public static void Test1() { int length = 100; int loop = 1; Valuation valuation = new Valuation(); Expression exp = new IntConstant(1); for (int i = 0; i < length; i++) { exp = new PrimitiveApplication(PrimitiveApplication.PLUS, exp, new IntConstant(1)); } Console.WriteLine(DateTime.Now.ToLongTimeString() + DateTime.Now.Millisecond); for (int i = 0; i < loop; i++) { EvaluatorDenotational.Evaluate(exp, valuation); } Console.WriteLine(DateTime.Now.ToLongTimeString() + DateTime.Now.Millisecond); DynamicMethod method = GetDynamicMethodOfExpression(exp); for (int i = 0; i < loop; i++) { method.Invoke(null, null); } Console.WriteLine(DateTime.Now.ToLongTimeString() + DateTime.Now.Millisecond); Console.WriteLine("---------------------"); //--------------------------------------------------- exp = new Variable(var1); for (int i = 0; i < length; i++) { exp = new PrimitiveApplication(PrimitiveApplication.PLUS, exp, new Variable(var1)); } valuation.Variables = new StringDictionaryWithKey <ExpressionValue>(); valuation.Variables.Add(var1, new IntConstant(1)); Console.WriteLine(DateTime.Now.ToLongTimeString() + DateTime.Now.Millisecond); for (int i = 0; i < loop; i++) { EvaluatorDenotational.Evaluate(exp, valuation); } Console.WriteLine(DateTime.Now.ToLongTimeString() + DateTime.Now.Millisecond); method = GetDynamicMethodOfExpression(exp); for (int i = 0; i < loop; i++) { UpdateVarsBasedOnValuation(valuation); object value = method.Invoke(null, null); Console.WriteLine(value); UpdateValuationBasedOnClassValues(valuation); } Console.WriteLine(DateTime.Now.ToLongTimeString() + DateTime.Now.Millisecond); }
/// <summary> /// Clone only the relevant environment, i.e., the variables provided. /// </summary> /// <param name="visibleVars"></param> /// <returns></returns> public virtual Valuation GetVariableClone(List <string> visibleVars) { Valuation newEnv = new Valuation(); if (Variables != null) { StringDictionaryWithKey <ExpressionValue> newVar = new StringDictionaryWithKey <ExpressionValue>(); foreach (StringDictionaryEntryWithKey <ExpressionValue> pair in Variables._entries) { if (pair != null) { foreach (string var in visibleVars) { if (var == pair.Key) { newVar.Add(pair.Key, pair.Value.GetClone()); break; } } } } newEnv.Variables = newVar; } newEnv.Channels = this.Channels; return(newEnv); }
public override void MoveOneStep(Valuation GlobalEnv, List<Configuration> list) { System.Diagnostics.Debug.Assert(list.Count == 0); FirstProcess.MoveOneStep(GlobalEnv, list); for (int i = 0; i < list.Count; i++) { Configuration step = list[i]; if (step.Event != Constants.TERMINATION) { Interrupt inter = new Interrupt(step.Process, SecondProcess); step.Process = inter; } } List<Configuration> list2 = new List<Configuration>(); SecondProcess.MoveOneStep(GlobalEnv, list2); for (int i = 0; i < list2.Count; i++) { Configuration step = list2[i]; if (step.Event == Constants.TAU) { Interrupt inter = new Interrupt(FirstProcess, step.Process); step.Process = inter; } list.Add(step); } //return returnList; }
public virtual Valuation GetClone() { Valuation newEnv = new Valuation(); if (Variables != null) { StringDictionaryWithKey <ExpressionValue> newVars = new StringDictionaryWithKey <ExpressionValue>(Variables); for (int i = 0; i < Variables._entries.Length; i++) { StringDictionaryEntryWithKey <ExpressionValue> pair = Variables._entries[i]; if (pair != null) { newVars._entries[i] = new StringDictionaryEntryWithKey <ExpressionValue>(pair.HashA, pair.HashB, pair.Value.GetClone(), pair.Key); } } newEnv.Variables = newVars; } if (Channels != null) { newEnv.Channels = new Dictionary <string, ChannelQueue>(this.Channels); } return(newEnv); }
/// <summary> /// Set fields to values as valuation /// </summary> /// <param name="valuation"></param> private static void UpdateVarsBasedOnValuation(Valuation valuation) { if (valuation.Variables != null) { foreach (StringDictionaryEntryWithKey <ExpressionValue> pair in valuation.Variables._entries) { if (pair != null) { if (pair.Value is RecordValue) { RecordValue arrayOfValues = pair.Value as RecordValue; int[] values = new int[arrayOfValues.Associations.Length]; for (int i = 0; i < values.Length; i++) { values[i] = int.Parse(arrayOfValues.Associations[i].ExpressionID); } SetValue(pair.Key, values); } else if (pair.Value is BoolConstant) { int value = (pair.Value as BoolConstant).Value ? 1 : 0; SetValue(pair.Key, value); } else { SetValue(pair.Key, int.Parse(pair.Value.ExpressionID)); } } } } }
/** * BASE CLASS VARIABLEs * * public string Event; * public string DisplayName; * public Valuation GlobalEnv; //-> the global variable * * public bool IsDeadLock; //-> fire to mark when checking Deadlock Assertion * public bool IsAtomic; * public bool IsDataOperation; * public string[] ParticipatingProcesses; */ /// <summary> /// This constructor is called from the assertion to intial a configuration /// /// Status: incompleted: How to initial value for globalEnv /// </summary> /// <param name="p"></param> /// <param name="e"></param> /// <param name="displayName"></param> /// <param name="globalEnv"></param> /// <param name="isDataOperation"></param> public PNConfiguration(PetriNet p, string e, string displayName, Valuation globalEnv, bool isDataOperation) { Process = p; Event = e;//base event GlobalEnv = globalEnv; DisplayName = displayName; IsDataOperation = isDataOperation; }
public Configuration(Process p, string e, string displayName, Valuation globalEnv, bool isDataOperation) { Process = p; Event = e; GlobalEnv = globalEnv; DisplayName = displayName; IsDataOperation = isDataOperation; }
/// <summary> /// Update the valuation after evaluating the expression /// </summary> /// <param name="funcName"></param> /// <param name="valuation"></param> private static void RunProgramBlock(Expression expression, Valuation valuation) { UpdateVarsBasedOnValuation(valuation); EvaluateExpression(expression); UpdateValuationBasedOnClassValues(valuation); }
/// <summary> /// Add channel variable to model from channel delcaration in Valuation /// </summary> /// <param name="valuation"></param> public void AddGlobalChannel(Valuation valuation) { if (valuation.Channels != null && valuation.Channels.Count > 0) { foreach (KeyValuePair<string, ChannelQueue> pair in valuation.Channels) { model.AddGlobalChannel(pair.Key, pair.Value.Size); } } }
/// <summary> /// todo: when channel clone, we also clone the DMB, since they are used together always. /// </summary> /// <returns></returns> public virtual Valuation GetChannelClone() { Valuation newEnv = new Valuation(); newEnv.Variables = this.Variables; Debug.Assert(Channels != null); newEnv.Channels = new Dictionary <string, ChannelQueue>(this.Channels); return(newEnv); }
public override void MoveOneStep(Valuation GlobalEnv, List<Configuration> list) { System.Diagnostics.Debug.Assert(list.Count == 0); Process.MoveOneStep(GlobalEnv, list); foreach (Configuration configuration in list) { configuration.Process = new AtomicProcess(configuration.Process, true); configuration.IsAtomic = Started; } }
public override string GetEventID(Valuation global) { if (ExpressionList.Length > 0) { ExpressionValue v = EvaluatorDenotational.Evaluate(ExpressionList[0], global); return BaseName + "[" + v.ExpressionID + "]"; } else { return BaseName; } }
public override void MoveOneStep(Valuation GlobalEnv, List<Configuration> list) { System.Diagnostics.Debug.Assert(list.Count == 0); ExpressionValue v = EvaluatorDenotational.Evaluate(Condition, GlobalEnv); if ((v as BoolConstant).Value) { Process.MoveOneStep(GlobalEnv, list); } //return new List<Configuration>(0); }
public override void MoveOneStep(Valuation GlobalEnv, List<Configuration> list) { ExpressionValue v = EvaluatorDenotational.Evaluate(ConditionalExpression, GlobalEnv); if ((v as BoolConstant).Value) { FirstProcess.MoveOneStep(GlobalEnv, list); } else { SecondProcess.MoveOneStep(GlobalEnv, list); } }
/// <summary> /// returns all the possible moves of the current process /// </summary> /// <returns></returns> public override void MoveOneStep(Valuation GlobalEnv, List<Configuration> list) { //TODO: the operational semantics should be implemented here //string ID = Event.GetEventID(eStep.GlobalEnv); //string name = Event.GetEventName(eStep.GlobalEnv); //if(ID != name) //{ // list.Add(new Configuration(Process, ID ,name, eStep.GlobalEnv, false)); //} //else //{ // list.Add(new Configuration(Process, ID, null, eStep.GlobalEnv, false)); //} }
public override void MoveOneStep(Valuation GlobalEnv, List<Configuration> list) { System.Diagnostics.Debug.Assert(list.Count == 0); ExpressionValue v = EvaluatorDenotational.Evaluate(ConditionalExpression, GlobalEnv); if ((v as BoolConstant).Value) { list.Add(new Configuration(new Stop(), Constants.TERMINATION, null, GlobalEnv, false)); } else { throw new RuntimeException("Assertion at line " + LineNumber + " failed: " + ConditionalExpression.ToString()); } }
// added by Tinh public PNConfiguration(PetriNet p, string e, string displayName, Valuation globalEnv, bool isDataOperation, SpecificationBase spec) { Process = p; Event = e;//base event GlobalEnv = globalEnv; DisplayName = displayName; IsDataOperation = isDataOperation; if (spec != null) { p.Transitions = new List<PNTransition>(16); foreach (KeyValuePair<string, PetriNet> entry in (spec as Specification).PNDefinitionDatabase) p.Transitions.AddRange(entry.Value.Transitions); } }
public override void MoveOneStep(Valuation GlobalEnv, List<Configuration> list) { System.Diagnostics.Debug.Assert(list.Count == 0); ExpressionValue v = EvaluatorDenotational.Evaluate(ConditionalExpression, GlobalEnv); if ((v as BoolConstant).Value) { list.Add(new Configuration(FirstProcess, Constants.TAU, "[if(" + ConditionalExpression + ")]", GlobalEnv, false)); } else { list.Add(new Configuration(SecondProcess, Constants.TAU, "[else(" + ConditionalExpression + ")]", GlobalEnv, false)); } }
private static void AddFields(Valuation valuation) { if (valuation.Variables != null && valuation.Variables.Count > 0) { foreach (StringDictionaryEntryWithKey <ExpressionValue> pair in valuation.Variables._entries) { if (pair != null) { if (pair.Value is RecordValue) { AddField(pair.Key, typeof(int[])); } else { AddField(pair.Key, typeof(int)); } } } } }
private static void UpdateValuationBasedOnClassValues(Valuation valuation) { if (valuation.Variables != null) { foreach (StringDictionaryEntryWithKey <ExpressionValue> pair in valuation.Variables._entries) { if (pair != null) { if (pair.Value is RecordValue) { RecordValue recordValue = (RecordValue)pair.Value; int[] values = (int[])GetValue(pair.Key); for (int i = 0; i < values.Length; i++) { if (recordValue.Associations[0] is IntConstant) { recordValue.Associations[i] = new IntConstant(values[i]); } else { recordValue.Associations[i] = new BoolConstant(values[i] > 0); } } } else if (pair.Value is BoolConstant) { int value = (int)GetValue(pair.Key); pair.Value = new BoolConstant(value > 0); } else { int value = (int)GetValue(pair.Key); pair.Value = new IntConstant(value); } } } } }
public virtual Valuation GetVariableChannelClone(List <string> visibleVars, List <string> visibleChannels) { Valuation newEnv = GetVariableClone(visibleVars); if (Channels != null) { Dictionary <string, ChannelQueue> channels = new Dictionary <string, ChannelQueue>(); foreach (KeyValuePair <string, ChannelQueue> pair in Channels) { if (visibleChannels.Contains(pair.Key)) { if (pair.Value.Size != 0) { channels.Add(pair.Key, pair.Value); } } } newEnv.Channels = channels; } return(newEnv); }
/// <summary> /// Based on the list of global variables in the Valuation, add them to the model /// </summary> /// <param name="valuation"></param> public void AddGlobalVars(Valuation valuation) { if (valuation.Variables != null && valuation.Variables.Count > 0) { foreach (StringDictionaryEntryWithKey<ExpressionValue> pair in valuation.Variables._entries) { if (pair != null) { int lowerBound = Model.BDD_INT_LOWER_BOUND; if (Valuation.VariableLowerBound.ContainsKey(pair.Key)) { lowerBound = Valuation.VariableLowerBound.GetContainsKey(pair.Key); } int upperBound = Model.BDD_INT_UPPER_BOUND; if (Valuation.VariableUpperLowerBound.ContainsKey(pair.Key)) { upperBound = Valuation.VariableUpperLowerBound.GetContainsKey(pair.Key); } if (pair.Value is RecordValue) { RecordValue array = pair.Value as RecordValue; this.model.AddGlobalArray(pair.Key, array.Associations.Length, lowerBound, upperBound); } else if (pair.Value is BoolConstant) { this.model.AddGlobalVar(pair.Key, 0, 1); } else { this.model.AddGlobalVar(pair.Key, lowerBound, upperBound); } } } } }
/// <summary> /// Add global variables and environment variables /// </summary> /// <param name="valuation"></param> /// <param name="assertion"></param> public BDDEncoder(Valuation valuation) { model = new Model(); //4 more events for Tau, Terminate, and temp, and tock Model.NUMBER_OF_EVENT += 4; //each event with global update, add Model.NUMBER_OF_EVENT to its index model.AddSingleCopyVar(Model.EVENT_NAME, 0, Model.NUMBER_OF_EVENT - 1); this.allEventIndex.Add(new EventChannelInfo(Constants.TAU, 0, EventChannelInfo.EventType.EVENT)); this.allEventIndex.Add(new EventChannelInfo(Constants.TERMINATION, 0, EventChannelInfo.EventType.EVENT)); this.allEventIndex.Add(new EventChannelInfo(Constants.TOCK, 0, EventChannelInfo.EventType.EVENT)); for (int i = 0; i < Model.MAX_NUMBER_EVENT_PARAMETERS; i++) { string varName = Model.EVENT_NAME + Model.NAME_SEPERATOR + i; model.eventParameterVariables.Add(varName); model.AddSingleCopyVar(varName, Model.MIN_EVENT_INDEX[i], Model.MAX_EVENT_INDEX[i]); } // AddGlobalVars(valuation); AddGlobalChannel(valuation); }
public override void MoveOneStep(Valuation GlobalEnv, List<Configuration> list) { System.Diagnostics.Debug.Assert(list.Count == 0); bool allTerminationCount = true; bool hasAtomicTermination = false; for (int i = 0; i < Processes.Count; i++) { Process process = Processes[i]; List<Configuration> list1 = new List<Configuration>(); process.MoveOneStep(GlobalEnv, list1); bool hasTermination = false; for (int j = 0; j < list1.Count; j++) { Configuration step = list1[j]; if (step.Event == Constants.TERMINATION) { hasTermination = true; if (step.IsAtomic) { hasAtomicTermination = true; } } else { if (AssertionBase.CalculateParticipatingProcess) { step.ParticipatingProcesses = new string[] {i.ToString()}; } List<Process> newProcess = new List<Process>(Processes.Count); newProcess.AddRange(Processes); newProcess[i] = step.Process; IndexInterleave interleave = new IndexInterleave(newProcess); step.Process = interleave; list.Add(step); } } //to check whether there are synchoronous channel input/output if (Specification.HasSyncrhonousChannel) { SynchronousChannelInputOutput(list, i, GlobalEnv, null); } if (!hasTermination) { allTerminationCount = false; } } if (allTerminationCount) { Configuration temp = new Configuration(new Stop(), Constants.TERMINATION, null, GlobalEnv, false); if (hasAtomicTermination) { temp.IsAtomic = true; } if (AssertionBase.CalculateParticipatingProcess) { temp.ParticipatingProcesses = new string[Processes.Count]; for (int i = 0; i < Processes.Count; i++) { temp.ParticipatingProcesses[i] = i.ToString(); } } list.Add(temp); } //return returnList; }
public override void SyncOutput(Valuation GlobalEnv, List<ConfigurationWithChannelData> list) { for (int i = 0; i < Processes.Count; i++) { List<ConfigurationWithChannelData> list1 = new List<ConfigurationWithChannelData>(); Processes[i].SyncOutput(GlobalEnv, list1); list.AddRange(list1); } }
private static ExpressionValue EvalPrimAppl(PrimitiveApplication application, ExpressionValue x1, Expression x2Exp, Valuation env) { try { ExpressionValue x2; switch (application.Operator) { case "<": x2 = Evaluate(x2Exp, env); return new BoolConstant(((IntConstant)x1).Value < ((IntConstant)x2).Value); case "<=": x2 = Evaluate(x2Exp, env); return new BoolConstant(((IntConstant)x1).Value <= ((IntConstant)x2).Value); case ">": x2 = Evaluate(x2Exp, env); return new BoolConstant(((IntConstant)x1).Value > ((IntConstant)x2).Value); case ">=": x2 = Evaluate(x2Exp, env); return new BoolConstant(((IntConstant)x1).Value >= ((IntConstant)x2).Value); case "==": x2 = Evaluate(x2Exp, env); return new BoolConstant(x1.ExpressionID == x2.ExpressionID); case "!=": x2 = Evaluate(x2Exp, env); //return new BoolConstant(((IntConstant)x1).Value != ((IntConstant)x2).Value); return new BoolConstant(x1.ExpressionID != x2.ExpressionID); case "&&": if(((BoolConstant)x1).Value) { x2 = Evaluate(x2Exp, env); return new BoolConstant(((BoolConstant)x2).Value); } else { return new BoolConstant(false); } case "||": if (!((BoolConstant)x1).Value) { x2 = Evaluate(x2Exp, env); return new BoolConstant(((BoolConstant)x2).Value); } else { return new BoolConstant(true); } case "xor": x2 = Evaluate(x2Exp, env); return new BoolConstant(((BoolConstant)x1).Value ^ ((BoolConstant)x2).Value); case "!": return new BoolConstant(!((BoolConstant)x1).Value); case "+": x2 = Evaluate(x2Exp, env); return new IntConstant(((IntConstant)x1).Value + ((IntConstant)x2).Value); case "-": x2 = Evaluate(x2Exp, env); return new IntConstant(((IntConstant)x1).Value - ((IntConstant)x2).Value); case "*": x2 = Evaluate(x2Exp, env); return new IntConstant(((IntConstant)x1).Value * ((IntConstant)x2).Value); case "/": x2 = Evaluate(x2Exp, env); if (((IntConstant)x2).Value == 0) { throw new ArithmeticException("Divide by Zero on " + application.ToString()); } else { return new IntConstant(((IntConstant)x1).Value / ((IntConstant)x2).Value); } case "mod": x2 = Evaluate(x2Exp, env); if (((IntConstant)x2).Value == 0) { throw new ArithmeticException("Modulo by Zero on " + application.ToString()); } else { int int_X1 = ((IntConstant) x1).Value; int int_X2 = ((IntConstant) x2).Value; int tmp = int_X1 % int_X2; return new IntConstant((tmp >= 0) ? tmp : (tmp + int_X2)); } //case "empty" : // return new Value(((RecordValue) x1).Empty); //case "hasproperty": // return new Value(((RecordValue)x1).HasProperty(((PropertyValue)x2).PropertyName)); case ".": RecordValue record = (RecordValue)x1; x2 = Evaluate(x2Exp, env); int index = ((IntConstant)x2).Value; if (index < 0) { throw new NegativeArraySizeException("Access negative index " + index + " for variable " + application.Argument1.ToString() + " in expression " + application.ToString()); } else if (index >= record.Associations.Length) { throw new IndexOutOfBoundsException("Index " + index + " is out of range for variable " + application.Argument1.ToString() + " in expression " + application.ToString()); } return record.Associations[index]; case "~": return new IntConstant(-((IntConstant)x1).Value); //Bitwise operators used by NESC module case "<<"://bitwise left shift x2 = Evaluate(x2Exp, env); return new IntConstant(((IntConstant)x1).Value << ((IntConstant)x2).Value); case ">>"://bitwise right shift x2 = Evaluate(x2Exp, env); return new IntConstant(((IntConstant)x1).Value >> ((IntConstant)x2).Value); case "&"://bitwise AND x2 = Evaluate(x2Exp, env); return new IntConstant(((IntConstant)x1).Value & ((IntConstant)x2).Value); case "^"://bitwise XOR x2 = Evaluate(x2Exp, env); return new IntConstant(((IntConstant)x1).Value ^ ((IntConstant)x2).Value); case "|"://bitwise OR x2 = Evaluate(x2Exp, env); return new IntConstant(((IntConstant)x1).Value | ((IntConstant)x2).Value); } } catch (InvalidCastException ex) { throw new RuntimeException("Invalid Cast Exception for " + application.ToString() + ": " + ex.Message.Replace("PAT.Common.Classes.Expressions.ExpressionClass.", "")); } //catch (Exception ex1) //{ // throw new RuntimeException("Invalid Primitive Operation: " + application.ToString() + "!"); //} throw new RuntimeException("Invalid Primitive Operation: " +application.ToString() + "!"); }
// evaluate starts evaluation with fresh environment public static ExpressionValue Evaluate(Expression exp, Valuation env) { switch (exp.ExpressionType) { case ExpressionType.Constant: return exp as ExpressionValue; case ExpressionType.Variable: // Look up variable in environment; we assume // that value is found try { return env.Variables[exp.expressionID]; } catch (KeyNotFoundException) { throw new EvaluatingException("Access the non existing variable: " + exp.expressionID); } catch (Exception ex) { throw new EvaluatingException("Variable evaluation exception for variable '" + exp.expressionID + "':" + ex.Message); } case ExpressionType.Record: { Expression[] ass = ((Record)exp).Associations; ExpressionValue[] values = new ExpressionValue[ass.Length]; for (int i = 0; i < ass.Length; i++) { //rv.Put(association.Property, store.Extend(Eval(association.Expression, env))); //rv.Put(Eval(association, env)); values[i] = Evaluate(ass[i], env); #if !OPTIMAL_FOR_EXP if(values[i] == null) { throw new RuntimeException("Invalid expression assignment: " + exp); } #endif } RecordValue rv = new RecordValue(values); return rv; } case ExpressionType.PrimitiveApplication: // First evaluate the first argument, then the second, and // then evaluate using evalPrimAppl. { PrimitiveApplication newexp = exp as PrimitiveApplication; ExpressionValue x1 = Evaluate(newexp.Argument1, env); Debug.Assert(x1 != null); #if !OPTIMAL_FOR_EXP if (x1 == null) { throw new RuntimeException("Invalid expression assignment: " + exp); } #endif return EvalPrimAppl(newexp, x1, newexp.Argument2, env); } case ExpressionType.Assignment: { //Assign the rhs to lhs String lhs = ((Assignment) exp).LeftHandSide; Expression rhs = ((Assignment) exp).RightHandSide; ExpressionValue rhsV = Evaluate(rhs, env); #if !OPTIMAL_FOR_EXP if (rhsV == null) { throw new RuntimeException("Invalid expression assignment: " + exp); } Valuation.CheckVariableRange(lhs, rhsV); #endif env.Variables[lhs] = rhsV; return rhsV; } case ExpressionType.PropertyAssignment: { try { PropertyAssignment pa = (PropertyAssignment) exp; RecordValue rec = (RecordValue) Evaluate(pa.RecordExpression, env); IntConstant pro = (IntConstant) Evaluate(pa.PropertyExpression, env); ExpressionValue rhs = Evaluate(pa.RightHandExpression, env); //rec.Put(pro.PropertyName, store.Extend(rhs)); int index = pro.Value; if (index < 0) { throw new NegativeArraySizeException("Access negative index " + index + " for variable " + pa.RecordExpression.ToString()); } else if (index >= rec.Associations.Length) { throw new IndexOutOfBoundsException("Index " + index + " is out of range for variable " + pa.RecordExpression.ToString()); } #if !OPTIMAL_FOR_EXP if (rhs == null) { throw new RuntimeException("Invalid expression assignment: " + exp); } Valuation.CheckVariableRange(pa.RecordExpression.ToString(), rhs); #endif rec.Associations[index] = rhs; //Note:Important!!! must recalculate the ID here, otherwise ID is obsolete and the verification result is wrong rec.GetID(); return rhs; } catch (InvalidCastException ex) { throw new RuntimeException("Invalid Cast Exception for " + exp + ": " + ex.Message.Replace("PAT.Common.Classes.Expressions.ExpressionClass.", "")); } } case ExpressionType.If: // Conditionals are evaluated by evaluating the then-part or // else-part depending of the result of evaluating the condition. { ExpressionValue cond = Evaluate(((If)exp).Condition, env); if (((BoolConstant) cond).Value) { return Evaluate(((If) exp).ThenPart, env); } else if (((If)exp).ElsePart != null) { return Evaluate(((If) exp).ElsePart, env); } else { return null; } } case ExpressionType.Sequence: // firstPart;secondPart Expression fP = ((Sequence) exp).FirstPart; Expression sP = ((Sequence) exp).SecondPart; Evaluate(fP, env); return Evaluate(sP, env); case ExpressionType.While: Expression test = ((While) exp).Test; Expression body = ((While) exp).Body; // the value of test may not be a Value. // here we assume it is always a Value, which // may cause run time exception due to non-Value. if (((BoolConstant) Evaluate(test, env)).Value) { // test is ture Evaluate(body, env); // body serves to change the store return Evaluate(exp, env); // evaluate the While again } else { return null; } case ExpressionType.StaticMethodCall: try { StaticMethodCall methodCall = (StaticMethodCall)exp; if (methodCall.Arguments.Length > 0) { ChannelQueue queue; string cname = null; if ((methodCall.Arguments[0] is Variable)) { cname = (methodCall.Arguments[0] as Variable).ExpressionID; } else if (methodCall.Arguments[0] is PrimitiveApplication) { PrimitiveApplication pa = (methodCall.Arguments[0] as PrimitiveApplication); ExpressionValue ind = Evaluate(pa.Argument2, env); cname = pa.Argument1 + "[" + ind + "]"; } switch (methodCall.MethodName) { case Common.Classes.Ultility.Constants.cfull: if (env.Channels.TryGetValue(cname, out queue)) { return new BoolConstant(queue.IsFull()); } else { throw new RuntimeException("Channel " + cname + " is not used in the model. Therefore it is meaningless to query channel information using " + methodCall + "."); } case Common.Classes.Ultility.Constants.cempty: if (env.Channels.TryGetValue(cname, out queue)) { return new BoolConstant(queue.IsEmpty()); } else { throw new RuntimeException("Channel " + cname + " is not used in the model. Therefore it is meaningless to query channel information using " + methodCall + "."); } case Common.Classes.Ultility.Constants.ccount: if (env.Channels.TryGetValue(cname, out queue)) { return new IntConstant(queue.Count); } else { throw new RuntimeException("Channel " + cname + " is not used in the model. Therefore it is meaningless to query channel information using " + methodCall + "."); } case Common.Classes.Ultility.Constants.csize: if (env.Channels.TryGetValue(cname, out queue)) { return new IntConstant(queue.Size); } else { throw new RuntimeException("Channel " + cname + " is not used in the model. Therefore it is meaningless to query channel information using " + methodCall + "."); } case Common.Classes.Ultility.Constants.cpeek: if (env.Channels.TryGetValue(cname, out queue)) { if (queue.Count == 0) { throw new IndexOutOfBoundsException("Channel " + cname + "'s buffer is empty!"); } return new RecordValue(queue.Peek()); } else { throw new RuntimeException("Channel " + cname + " is not used in the model. Therefore it is meaningless to query channel information using " + methodCall + "."); } } } object[] paras = new object[methodCall.Arguments.Length]; for (int i = 0; i < paras.Length; i++) { ExpressionValue x1 = Evaluate(methodCall.Arguments[i], env); paras[i] = GetValueFromExpression(x1); } string key = methodCall.MethodName + paras.Length; if (Common.Utility.Utilities.CSharpMethods.ContainsKey(key)) { object resultv = Common.Utility.Utilities.CSharpMethods[key].Invoke(null, paras); if (Common.Utility.Utilities.CSharpMethods[key].ReturnType.Name == "Void") { return null; } if (resultv is bool) { return new BoolConstant((bool)resultv); } else if (resultv is int || resultv is short || resultv is byte || resultv is double) { return new IntConstant(Convert.ToInt32(resultv)); } else if (resultv is int[]) { int[] list = resultv as int[]; ExpressionValue[] vals = new ExpressionValue[list.Length]; for (int i = 0; i < vals.Length; i++) { vals[i] = new IntConstant(list[i]); } return new RecordValue(vals); } else if (resultv is ExpressionValue) { return resultv as ExpressionValue; } return new NullConstant(); //the following check is not necessary, since we will only keep bool, int and int[] methods //else //{ // throw new Expressions.ExpressionClass.RuntimeException("Call expression can only return int, short, byte, bool or int[] types. Please check your methods."); //} } throw new RuntimeException("Invalid Method Call: " + methodCall + "! Make sure you have defined the method in the library."); } catch(TargetInvocationException ex) { if (ex.InnerException != null) { RuntimeException exception = new RuntimeException("Exception happened at expression " + exp + ": " + ex.InnerException.Message); exception.InnerStackTrace = ex.InnerException.StackTrace; throw exception; } else { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } } catch (Exception ex) { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } case ExpressionType.ClassMethodCall: try { ClassMethodCall methodCall = (ClassMethodCall)exp; ExpressionValue variable = env.Variables[methodCall.Variable]; if (variable == null) { throw new RuntimeException("Exception happened at expression " + exp + ": variable " + methodCall.Variable + "'s value is null"); } object[] paras = new object[methodCall.Arguments.Length]; for (int i = 0; i < paras.Length; i++) { ExpressionValue x1 = Evaluate(methodCall.Arguments[i], env); paras[i] = GetValueFromExpression(x1); } MethodInfo methodInfo = variable.GetType().GetMethod(methodCall.MethodName); if (methodInfo != null) { object resultv = methodInfo.Invoke(variable, BindingFlags.InvokeMethod, null, paras, CultureInfo.InvariantCulture); if (methodInfo.ReturnType.Name == "Void") { return null; } if (resultv is bool) { return new BoolConstant((bool)resultv); } else if (resultv is int || resultv is short || resultv is byte || resultv is double) { return new IntConstant(Convert.ToInt32(resultv)); } else if (resultv is int[]) { int[] list = resultv as int[]; ExpressionValue[] vals = new ExpressionValue[list.Length]; for (int i = 0; i < vals.Length; i++) { vals[i] = new IntConstant(list[i]); } return new RecordValue(vals); } else if (resultv is ExpressionValue) { return resultv as ExpressionValue; } else if (resultv == null) { return new NullConstant(); } //return null; //the following check is not necessary, since we will only keep bool, int and int[] methods throw new RuntimeException("Call expression can only return int, short, byte, bool or int[] types. Please check your statement: " + methodCall.ToString() + "."); } throw new RuntimeException("Invalid Method Call: " + methodCall + "! Make sure you have defined the method in the library."); } catch (TargetInvocationException ex) { if(ex.InnerException != null) { RuntimeException exception = new RuntimeException("Exception happened at expression " + exp + ": " + ex.InnerException.Message); exception.InnerStackTrace = ex.InnerException.StackTrace; throw exception; } else { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } } catch (Exception ex) { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } case ExpressionType.ClassMethodCallInstance: try { ClassMethodCallInstance methodCall = (ClassMethodCallInstance) exp; ExpressionValue variable = Evaluate(methodCall.Variable, env); object[] paras = new object[methodCall.Arguments.Length]; for (int i = 0; i < paras.Length; i++) { ExpressionValue x1 = Evaluate(methodCall.Arguments[i], env); paras[i] = GetValueFromExpression(x1); } MethodInfo methodInfo = variable.GetType().GetMethod(methodCall.MethodName); if (methodInfo != null) { object resultv = methodInfo.Invoke(variable, paras); if (methodInfo.ReturnType.Name == "Void") { return null; } if (resultv is bool) { return new BoolConstant((bool)resultv); } else if (resultv is int || resultv is short || resultv is byte || resultv is double) { return new IntConstant(Convert.ToInt32(resultv)); } else if (resultv is int[]) { int[] list = resultv as int[]; ExpressionValue[] vals = new ExpressionValue[list.Length]; for (int i = 0; i < vals.Length; i++) { vals[i] = new IntConstant(list[i]); } return new RecordValue(vals); } else if (resultv is ExpressionValue) { return resultv as ExpressionValue; } else if (resultv == null) { return new NullConstant(); } //return null; //the following check is not necessary, since we will only keep bool, int and int[] methods throw new RuntimeException("Call expression can only return int, short, byte, bool or int[] types. Please check your statement: " + methodCall.ToString() + "."); } throw new RuntimeException("Invalid Method Call: " + methodCall + "! Make sure you have defined the method in the library."); } catch (TargetInvocationException ex) { if (ex.InnerException != null) { RuntimeException exception = new RuntimeException("Exception happened at expression " + exp + ": " + ex.InnerException.Message); exception.InnerStackTrace = ex.InnerException.StackTrace; throw exception; } else { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } } catch (Exception ex) { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } case ExpressionType.ClassProperty: try { ClassProperty property = (ClassProperty)exp; ExpressionValue variable = Evaluate(property.Variable, env); PropertyInfo propertyInfo = variable.GetType().GetProperty(property.PropertyName); object resultv = null; if (propertyInfo != null) { resultv = propertyInfo.GetValue(variable, null); } else { FieldInfo fieldInfo = variable.GetType().GetField(property.PropertyName); if (fieldInfo != null) { resultv = fieldInfo.GetValue(variable); } } if (resultv != null) { if (resultv is bool) { return new BoolConstant((bool)resultv); } else if (resultv is int || resultv is short || resultv is byte || resultv is double) { return new IntConstant(Convert.ToInt32(resultv)); } else if (resultv is int[]) { int[] list = resultv as int[]; ExpressionValue[] vals = new ExpressionValue[list.Length]; for (int i = 0; i < vals.Length; i++) { vals[i] = new IntConstant(list[i]); } return new RecordValue(vals); } else if (resultv is ExpressionValue) { return resultv as ExpressionValue; } //else if (resultv == null) //{ // return new NullConstant(); //} //return null; //the following check is not necessary, since we will only keep bool, int and int[] methods throw new RuntimeException("Call expression can only return int, short, byte, bool or int[] types. Please check your statement: " + property.ToString() + "."); } throw new RuntimeException("Invalid Property Accessing: " + property + "! Make sure you have defined the method in the library."); } catch (TargetInvocationException ex) { if (ex.InnerException != null) { RuntimeException exception = new RuntimeException("Exception happened at expression " + exp + ": " + ex.InnerException.Message); exception.InnerStackTrace = ex.InnerException.StackTrace; throw exception; } else { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } } catch (Exception ex) { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } case ExpressionType.ClassPropertyAssignment: { try { ClassPropertyAssignment pa = (ClassPropertyAssignment)exp; ExpressionValue rhs = Evaluate(pa.RightHandExpression, env); #if !OPTIMAL_FOR_EXP if (rhs == null) { throw new RuntimeException("Invalid expression assignment: " + exp); } #endif ClassProperty property = pa.ClassProperty; ExpressionValue variable = Evaluate(property.Variable, env); PropertyInfo propertyInfo = variable.GetType().GetProperty(property.PropertyName); if (propertyInfo != null) { propertyInfo.SetValue(variable, GetValueFromExpression(rhs), null); } else { FieldInfo fieldInfo = variable.GetType().GetField(property.PropertyName); if (fieldInfo != null) { fieldInfo.SetValue(variable, GetValueFromExpression(rhs)); } else { throw new RuntimeException("Invalid expression assignment: " + exp); } } return rhs; } catch (InvalidCastException ex) { throw new RuntimeException("Invalid Cast Exception for " + exp + ": " + ex.Message.Replace("PAT.Common.Classes.Expressions.ExpressionClass.", "")); } } case ExpressionType.Let: LetDefinition definition = exp as LetDefinition; ExpressionValue rhv = Evaluate(definition.RightHandExpression, env); env.ExtendDestructive(definition.Variable, rhv); return null; case ExpressionType.NewObjectCreation: try { NewObjectCreation methodCall = (NewObjectCreation)exp; object[] paras = new object[methodCall.Arguments.Length]; for (int i = 0; i < paras.Length; i++) { ExpressionValue x1 = Evaluate(methodCall.Arguments[i], env); paras[i] = GetValueFromExpression(x1); } Type classType; if (Common.Utility.Utilities.CSharpDataType.TryGetValue(methodCall.ClassName, out classType)) { object resultv = Activator.CreateInstance(classType, paras); if (resultv is ExpressionValue) { return resultv as ExpressionValue; } //return null; //the following check is not necessary, since we will only keep bool, int and int[] methods throw new RuntimeException("Only object of class inheriting from ExpressionValue can be created. Please check your statement: " + methodCall .ToString() + "."); } throw new RuntimeException("Invalid Object Creation: " + methodCall + "! Make sure you have defined the class in the library."); } catch (Exception ex) { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } //case ExpressionType.UserDefinedDataType: // return exp as ; /* case ExpressionType.Let: // Evaluate body with respect to environment extended by binding of leftHand to rightHand { Valuation newenv = env.GetVariableClone(); foreach (LetDefinition def in ((Let) exp).Definitions) { Value rhv = Evaluate(def.RightHandExpression, env); //newenv = Extend(newenv, def.Variable, rhv); //newenv = newenv.Extend(def.Variable, rhv); newenv.ExtendDestructive(def.Variable, rhv); } return Evaluate(((Let) exp).Body, newenv); } case ExpressionType.Fun: return new FunValue(env, ((Fun) exp).Formals, ((Fun) exp).Body); case ExpressionType.RecFun: // For recursive functions, we need to place an environment // in the function that has a binding of the function variable // to the function itself. For this, we obtain a clone of the // environment, making sure that a destructive change will // not have any effect on the original environment. Then, we // place the clone in the function value. After that, we // destructively change the environment by a binding of the // function variable to the constructed function value. { Valuation newEnv = env.GetVariableClone(); // (Valuation)env.Clone(); Value result = new FunValue(newEnv, ((RecFun) exp).Formals, ((RecFun) exp).body); //ExtendDestructive(newEnv, ((RecFun)exp).FunVar, result); newEnv.ExtendDestructive(((RecFun) exp).FunVar, result); return result; } case ExpressionType.Application: // Apply the function value resulting from evaluating the operator // (we assume that this is a function value) to // the value resulting from evaluating the operand. // Note that we do not need to distinguish functions from // recursive functions. Both are represented by function values, // recursive functions have a binding of their function variable // to themselves in their environment. { FunValue fun = (FunValue) Evaluate(((Application) exp).Operator, env); Valuation newenv = (Valuation) fun.Valuation; List<Expression> ops = ((Application) exp).Operands; List<string> fe = fun.Formals; for (int i = 0; i < ops.Count; i++) { Value argvalue = Evaluate(ops[i], env); //newenv = Extend(newenv, fe[i], argvalue); newenv = newenv.Extend((String) fe[i], argvalue); } return Evaluate(fun.Body, newenv); }*/ } // (exp instanceof NotUsed) // NotUsed is used as argument2 of PrimitiveApplication. // We assume the resulting value will not be used, // thus any value will do, here. return new BoolConstant(true); }
private void SynchronousChannelInputOutput(List<Configuration> returnList, int i, Valuation GlobalEnv, string evt) { List<ConfigurationWithChannelData> outputs = new List<ConfigurationWithChannelData>(); Processes[i].SyncOutput(GlobalEnv,outputs); foreach (ConfigurationWithChannelData vm in outputs) { if(evt != null && vm.Event != evt) { continue; } Process output = vm.Process; for (int k = 0; k < Processes.Count; k++) { if (k != i) { List<Configuration> syncedProcess = new List<Configuration>(); Processes[k].SyncInput(vm, syncedProcess); foreach (Configuration p in syncedProcess) { List<Process> newProcess = new List<Process>(Processes.Count); newProcess.AddRange(Processes); newProcess[i] = output; newProcess[k] = p.Process; IndexParallel interleave = new IndexParallel(newProcess, Alphabets); Configuration newStep = new Configuration(interleave, vm.Event, vm.DisplayName, GlobalEnv, false); newStep.IsAtomic = vm.IsAtomic || p.IsAtomic; if (AssertionBase.CalculateParticipatingProcess) { newStep.ParticipatingProcesses = new string[]{i.ToString(), k.ToString()}; } returnList.Add(newStep); } } } } }
public override void SyncOutput(Valuation GlobalEnv, List<ConfigurationWithChannelData> list) { //List<ConfigurationWithChannelData> returnList = new List<ConfigurationWithChannelData>(); for (int i = 0; i < Processes.Count; i++) { Process process = Processes[i]; List<ConfigurationWithChannelData> list1 = new List<ConfigurationWithChannelData>(); process.SyncOutput(GlobalEnv, list1); for (int j = 0; j < list1.Count; j++) { Configuration step = list1[j]; List<Process> newProcess = new List<Process>(Processes.Count); newProcess.AddRange(Processes); newProcess[i] = step.Process; step.Process = new IndexParallel(newProcess, Alphabets); } list.AddRange(list1); } //return returnList; }
public override void MoveOneStep(Valuation GlobalEnv, List<Configuration> list) { if (Alphabets == null) { IdentifySharedEventsAndVariables(); } List<string> barrierEnabledEvents = new List<string>(); List<string> disabled = new List<string>(); System.Diagnostics.Debug.Assert(list.Count == 0); Dictionary<string, List<Configuration>> syncSteps = new Dictionary<string, List<Configuration>>(); for (int i = 0; i < Processes.Count; i++) { //Process process = Processes[i]; List<Configuration> list1 = new List<Configuration>(); Processes[i].MoveOneStep(GlobalEnv, list1); List<string> enabled = new List<string>(list1.Count); for (int j = 0; j < list1.Count; j++) { Configuration step = list1[j]; string evt = step.Event; //if it happens that a data operation shares the same name with the sync event, treat it as an interleave case if (!Alphabets[i].Contains(evt) || step.IsDataOperation) { if (AssertionBase.CalculateParticipatingProcess) { step.ParticipatingProcesses = new string[] { i.ToString() }; } List<Process> newProcess = new List<Process>(Processes.Count); newProcess.AddRange(Processes); newProcess[i] = step.Process; step.Process = new IndexParallel(newProcess, Alphabets); list.Add(step); } else { enabled.Add(evt); string key = evt + Constants.SEPARATOR + i; if (!syncSteps.ContainsKey(key)) { syncSteps.Add(key, new List<Configuration>()); } syncSteps[key].Add(step); if (!barrierEnabledEvents.Contains(evt)) //Alphabets[i].Contains(evt) && { barrierEnabledEvents.Add(evt); } } } //int alphabetsCount = Alphabets[i].Count; foreach (string s in Alphabets[i]) { if (!enabled.Contains(s) && !disabled.Contains(s)) { disabled.Add(s); } } //to check whether there are synchoronous channel input/output if (Specification.HasSyncrhonousChannel) { SynchronousChannelInputOutput(list, i, GlobalEnv, null); } } int disabledCount = disabled.Count; for (int i = 0; i < disabledCount; i++) { barrierEnabledEvents.Remove(disabled[i]); } List<bool> isAtomic = null; //move the barrier synchronization events. foreach (string evt in barrierEnabledEvents) { //maps an event to the list of resulting processes. List<List<Process>> moves = new List<List<Process>>(); moves.Add(new List<Process>()); if (SpecificationBase.HasAtomicEvent) { isAtomic = new List<bool>(); isAtomic.Add(false); } List<string> participatingProcesses = new List<string>(); for (int i = 0; i < Processes.Count; i++) { if (Alphabets[i].Contains(evt)) { participatingProcesses.Add(i.ToString()); List<Configuration> steps = syncSteps[evt + Constants.SEPARATOR + i]; //Processes[i].MoveOneStep(eStep, evt); List<List<Process>> toAdd = new List<List<Process>>(moves.Count); foreach (Configuration step in steps) { //if it happens that a data operation shares the same name with the sync event, ignore if (!step.IsDataOperation) { if (moves[0].Count == i) { foreach (List<Process> list2 in moves) { list2.Add(step.Process); if (step.IsAtomic) { for (int j = 0; j < isAtomic.Count; j++) { isAtomic[j] = true; } } } } else { //If there non-determinism, clone and then add. for (int k = 0; k < moves.Count; k++) { List<Process> list2 = moves[k]; List<Process> newProcList = new List<Process>(); for (int j = 0; j < list2.Count - 1; j++) { newProcList.Add(list2[j]); } newProcList.Add(step.Process); toAdd.Add(newProcList); if (SpecificationBase.HasAtomicEvent) { if (!isAtomic[k]) { isAtomic.Add(step.IsAtomic); } else { isAtomic.Add(true); } } } } } } moves.AddRange(toAdd); } else { foreach (List<Process> move in moves) { move.Add(Processes[i]); } } } for (int i = 0; i < moves.Count; i++) { List<Process> list2 = moves[i]; IndexParallel para = new IndexParallel(list2, Alphabets); Configuration tmpStep = new Configuration(para, evt, null, GlobalEnv, false); if (SpecificationBase.HasAtomicEvent) { tmpStep.IsAtomic = isAtomic[i]; } if (AssertionBase.CalculateParticipatingProcess) { tmpStep.ParticipatingProcesses = participatingProcesses.ToArray(); } list.Add(tmpStep); } } //return returnList; }
private static ExpressionValue EvalPrimAppl(PrimitiveApplication application, ExpressionValue x1, Expression x2Exp, Valuation env) { try { ExpressionValue x2; switch (application.Operator) { case "<": x2 = Evaluate(x2Exp, env); return(new BoolConstant(((IntConstant)x1).Value < ((IntConstant)x2).Value)); case "<=": x2 = Evaluate(x2Exp, env); return(new BoolConstant(((IntConstant)x1).Value <= ((IntConstant)x2).Value)); case ">": x2 = Evaluate(x2Exp, env); return(new BoolConstant(((IntConstant)x1).Value > ((IntConstant)x2).Value)); case ">=": x2 = Evaluate(x2Exp, env); return(new BoolConstant(((IntConstant)x1).Value >= ((IntConstant)x2).Value)); case "==": x2 = Evaluate(x2Exp, env); return(new BoolConstant(x1.ExpressionID == x2.ExpressionID)); case "!=": x2 = Evaluate(x2Exp, env); //return new BoolConstant(((IntConstant)x1).Value != ((IntConstant)x2).Value); return(new BoolConstant(x1.ExpressionID != x2.ExpressionID)); case "&&": if (((BoolConstant)x1).Value) { x2 = Evaluate(x2Exp, env); return(new BoolConstant(((BoolConstant)x2).Value)); } else { return(new BoolConstant(false)); } case "||": if (!((BoolConstant)x1).Value) { x2 = Evaluate(x2Exp, env); return(new BoolConstant(((BoolConstant)x2).Value)); } else { return(new BoolConstant(true)); } case "xor": x2 = Evaluate(x2Exp, env); return(new BoolConstant(((BoolConstant)x1).Value ^ ((BoolConstant)x2).Value)); case "!": return(new BoolConstant(!((BoolConstant)x1).Value)); case "+": x2 = Evaluate(x2Exp, env); return(new IntConstant(((IntConstant)x1).Value + ((IntConstant)x2).Value)); case "-": x2 = Evaluate(x2Exp, env); return(new IntConstant(((IntConstant)x1).Value - ((IntConstant)x2).Value)); case "*": x2 = Evaluate(x2Exp, env); return(new IntConstant(((IntConstant)x1).Value * ((IntConstant)x2).Value)); case "/": x2 = Evaluate(x2Exp, env); if (((IntConstant)x2).Value == 0) { throw new ArithmeticException("Divide by Zero on " + application.ToString()); } else { return(new IntConstant(((IntConstant)x1).Value / ((IntConstant)x2).Value)); } case "mod": x2 = Evaluate(x2Exp, env); if (((IntConstant)x2).Value == 0) { throw new ArithmeticException("Modulo by Zero on " + application.ToString()); } else { int int_X1 = ((IntConstant)x1).Value; int int_X2 = ((IntConstant)x2).Value; int tmp = int_X1 % int_X2; return(new IntConstant((tmp >= 0) ? tmp : (tmp + int_X2))); } //case "empty" : // return new Value(((RecordValue) x1).Empty); //case "hasproperty": // return new Value(((RecordValue)x1).HasProperty(((PropertyValue)x2).PropertyName)); case ".": RecordValue record = (RecordValue)x1; x2 = Evaluate(x2Exp, env); int index = ((IntConstant)x2).Value; if (index < 0) { throw new NegativeArraySizeException("Access negative index " + index + " for variable " + application.Argument1.ToString() + " in expression " + application.ToString()); } else if (index >= record.Associations.Length) { throw new IndexOutOfBoundsException("Index " + index + " is out of range for variable " + application.Argument1.ToString() + " in expression " + application.ToString()); } return(record.Associations[index]); case "~": return(new IntConstant(-((IntConstant)x1).Value)); //Bitwise operators used by NESC module case "<<": //bitwise left shift x2 = Evaluate(x2Exp, env); return(new IntConstant(((IntConstant)x1).Value << ((IntConstant)x2).Value)); case ">>": //bitwise right shift x2 = Evaluate(x2Exp, env); return(new IntConstant(((IntConstant)x1).Value >> ((IntConstant)x2).Value)); case "&": //bitwise AND x2 = Evaluate(x2Exp, env); return(new IntConstant(((IntConstant)x1).Value & ((IntConstant)x2).Value)); case "^": //bitwise XOR x2 = Evaluate(x2Exp, env); return(new IntConstant(((IntConstant)x1).Value ^ ((IntConstant)x2).Value)); case "|": //bitwise OR x2 = Evaluate(x2Exp, env); return(new IntConstant(((IntConstant)x1).Value | ((IntConstant)x2).Value)); } } catch (InvalidCastException ex) { throw new RuntimeException("Invalid Cast Exception for " + application.ToString() + ": " + ex.Message.Replace("PAT.Common.Classes.Expressions.ExpressionClass.", "")); } //catch (Exception ex1) //{ // throw new RuntimeException("Invalid Primitive Operation: " + application.ToString() + "!"); //} throw new RuntimeException("Invalid Primitive Operation: " + application.ToString() + "!"); }
public override void MoveOneStep(Valuation GlobalEnv, List<Configuration> list) { System.Diagnostics.Debug.Assert(list.Count == 0); for (int i = 0; i < Processes.Count; i++) { List<Configuration> list1 = new List<Configuration>(); Processes[i].MoveOneStep(GlobalEnv, list1); foreach (Configuration configuration in list1) { if (configuration.Event == Constants.TAU) { List<Process> newProcess = new List<Process>(Processes); newProcess[i] = configuration.Process; IndexExternalChoice choice = new IndexExternalChoice(newProcess); configuration.Process = choice; } list.Add(configuration); } } }
private void SynchronousChannelInputOutput(List<Configuration> returnList, int i, Valuation GlobalEnv, string evt) { List<ConfigurationWithChannelData> outputs = new List<ConfigurationWithChannelData>(); Processes[i].SyncOutput(GlobalEnv, outputs); List<Dictionary<string, int>> nextProcessCounters1 = Common.Classes.Ultility.Ultility.ProcessCounterDecrement(Common.Classes.Ultility.Ultility.CutNumber, ProcessesCounter, Processes[i].ProcessID, 1); foreach (ConfigurationWithChannelData vm in outputs) { if (evt != null & vm.Event != evt) { continue; } for (int k = 0; k < Processes.Count; k++) { string id = Processes[k].ProcessID; if (k != i || (k == i && (ProcessesCounter[id] > 1 || ProcessesCounter[id] == -1))) { List<Configuration> syncedProcess = new List<Configuration>(); Processes[k].SyncInput(vm, syncedProcess); if (syncedProcess.Count > 0) { if (k == i) { List<Dictionary<string, int>> nextProcessCountersInner = Common.Classes.Ultility.Ultility.ProcessCounterDecrement(Common.Classes.Ultility.Ultility.CutNumber, ProcessesCounter, Processes[i].ProcessID, 2); foreach (Configuration p in syncedProcess) { foreach (Dictionary<string, int> ints in nextProcessCountersInner) { Dictionary<string, int> dictionaryNew = new Dictionary<string, int>(ints); List<Process> newProcess = new List<Process>(Processes); AddOneProcess(newProcess, p.Process, dictionaryNew); AddOneProcess(newProcess, vm.Process, dictionaryNew); Configuration newStep = new Configuration(new IndexInterleaveAbstract(newProcess, dictionaryNew), vm.Event,vm.DisplayName, GlobalEnv, false); newStep.IsAtomic = vm.IsAtomic || p.IsAtomic; if (AssertionBase.CalculateParticipatingProcess) { newStep.ParticipatingProcesses = new string[] { Processes[i].ProcessID, Processes[k].ProcessID }; } returnList.Add(newStep); } } } else { foreach (Dictionary<string, int> ints in nextProcessCounters1) { List<Dictionary<string, int>> nextProcessCountersInner = Common.Classes.Ultility.Ultility.ProcessCounterDecrement(Common.Classes.Ultility.Ultility.CutNumber, ints, id, 1); foreach (Configuration p in syncedProcess) { foreach (Dictionary<string, int> dictionary in nextProcessCountersInner) { List<Process> newProcess = new List<Process>(Processes); AddOneProcess(newProcess, p.Process, dictionary); AddOneProcess(newProcess, vm.Process, dictionary); Configuration newStep = new Configuration(new IndexInterleaveAbstract(newProcess, dictionary),vm.Event, vm.DisplayName, GlobalEnv, false); newStep.IsAtomic = vm.IsAtomic || p.IsAtomic; if (AssertionBase.CalculateParticipatingProcess) { newStep.ParticipatingProcesses = new string[] { Processes[i].ProcessID, Processes[k].ProcessID }; } returnList.Add(newStep); } } } } } } } } }
/// <summary> /// returns all the possible synchronous output steps /// </summary> /// <returns></returns> public virtual void SyncOutput(Valuation GlobalEnv, List<ConfigurationWithChannelData> list) { }
/// <summary> /// returns all the possible moves of the current process /// </summary> /// <param name="GlobalEnv">The current global valuation</param> /// <param name="list">The list of steps to be returned.</param> /// A precondition of the method is that "System.Diagnostics.Debug.Assert(list.Count == 0);" public abstract void MoveOneStep(Valuation GlobalEnv, List<Configuration> list);
// evaluate starts evaluation with fresh environment public static ExpressionValue Evaluate(Expression exp, Valuation env) { switch (exp.ExpressionType) { case ExpressionType.Constant: return(exp as ExpressionValue); case ExpressionType.Variable: // Look up variable in environment; we assume // that value is found try { return(env.Variables[exp.expressionID]); } catch (KeyNotFoundException) { throw new EvaluatingException("Access the non existing variable: " + exp.expressionID); } catch (Exception ex) { throw new EvaluatingException("Variable evaluation exception for variable '" + exp.expressionID + "':" + ex.Message); } case ExpressionType.Record: { Expression[] ass = ((Record)exp).Associations; ExpressionValue[] values = new ExpressionValue[ass.Length]; for (int i = 0; i < ass.Length; i++) { //rv.Put(association.Property, store.Extend(Eval(association.Expression, env))); //rv.Put(Eval(association, env)); values[i] = Evaluate(ass[i], env); #if !OPTIMAL_FOR_EXP if (values[i] == null) { throw new RuntimeException("Invalid expression assignment: " + exp); } #endif } RecordValue rv = new RecordValue(values); return(rv); } case ExpressionType.PrimitiveApplication: // First evaluate the first argument, then the second, and // then evaluate using evalPrimAppl. { PrimitiveApplication newexp = exp as PrimitiveApplication; ExpressionValue x1 = Evaluate(newexp.Argument1, env); Debug.Assert(x1 != null); #if !OPTIMAL_FOR_EXP if (x1 == null) { throw new RuntimeException("Invalid expression assignment: " + exp); } #endif return(EvalPrimAppl(newexp, x1, newexp.Argument2, env)); } case ExpressionType.Assignment: { //Assign the rhs to lhs String lhs = ((Assignment)exp).LeftHandSide; Expression rhs = ((Assignment)exp).RightHandSide; ExpressionValue rhsV = Evaluate(rhs, env); #if !OPTIMAL_FOR_EXP if (rhsV == null) { throw new RuntimeException("Invalid expression assignment: " + exp); } Valuation.CheckVariableRange(lhs, rhsV); #endif env.Variables[lhs] = rhsV; return(rhsV); } case ExpressionType.PropertyAssignment: { try { PropertyAssignment pa = (PropertyAssignment)exp; RecordValue rec = (RecordValue)Evaluate(pa.RecordExpression, env); IntConstant pro = (IntConstant)Evaluate(pa.PropertyExpression, env); ExpressionValue rhs = Evaluate(pa.RightHandExpression, env); //rec.Put(pro.PropertyName, store.Extend(rhs)); int index = pro.Value; if (index < 0) { throw new NegativeArraySizeException("Access negative index " + index + " for variable " + pa.RecordExpression.ToString()); } else if (index >= rec.Associations.Length) { throw new IndexOutOfBoundsException("Index " + index + " is out of range for variable " + pa.RecordExpression.ToString()); } #if !OPTIMAL_FOR_EXP if (rhs == null) { throw new RuntimeException("Invalid expression assignment: " + exp); } Valuation.CheckVariableRange(pa.RecordExpression.ToString(), rhs); #endif rec.Associations[index] = rhs; //Note:Important!!! must recalculate the ID here, otherwise ID is obsolete and the verification result is wrong rec.GetID(); return(rhs); } catch (InvalidCastException ex) { throw new RuntimeException("Invalid Cast Exception for " + exp + ": " + ex.Message.Replace("PAT.Common.Classes.Expressions.ExpressionClass.", "")); } } case ExpressionType.If: // Conditionals are evaluated by evaluating the then-part or // else-part depending of the result of evaluating the condition. { ExpressionValue cond = Evaluate(((If)exp).Condition, env); if (((BoolConstant)cond).Value) { return(Evaluate(((If)exp).ThenPart, env)); } else if (((If)exp).ElsePart != null) { return(Evaluate(((If)exp).ElsePart, env)); } else { return(null); } } case ExpressionType.Sequence: // firstPart;secondPart Expression fP = ((Sequence)exp).FirstPart; Expression sP = ((Sequence)exp).SecondPart; Evaluate(fP, env); return(Evaluate(sP, env)); case ExpressionType.While: Expression test = ((While)exp).Test; Expression body = ((While)exp).Body; // the value of test may not be a Value. // here we assume it is always a Value, which // may cause run time exception due to non-Value. if (((BoolConstant)Evaluate(test, env)).Value) { // test is ture Evaluate(body, env); // body serves to change the store return(Evaluate(exp, env)); // evaluate the While again } else { return(null); } case ExpressionType.StaticMethodCall: try { StaticMethodCall methodCall = (StaticMethodCall)exp; if (methodCall.Arguments.Length > 0) { ChannelQueue queue; string cname = null; if ((methodCall.Arguments[0] is Variable)) { cname = (methodCall.Arguments[0] as Variable).ExpressionID; } else if (methodCall.Arguments[0] is PrimitiveApplication) { PrimitiveApplication pa = (methodCall.Arguments[0] as PrimitiveApplication); ExpressionValue ind = Evaluate(pa.Argument2, env); cname = pa.Argument1 + "[" + ind + "]"; } switch (methodCall.MethodName) { case Common.Classes.Ultility.Constants.cfull: if (env.Channels.TryGetValue(cname, out queue)) { return(new BoolConstant(queue.IsFull())); } else { throw new RuntimeException("Channel " + cname + " is not used in the model. Therefore it is meaningless to query channel information using " + methodCall + "."); } case Common.Classes.Ultility.Constants.cempty: if (env.Channels.TryGetValue(cname, out queue)) { return(new BoolConstant(queue.IsEmpty())); } else { throw new RuntimeException("Channel " + cname + " is not used in the model. Therefore it is meaningless to query channel information using " + methodCall + "."); } case Common.Classes.Ultility.Constants.ccount: if (env.Channels.TryGetValue(cname, out queue)) { return(new IntConstant(queue.Count)); } else { throw new RuntimeException("Channel " + cname + " is not used in the model. Therefore it is meaningless to query channel information using " + methodCall + "."); } case Common.Classes.Ultility.Constants.csize: if (env.Channels.TryGetValue(cname, out queue)) { return(new IntConstant(queue.Size)); } else { throw new RuntimeException("Channel " + cname + " is not used in the model. Therefore it is meaningless to query channel information using " + methodCall + "."); } case Common.Classes.Ultility.Constants.cpeek: if (env.Channels.TryGetValue(cname, out queue)) { if (queue.Count == 0) { throw new IndexOutOfBoundsException("Channel " + cname + "'s buffer is empty!"); } return(new RecordValue(queue.Peek())); } else { throw new RuntimeException("Channel " + cname + " is not used in the model. Therefore it is meaningless to query channel information using " + methodCall + "."); } } } object[] paras = new object[methodCall.Arguments.Length]; for (int i = 0; i < paras.Length; i++) { ExpressionValue x1 = Evaluate(methodCall.Arguments[i], env); paras[i] = GetValueFromExpression(x1); } string key = methodCall.MethodName + paras.Length; if (Common.Utility.Utilities.CSharpMethods.ContainsKey(key)) { object resultv = Common.Utility.Utilities.CSharpMethods[key].Invoke(null, paras); if (Common.Utility.Utilities.CSharpMethods[key].ReturnType.Name == "Void") { return(null); } if (resultv is bool) { return(new BoolConstant((bool)resultv)); } else if (resultv is int || resultv is short || resultv is byte || resultv is double) { return(new IntConstant(Convert.ToInt32(resultv))); } else if (resultv is int[]) { int[] list = resultv as int[]; ExpressionValue[] vals = new ExpressionValue[list.Length]; for (int i = 0; i < vals.Length; i++) { vals[i] = new IntConstant(list[i]); } return(new RecordValue(vals)); } else if (resultv is ExpressionValue) { return(resultv as ExpressionValue); } return(new NullConstant()); //the following check is not necessary, since we will only keep bool, int and int[] methods //else //{ // throw new Expressions.ExpressionClass.RuntimeException("Call expression can only return int, short, byte, bool or int[] types. Please check your methods."); //} } throw new RuntimeException("Invalid Method Call: " + methodCall + "! Make sure you have defined the method in the library."); } catch (TargetInvocationException ex) { if (ex.InnerException != null) { RuntimeException exception = new RuntimeException("Exception happened at expression " + exp + ": " + ex.InnerException.Message); exception.InnerStackTrace = ex.InnerException.StackTrace; throw exception; } else { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } } catch (Exception ex) { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } case ExpressionType.ClassMethodCall: try { ClassMethodCall methodCall = (ClassMethodCall)exp; ExpressionValue variable = env.Variables[methodCall.Variable]; if (variable == null) { throw new RuntimeException("Exception happened at expression " + exp + ": variable " + methodCall.Variable + "'s value is null"); } object[] paras = new object[methodCall.Arguments.Length]; for (int i = 0; i < paras.Length; i++) { ExpressionValue x1 = Evaluate(methodCall.Arguments[i], env); paras[i] = GetValueFromExpression(x1); } MethodInfo methodInfo = variable.GetType().GetMethod(methodCall.MethodName); if (methodInfo != null) { object resultv = methodInfo.Invoke(variable, BindingFlags.InvokeMethod, null, paras, CultureInfo.InvariantCulture); if (methodInfo.ReturnType.Name == "Void") { return(null); } if (resultv is bool) { return(new BoolConstant((bool)resultv)); } else if (resultv is int || resultv is short || resultv is byte || resultv is double) { return(new IntConstant(Convert.ToInt32(resultv))); } else if (resultv is int[]) { int[] list = resultv as int[]; ExpressionValue[] vals = new ExpressionValue[list.Length]; for (int i = 0; i < vals.Length; i++) { vals[i] = new IntConstant(list[i]); } return(new RecordValue(vals)); } else if (resultv is ExpressionValue) { return(resultv as ExpressionValue); } else if (resultv == null) { return(new NullConstant()); } //return null; //the following check is not necessary, since we will only keep bool, int and int[] methods throw new RuntimeException("Call expression can only return int, short, byte, bool or int[] types. Please check your statement: " + methodCall.ToString() + "."); } throw new RuntimeException("Invalid Method Call: " + methodCall + "! Make sure you have defined the method in the library."); } catch (TargetInvocationException ex) { if (ex.InnerException != null) { RuntimeException exception = new RuntimeException("Exception happened at expression " + exp + ": " + ex.InnerException.Message); exception.InnerStackTrace = ex.InnerException.StackTrace; throw exception; } else { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } } catch (Exception ex) { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } case ExpressionType.ClassMethodCallInstance: try { ClassMethodCallInstance methodCall = (ClassMethodCallInstance)exp; ExpressionValue variable = Evaluate(methodCall.Variable, env); object[] paras = new object[methodCall.Arguments.Length]; for (int i = 0; i < paras.Length; i++) { ExpressionValue x1 = Evaluate(methodCall.Arguments[i], env); paras[i] = GetValueFromExpression(x1); } MethodInfo methodInfo = variable.GetType().GetMethod(methodCall.MethodName); if (methodInfo != null) { object resultv = methodInfo.Invoke(variable, paras); if (methodInfo.ReturnType.Name == "Void") { return(null); } if (resultv is bool) { return(new BoolConstant((bool)resultv)); } else if (resultv is int || resultv is short || resultv is byte || resultv is double) { return(new IntConstant(Convert.ToInt32(resultv))); } else if (resultv is int[]) { int[] list = resultv as int[]; ExpressionValue[] vals = new ExpressionValue[list.Length]; for (int i = 0; i < vals.Length; i++) { vals[i] = new IntConstant(list[i]); } return(new RecordValue(vals)); } else if (resultv is ExpressionValue) { return(resultv as ExpressionValue); } else if (resultv == null) { return(new NullConstant()); } //return null; //the following check is not necessary, since we will only keep bool, int and int[] methods throw new RuntimeException("Call expression can only return int, short, byte, bool or int[] types. Please check your statement: " + methodCall.ToString() + "."); } throw new RuntimeException("Invalid Method Call: " + methodCall + "! Make sure you have defined the method in the library."); } catch (TargetInvocationException ex) { if (ex.InnerException != null) { RuntimeException exception = new RuntimeException("Exception happened at expression " + exp + ": " + ex.InnerException.Message); exception.InnerStackTrace = ex.InnerException.StackTrace; throw exception; } else { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } } catch (Exception ex) { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } case ExpressionType.ClassProperty: try { ClassProperty property = (ClassProperty)exp; ExpressionValue variable = Evaluate(property.Variable, env); PropertyInfo propertyInfo = variable.GetType().GetProperty(property.PropertyName); object resultv = null; if (propertyInfo != null) { resultv = propertyInfo.GetValue(variable, null); } else { FieldInfo fieldInfo = variable.GetType().GetField(property.PropertyName); if (fieldInfo != null) { resultv = fieldInfo.GetValue(variable); } } if (resultv != null) { if (resultv is bool) { return(new BoolConstant((bool)resultv)); } else if (resultv is int || resultv is short || resultv is byte || resultv is double) { return(new IntConstant(Convert.ToInt32(resultv))); } else if (resultv is int[]) { int[] list = resultv as int[]; ExpressionValue[] vals = new ExpressionValue[list.Length]; for (int i = 0; i < vals.Length; i++) { vals[i] = new IntConstant(list[i]); } return(new RecordValue(vals)); } else if (resultv is ExpressionValue) { return(resultv as ExpressionValue); } //else if (resultv == null) //{ // return new NullConstant(); //} //return null; //the following check is not necessary, since we will only keep bool, int and int[] methods throw new RuntimeException("Call expression can only return int, short, byte, bool or int[] types. Please check your statement: " + property.ToString() + "."); } throw new RuntimeException("Invalid Property Accessing: " + property + "! Make sure you have defined the method in the library."); } catch (TargetInvocationException ex) { if (ex.InnerException != null) { RuntimeException exception = new RuntimeException("Exception happened at expression " + exp + ": " + ex.InnerException.Message); exception.InnerStackTrace = ex.InnerException.StackTrace; throw exception; } else { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } } catch (Exception ex) { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } case ExpressionType.ClassPropertyAssignment: { try { ClassPropertyAssignment pa = (ClassPropertyAssignment)exp; ExpressionValue rhs = Evaluate(pa.RightHandExpression, env); #if !OPTIMAL_FOR_EXP if (rhs == null) { throw new RuntimeException("Invalid expression assignment: " + exp); } #endif ClassProperty property = pa.ClassProperty; ExpressionValue variable = Evaluate(property.Variable, env); PropertyInfo propertyInfo = variable.GetType().GetProperty(property.PropertyName); if (propertyInfo != null) { propertyInfo.SetValue(variable, GetValueFromExpression(rhs), null); } else { FieldInfo fieldInfo = variable.GetType().GetField(property.PropertyName); if (fieldInfo != null) { fieldInfo.SetValue(variable, GetValueFromExpression(rhs)); } else { throw new RuntimeException("Invalid expression assignment: " + exp); } } return(rhs); } catch (InvalidCastException ex) { throw new RuntimeException("Invalid Cast Exception for " + exp + ": " + ex.Message.Replace("PAT.Common.Classes.Expressions.ExpressionClass.", "")); } } case ExpressionType.Let: LetDefinition definition = exp as LetDefinition; ExpressionValue rhv = Evaluate(definition.RightHandExpression, env); env.ExtendDestructive(definition.Variable, rhv); return(null); case ExpressionType.NewObjectCreation: try { NewObjectCreation methodCall = (NewObjectCreation)exp; object[] paras = new object[methodCall.Arguments.Length]; for (int i = 0; i < paras.Length; i++) { ExpressionValue x1 = Evaluate(methodCall.Arguments[i], env); paras[i] = GetValueFromExpression(x1); } Type classType; if (Common.Utility.Utilities.CSharpDataType.TryGetValue(methodCall.ClassName, out classType)) { object resultv = Activator.CreateInstance(classType, paras); if (resultv is ExpressionValue) { return(resultv as ExpressionValue); } //return null; //the following check is not necessary, since we will only keep bool, int and int[] methods throw new RuntimeException("Only object of class inheriting from ExpressionValue can be created. Please check your statement: " + methodCall.ToString() + "."); } throw new RuntimeException("Invalid Object Creation: " + methodCall + "! Make sure you have defined the class in the library."); } catch (Exception ex) { throw new RuntimeException("Exception happened at expression " + exp + ": " + ex.Message); } //case ExpressionType.UserDefinedDataType: // return exp as ; /* case ExpressionType.Let: * // Evaluate body with respect to environment extended by binding of leftHand to rightHand * { * Valuation newenv = env.GetVariableClone(); * foreach (LetDefinition def in ((Let) exp).Definitions) * { * Value rhv = Evaluate(def.RightHandExpression, env); * //newenv = Extend(newenv, def.Variable, rhv); * //newenv = newenv.Extend(def.Variable, rhv); * newenv.ExtendDestructive(def.Variable, rhv); * } * return Evaluate(((Let) exp).Body, newenv); * } * case ExpressionType.Fun: * return new FunValue(env, ((Fun) exp).Formals, ((Fun) exp).Body); * case ExpressionType.RecFun: * // For recursive functions, we need to place an environment * // in the function that has a binding of the function variable * // to the function itself. For this, we obtain a clone of the * // environment, making sure that a destructive change will * // not have any effect on the original environment. Then, we * // place the clone in the function value. After that, we * // destructively change the environment by a binding of the * // function variable to the constructed function value. * { * Valuation newEnv = env.GetVariableClone(); // (Valuation)env.Clone(); * Value result = new FunValue(newEnv, ((RecFun) exp).Formals, ((RecFun) exp).body); * //ExtendDestructive(newEnv, ((RecFun)exp).FunVar, result); * newEnv.ExtendDestructive(((RecFun) exp).FunVar, result); * return result; * } * case ExpressionType.Application: * // Apply the function value resulting from evaluating the operator * // (we assume that this is a function value) to * // the value resulting from evaluating the operand. * // Note that we do not need to distinguish functions from * // recursive functions. Both are represented by function values, * // recursive functions have a binding of their function variable * // to themselves in their environment. * { * FunValue fun = (FunValue) Evaluate(((Application) exp).Operator, env); * Valuation newenv = (Valuation) fun.Valuation; * * List<Expression> ops = ((Application) exp).Operands; * List<string> fe = fun.Formals; * * for (int i = 0; i < ops.Count; i++) * { * Value argvalue = Evaluate(ops[i], env); * //newenv = Extend(newenv, fe[i], argvalue); * newenv = newenv.Extend((String) fe[i], argvalue); * } * return Evaluate(fun.Body, newenv); * }*/ } // (exp instanceof NotUsed) // NotUsed is used as argument2 of PrimitiveApplication. // We assume the resulting value will not be used, // thus any value will do, here. return(new BoolConstant(true)); }
public override void SyncOutput(Valuation GlobalEnv, List<ConfigurationWithChannelData> list) { //List<ConfigurationWithChannelData> returnList = new List<ConfigurationWithChannelData>(); for (int i = 0; i < Processes.Count; i++) { Process process = Processes[i]; List<ConfigurationWithChannelData> list1 = new List<ConfigurationWithChannelData>(); process.SyncOutput(GlobalEnv, list1); foreach (ConfigurationWithChannelData pair in list1) { Configuration step = pair; List<Process> newProcess = new List<Process>(Processes.Count); newProcess.AddRange(Processes); newProcess[i] = step.Process; step.Process = new IndexInterleave(newProcess); } list.AddRange(list1); } //return returnList; }
public override void SyncOutput(Valuation GlobalEnv, List<ConfigurationWithChannelData> list) { FirstProcess.SyncOutput(GlobalEnv, list); for (int i = 0; i < list.Count; i++) { Configuration step = list[i]; if (step.Event != Constants.TERMINATION) { Interrupt inter = new Interrupt(step.Process, SecondProcess); step.Process = inter; } } SecondProcess.SyncOutput(GlobalEnv, list); //return returnList; }
public override void MoveOneStep(Valuation GlobalEnv, List<Configuration> list) { System.Diagnostics.Debug.Assert(list.Count == 0); int TerminationCount = 0; bool hasAtomicTermination = false; List<Dictionary<string, int>> nextProcessCounters = null; for (int i = 0; i < Processes.Count; i++) { Process process = Processes[i]; List<Configuration> list1 = new List<Configuration>(); process.MoveOneStep(GlobalEnv, list1); bool hasTermination = false; if (list1.Count> 0) { nextProcessCounters = Common.Classes.Ultility.Ultility.ProcessCounterDecrement(Common.Classes.Ultility.Ultility.CutNumber, ProcessesCounter, process.ProcessID, 1); } for (int j = 0; j < list1.Count; j++) { Configuration step = list1[j]; if (step.Event == Constants.TERMINATION) { hasTermination = true; if (step.IsAtomic) { hasAtomicTermination = true; } } else { foreach (Dictionary<string, int> ints in nextProcessCounters) { Dictionary<string, int> listInstance = new Dictionary<string, int>(ints); List<Process> newProcess = new List<Process>(Processes); AddOneProcess(newProcess, step.Process, listInstance); IndexInterleaveAbstract interleave = new IndexInterleaveAbstract(newProcess, listInstance); Configuration newStep = new Configuration(interleave, step.Event, step.DisplayName, step.GlobalEnv, step.IsDataOperation); newStep.IsAtomic = step.IsAtomic; if (AssertionBase.CalculateParticipatingProcess) { newStep.ParticipatingProcesses = new string[] { process.ProcessID }; } list.Add(newStep); } } } if (hasTermination) { TerminationCount++; } //to check whether there are synchoronous channel input/output if (Specification.HasSyncrhonousChannel) { SynchronousChannelInputOutput(list, i, GlobalEnv, null); } } if (TerminationCount == Processes.Count) { Configuration temp = new Configuration(new Stop(), Constants.TERMINATION, null, GlobalEnv, false); if(hasAtomicTermination) { temp.IsAtomic = true; } if (AssertionBase.CalculateParticipatingProcess) { temp.ParticipatingProcesses = new string[Processes.Count]; for (int i = 0; i < Processes.Count; i++) { temp.ParticipatingProcesses[i] = i.ToString(); } } list.Add(temp); } //return returnList; }
public PNConfigurationWithChannelData(PetriNet p, string e, string hiddenEvent, Valuation globalEnv, bool isDataOperation, string name, Expression[] expressions) : base(p, e, hiddenEvent, globalEnv, isDataOperation, null) { ChannelName = name; Expressions = expressions; }
public override void SyncOutput(Valuation GlobalEnv, List<ConfigurationWithChannelData> list) { //List<ConfigurationWithChannelData> returnList = new List<ConfigurationWithChannelData>(); for (int i = 0; i < Processes.Count; i++) { Process process = Processes[i]; List<ConfigurationWithChannelData> list1 = new List<ConfigurationWithChannelData>(); process.SyncOutput(GlobalEnv, list1); if (list1.Count > 0) { List<Dictionary<string, int>> nextProcessCounters = Common.Classes.Ultility.Ultility.ProcessCounterDecrement(Common.Classes.Ultility.Ultility.CutNumber, ProcessesCounter, process.ProcessID, 1); for (int j = 0; j < list1.Count; j++) { Configuration step = list1[j]; foreach (Dictionary<string, int> ints in nextProcessCounters) { List<Process> newProcess = new List<Process>(Processes); Dictionary<string, int> listInstance = new Dictionary<string, int>(ints); AddOneProcess(newProcess, step.Process, listInstance); IndexInterleaveAbstract interleave = new IndexInterleaveAbstract(newProcess, listInstance); ConfigurationWithChannelData newStep = new ConfigurationWithChannelData(interleave, step.Event, step.DisplayName, step.GlobalEnv, step.IsDataOperation, list1[j].ChannelName, list1[j].Expressions); newStep.IsAtomic = step.IsAtomic; list.Add(newStep); } } } } //return returnList; }