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;
}
