public override void restore(JObject state) { base.restore(state); income = (bool)state.GetValue(INCOME); eventTimeGenerator = (AbstractProcess)AbstractStorable.newInstance((JObject)state.GetValue(PROCESS)); amountGenerator = (AbstractValue)AbstractStorable.newInstance((JObject)state.GetValue(AMOUNT)); }
/// <summary> /// Добавлене данных в конец дампа /// </summary> /// <param name="CurrentTime"></param> /// <param name="value"></param> public void AppendValue(UInt64 CurrentTime, AbstractValue value) { using (TimeStampInfo ts = new TimeStampInfo(value)) { AppendValue(CurrentTime, ts); } }
/// <summary> /// Преобразование AbstractValue в строку /// </summary> /// <param name="value"></param> /// <returns></returns> public static string ToTestBenchString(AbstractValue value) { if (value is STD_ULOGIC_VALUE) { return(ToTestBenchString(value as STD_ULOGIC_VALUE)); } if (value is BIT_VALUE) { return(ToTestBenchString(value as BIT_VALUE)); } if (value is BOOLEAN_VALUE) { return(ToTestBenchString(value as BOOLEAN_VALUE)); } if (value is IntegerValue) { return(ToTestBenchString(value as IntegerValue)); } if (value is RealValue) { return(ToTestBenchString(value as RealValue)); } if (value is STD_ULOGIC_VECTOR_VALUE) { return(ToTestBenchString(value as STD_ULOGIC_VECTOR_VALUE)); } if (value is BIT_VECTOR_VALUE) { return(ToTestBenchString(value as BIT_VECTOR_VALUE)); } return(string.Empty); }
public AbstractValue this[ISymValue sym] { get { sym = Find(sym); AbstractValue v = (AbstractValue)this.absMap[sym]; if (v == null) { v = this.elementLattice.Top; } return(v); } set { SymbolicValue sv = Find(sym); AbstractValue old = this[sym]; if (old != value) { AddAValUpdate(sv); if (this.elementLattice.IsTop(value)) { this.absMap = this.absMap.Remove(sv); } else { this.absMap = this.absMap.Add(sv, value); } } } }
/// <summary> /// Called internally to distinguish between reserve elements that are part of state and /// those in the background set of values. Not used directly in models. /// </summary> public override void FinalizeImport() { foreach (IComparable obj in this.FieldValues()) { AbstractValue.FinalizeImport(obj); } }
protected override bool AtMost(AbstractValue a, AbstractValue b) { AVal av = (AVal)a; AVal bv = (AVal)b; return(AVal.Join(av, bv) == bv); }
/// <summary> /// Signals execution framework that a user-defined coverage point has been passed. Coverage points /// may be used to guide execution so that relevant aspects of the model are represented in /// analysis and testing. For example, coverage points may include user-level requirements, projections /// of the current state or execution paths of the model program source. /// </summary> /// <param name="coveragePointValue">A value whose corresponding term is a user-defined coverage point.</param> /// <exception cref="ArgumentException">Thrown if <paramref name="coveragePointValue"/> does not satisfy the /// <see cref="AbstractValue.IsAbstractValue"/> condition</exception> /// <seealso cref="AbstractValue.GetTerm"/> static public void AddCoveragePoint(IComparable coveragePointValue) { if (!AbstractValue.IsAbstractValue(coveragePointValue)) { throw new ArgumentException(MessageStrings.CoveragePointTypeError); } InterpretationContext.GetCurrentContext().AddCoveragePoint(AbstractValue.GetTerm(coveragePointValue)); }
// Does not take styling information into account...and it needs to be taken into account. public override int GetHashCode() { var hash = 163; hash *= 79 + AbstractValue.GetHashCode(); hash *= 79 + ConcreteValue.GetHashCode(); return(hash); }
public override CompoundTerm DoStep(InterpretationContext c, CompoundTerm action) { // Result of invocation must be a value term (must support IComparable) IComparable /*?*/ thisArg; IComparable /*?*/[] methodArgs = this.ConvertTermArgumentsToMethodArguments(c, action.Arguments, out thisArg); foreach (IComparable /*?*/ o in methodArgs) { AbstractValue.FinalizeImport(o); } object /*?*/ resultObj = this.method.methodInfo.Invoke(thisArg, methodArgs); CompoundTerm /*?*/ finishAction = null; // Handle output args and return value if (null != this.finishActionMethod) { int nOutputs = this.finishActionMethod.actionLabel.Arguments.Count; Sequence <Term> outputs = Sequence <Term> .EmptySequence; for (int i = 0; i < nOutputs; i += 1) { int outputArgIndex = this.finishActionMethod.outputArgumentIndices[i]; if (-2 == outputArgIndex) // "any" placeholder { outputs = outputs.AddLast(Any.Value); } else { object output = (-1 == outputArgIndex ? resultObj : methodArgs[outputArgIndex]); IComparable outputAsComparable; if (null == output) { outputAsComparable = null; } else { outputAsComparable = output as IComparable; if (null == outputAsComparable) { throw new InvalidOperationException(MessageStrings.LocalizedFormat(MessageStrings.ComparableResultRequired, action.ToString(), output.ToString())); } } outputs = outputs.AddLast(AbstractValue.GetTerm(outputAsComparable)); } } finishAction = new CompoundTerm(this.FinishAction, outputs); } return(finishAction); }
public AbstractValue Evaluate(Or expr) { AbstractValue left = Evaluate(expr.Left); AbstractValue right = Evaluate(expr.Right); if ((left != null) && (right != null) && (left is STD_ULOGIC_VALUE) && (right is STD_ULOGIC_VALUE)) { return(STD_ULOGIC_VALUE.OR(left as STD_ULOGIC_VALUE, right as STD_ULOGIC_VALUE)); } throw new NotImplementedException(); }
/// <summary> /// Determines if this value has an object id (that is, is of type <see cref="LabeledInstance"/>), /// or has a subvalue that has an object id (for example, a set of instances). /// </summary> /// <returns>True if this value has an object id or contains a value with an object id.</returns> public override bool ContainsObjectIds() { foreach (IComparable obj in this.FieldValues()) { if (AbstractValue.ContainsObjectIds(obj)) { return(true); } } return(false); }
public AbstractValue Evaluate(LessThan expr) { AbstractValue left = Evaluate(expr.Left); AbstractValue right = Evaluate(expr.Right); if ((left != null) && (right != null) && (left is TIME_VALUE) && (right is TIME_VALUE)) { return(TIME_VALUE.LESS_THAN(left as TIME_VALUE, right as TIME_VALUE)); } throw new NotImplementedException(); }
public Label(FieldFont font, string content, HorizontalAlignment hAlign, AbstractValue horizontal, VerticalAlignment vAlign, AbstractValue vertical, AbstractValue width, AbstractValue height) : base(hAlign, horizontal, vAlign, vertical, width, height) { _font = font; Content = content; }
private SymbolicValue AddJointEdge(SymbolicValue v1target, SymbolicValue v2target, IUniqueKey function, SymbolicValue resultRoot) { SymbolicValue rtarget = (SymbolicValue)Map[v1target, v2target]; bool newBinding = false; if (rtarget == null) { // if we have visited v1target before, then the result graph is not isomorphic to G1 if (Map.ContainsKey1(v1target) || IsCommon(v1target) && v1target != v2target) { this.changed = true; } newBinding = true; if (v1target.UniqueId <= lastCommonVariable && v1target == v2target) { rtarget = v1target; // reuse old symbol } else { rtarget = Result.FreshSymbolicValue(); } this.Map = this.Map.Add(v1target, v2target, rtarget); } else { // See if info is already present SymbolicValue oldTarget = Result.LookupWithoutManifesting(resultRoot, function); if (oldTarget == rtarget) { // no change, don't record or change anything return(null); } } Result[resultRoot, function] = rtarget; AbstractValue aval1 = G1[v1target]; AbstractValue aval2 = G2[v2target]; AbstractValue aresult = G1.elementLattice.Join(aval1, aval2); Result[rtarget] = aresult; if (!G1.elementLattice.LowerThanOrEqual(aresult, aval1)) { this.changed = true; } if (Analyzer.Debug) { Console.WriteLine("AddJointEdge: {0} -{1}-> [{2},{3},{4}]", resultRoot, EGraph.Function2String(function), v1target, v2target, rtarget); } return((newBinding)?rtarget:null); }
public NinePatchImage(NinePatchRegion2D ninePatch, HorizontalAlignment hAlign, AbstractValue horizontal, VerticalAlignment vAlign, AbstractValue vertical, AbstractValue width, AbstractValue height) : base(hAlign, horizontal, vAlign, vertical, width, height) { NinePatch = ninePatch; }
public AbstractValue AbstractCall(CallType callType, IList <AbstractValue> args) { TargetSet ts = this.GetTargetSet(args.Count); if (ts != null) { return(ts.AbstractCall(callType, args)); } else { return(AbstractValue.TypeError(BadArgumentCount(callType, args.Count).Message)); } }
public Image(TextureRegion2D texture, HorizontalAlignment hAlign, AbstractValue horizontal, VerticalAlignment vAlign, AbstractValue vertical, AbstractValue width, AbstractValue height) : base(hAlign, horizontal, vAlign, vertical, width, height) { Texture = texture; }
public override void AddEvent(ulong NOW, ulong after, AbstractValue value, DelayMechanism delayMechanism) { IList <AbstractValue> childs = (value as CompositeValue).GetChilds(); for (int i = 0; i < dumps.Count; i++) { dumps[i].AddEvent(NOW, after, childs[i], delayMechanism); } foreach (AbstractValue i in childs) { i.Dispose(); } }
/// <summary> /// Получение значения текущего итератора в виде строки /// </summary> /// <returns></returns> public static string GetStringValue(IValueIterator iterator) { if (iterator.CurrentValue == null) { return("<NULL>"); } string result = string.Empty; AbstractValue val = iterator.CurrentValue.LastValue; result = DataContainer.ValueDump.DataConvertorUtils.ToString(val, iterator.DataRepresentation); return(result); }
internal static ParameterGenerator[] GetInputParameterGenerators(MethodInfo methodInfo) { ParameterInfo[] parameterInfos = methodInfo.GetParameters(); int nParameters = parameterInfos.Length; ParameterGenerator /*?*/[] result = new ParameterGenerator[nParameters]; for (int i = 0; i < nParameters; i += 1) { ParameterInfo pInfo = parameterInfos[i]; Type pType = pInfo.ParameterType; if (pType.IsByRef) { pType = pType.GetElementType(); } ParameterGenerator /*?*/ parameterGenerator = null; if (ReflectionHelper.IsInputParameter(pInfo)) { object /*?*/[] /*?*/ attrs1 = pInfo.GetCustomAttributes(typeof(DomainAttribute), true); // object/*?*/[]/*?*/ attrs2 = pInfo.GetCustomAttributes(typeof(_Attribute), true); // object/*?*/[]/*?*/ attrs3 = pInfo.GetCustomAttributes(typeof(NewAttribute), true); bool hasDomainAttr = (attrs1 != null && attrs1.Length > 0); if (hasDomainAttr) { DomainAttribute attr = (DomainAttribute)attrs1[0]; string attrName = attr.Name; if (string.Equals("new", attrName)) { Symbol sort = AbstractValue.TypeSort(pType); parameterGenerator = delegate() { return(new Set <Term>(LabeledInstance.PeekNextLabelTerm(sort))); }; } else { parameterGenerator = CreateDomainParameterGenerator(methodInfo, attr, pType); } } else { parameterGenerator = Method.GetDefaultParameterGenerator(pType); } } result[i] = parameterGenerator; } return(result); }
public AbstractValue Evaluate(Equals expr) { AbstractValue left = Evaluate(expr.Left); AbstractValue right = Evaluate(expr.Right); if ((left != null) && (right != null) && (left is STD_LOGIC_VALUE) && (right is STD_LOGIC_VALUE)) { return(STD_LOGIC_VALUE.EQUALS(left as STD_LOGIC_VALUE, right as STD_LOGIC_VALUE)); } if ((left != null) && (right != null) && (left is TIME_VALUE) && (right is TIME_VALUE)) { return(TIME_VALUE.EQUALS(left as TIME_VALUE, right as TIME_VALUE)); } if ((left != null) && (right != null) && (left is TIME_VALUE) && (right is PhysicalValue)) { return(TIME_VALUE.EQUALS(left as TIME_VALUE, right as PhysicalValue)); } throw new NotImplementedException(); }
public IComparable /*?*/ GetValue(InterpretationContext context) { if (!field.IsStatic) { // TO DO: Implement instance field maps Map <LabeledInstance, IComparable /*?*/> result = Map <LabeledInstance, IComparable /*?*/> .EmptyMap; Symbol sort = AbstractValue.TypeSort(field.DeclaringType); foreach (LabeledInstance instance in context.InstancePoolValues(sort)) { object obj = field.GetValue(instance); if (obj == null) { result = result.Add(instance, null); } else { IComparable comparable = obj as IComparable; if ((object)comparable == null) { throw new ArgumentException(MessageStrings.LocalizedFormat(MessageStrings.RuntimeTypeError, typeof(IComparable).ToString(), obj.GetType().ToString())); } result = result.Add(instance, comparable); } } return(result); } else { object obj = field.GetValue(null); if (obj == null) { return(null); } IComparable comparable = obj as IComparable; if ((object)comparable == null) { throw new ArgumentException(MessageStrings.LocalizedFormat(MessageStrings.RuntimeTypeError, typeof(IComparable).ToString(), obj.GetType().ToString())); } return(comparable); } }
public void Dump(TextWriter tw) { HashSet seen = new HashSet(); WorkList wl = new WorkList(); Console.WriteLine("LastSymbolId:{0}", this.idCounter); foreach (IUniqueKey function in this.termMap.Keys2(this.constRoot)) { SymbolicValue target = this[this.constRoot, function]; tw.WriteLine("{0} = {1}", Function2String(function), target); wl.Add(target); } while (!wl.IsEmpty()) { SymbolicValue v = (SymbolicValue)wl.Pull(); if (!seen.Add(v)) { continue; } foreach (IUniqueKey function in this.termMap.Keys2(v)) { SymbolicValue target = this[v, function]; tw.WriteLine("{0}({2}) = {1}", Function2String(function), target, v); wl.Add(target); } } tw.WriteLine("**Abstract value map"); foreach (SymbolicValue v in seen) { AbstractValue aval = this[v]; if (!this.elementLattice.IsTop(aval)) { tw.WriteLine("{0} -> {1}", v, aval); } } }
public AbstractValue AbstractCall(AbstractContext context, IList <AbstractValue> args) { AbstractValue[] callArgs = new AbstractValue[_argBuilders.Count]; for (int i = 0; i < _argBuilders.Count; i++) { callArgs[i] = _argBuilders[i].AbstractBuild(context, args); } Expression[] argExprs = new Expression[callArgs.Length]; for (int i = 0; i < callArgs.Length; i++) { Expression expr = callArgs[i].Expression; if (expr == null) { argExprs = null; break; } else { argExprs[i] = expr; } } Expression callExpr = null; if (argExprs != null) { MethodInfo mi = Method as MethodInfo; if (mi != null) { Expression instance = mi.IsStatic ? null : _instanceBuilder.AbstractBuild(context, args).Expression; callExpr = Ast.SimpleCallHelper(instance, mi, argExprs); } else { callExpr = Ast.SimpleNewHelper((ConstructorInfo)Method, argExprs); } } return(AbstractValue.LimitType(this.ReturnType, callExpr)); }
public AbstractValue Evaluate(Not expr) { AbstractValue val = Evaluate(expr.Expression); if ((val != null) && (val is CHARACTER_VALUE)) { STD_LOGIC_VALUE v = STD_LOGIC_VALUE.CreateSTD_LOGIC_VALUE(((val as CHARACTER_VALUE).Value as VHDL.type.EnumerationType.CharacterEnumerationLiteral).getLiteral()); return(STD_LOGIC_VALUE.NOT(v as STD_LOGIC_VALUE)); } if ((val != null) && (val is STD_LOGIC_VALUE)) { return(STD_LOGIC_VALUE.NOT(val as STD_LOGIC_VALUE)); } if ((val != null) && (val is STD_ULOGIC_VALUE)) { return(STD_ULOGIC_VALUE.NOT(val as STD_ULOGIC_VALUE)); } return(null); }
public AbstractValue AbstractCall(CallType callType, IList <AbstractValue> args) { Type[] types = AbstractValue.GetTypes(args); List <MethodCandidate> targets = SelectTargets(callType, types, SymbolId.EmptySymbols); if (targets.Count == 1) { return(targets[0].Target.AbstractCall(new AbstractContext(_binder._binder), args)); } else { if (targets.Count == 0) { return(AbstractValue.TypeError(NoApplicableTargetMessage(callType, types))); } else { return(AbstractValue.TypeError(MultipleTargetsMessage(targets, callType, types))); } } }
static ParameterGenerator /*?*/ GetDefaultParameterGenerator(Type pType) { if (typeof(bool).Equals(pType)) { Set <Term> values = new Set <Term>(AbstractValue.GetTerm(true), AbstractValue.GetTerm(false)); return(delegate() { return values; }); } if (pType.IsSubclassOf(typeof(System.Enum))) { Set <Term> values = Set <Term> .EmptySet; foreach (System.Enum rawValue in System.Enum.GetValues(pType)) { values = values.Add(AbstractValue.GetTerm(rawValue)); } return(delegate() { return values; }); } return(null); }
public override void Replay(MergeState merge) { if (!merge.IsCommon(this.sv)) { return; } AbstractValue av1 = merge.G1[this.sv]; AbstractValue av2 = merge.G2[this.sv]; AbstractValue old = merge.Result[this.sv]; AbstractValue join = merge.Result.elementLattice.Join(av1, av2); if (join != av1 && merge.Result.elementLattice.LowerThanOrEqual(av1, join)) { merge.changed = true; } if (join != old) { merge.Result[this.sv] = join; } }
public override void AddEvent(ulong NOW, ulong after, AbstractValue value, VHDL.DelayMechanism delayMechanism) { AbstractTimeStampInfo <T> newValue = new AbstractTimeStampInfo <T>(valueCovertor.GetValue(value)); if (delayMechanism is VHDL.TRANSPORTDelayMechanism) { dump.AddTransportEvent(NOW + after, newValue); return; } if (delayMechanism.PulseRejectionLimit != null) { TIME_VALUE reject = ExpressionEvaluator.DefaultEvaluator.Evaluate(delayMechanism.PulseRejectionLimit) as TIME_VALUE; dump.AddInertialEvent(NOW, NOW + after, newValue, (UInt64)reject.DoubleValue); return; } if (delayMechanism is VHDL.INERTIALDelayMechanism) { dump.AddInertialEvent(NOW, NOW + after, newValue); return; } }
/// <summary> /// Добавление данных в конец дампа /// </summary> /// <param name="CurrentTime"></param> /// <param name="value"></param> public override void AppendValue(UInt64 CurrentTime, TimeStampInfo value) { if (value.Count == 0) { return; } AbstractTimeStampInfo <T> newValue = valueCovertor.GetAbstractTimeStampInfo(value); if (dump.Count >= 1) { UInt64 lastTime = dump.Keys[dump.Count - 1]; AbstractTimeStampInfo <T> lastInfo = dump.Values[dump.Count - 1]; if (lastTime < CurrentTime) { using (AbstractValue first_value = value.FirstValue) { if (first_value.Equals(lastInfo.LastValue)) { value.Info.Remove(0); } if (value.Count != 0) { dump.Add(CurrentTime, newValue); } } } else { dump.Append(CurrentTime, newValue); } } else { dump.Append(CurrentTime, newValue); } }
public override AbstractValue NontrivialJoin(AbstractValue a, AbstractValue b) { return AVal.Join((AVal)a, (AVal)b); }
protected override bool AtMost(AbstractValue a, AbstractValue b) { AVal av = (AVal)a; AVal bv = (AVal)b; return (av.Assigned || !bv.Assigned) && (av.Unassigned || !bv.Unassigned); }
protected override bool AtMost(AbstractValue a, AbstractValue b) { AVal av = (AVal)a; AVal bv = (AVal)b; return (av.IsNonNull || !bv.IsNonNull); }
public AbstractValue AbstractCall(AbstractContext context, IList<AbstractValue> args) { AbstractValue[] callArgs = new AbstractValue[_argBuilders.Count]; for (int i = 0; i < _argBuilders.Count; i++) { callArgs[i] = _argBuilders[i].AbstractBuild(context, args); } Expression[] argExprs = new Expression[callArgs.Length]; for (int i = 0; i < callArgs.Length; i++) { Expression expr = callArgs[i].Expression; if (expr == null) { argExprs = null; break; } else { argExprs[i] = expr; } } Expression callExpr = null; if (argExprs != null) { MethodInfo mi = Method as MethodInfo; if (mi != null) { Expression instance = mi.IsStatic ? null : _instanceBuilder.AbstractBuild(context, args).Expression; callExpr = Ast.SimpleCallHelper(instance, mi, argExprs); } else { callExpr = Ast.SimpleNewHelper((ConstructorInfo)Method, argExprs); } } return AbstractValue.LimitType(this.ReturnType, callExpr); }
protected override bool AtMost(AbstractValue a, AbstractValue b) { AVal av = (AVal)a; AVal bv = (AVal)b; return AVal.Join(av, bv) == bv; }