/// <summary> /// Recognizes expressions that start with a type's name. /// </summary> /// <returns> /// A <see cref="StaticMethodCall"/> or a <see cref="StaticPropertyRef"/> /// </returns> protected Expression AtomStartingWithTypeName() { Expression expr; Token first = Match(TokenID.TypeName); Match(TokenID.DoubleColon); Token last = Match(TokenID.Identifier); var name = new QualifiedName(first.ToString(), last.ToString()); if (TryMatch(TokenID.LeftParenthesis)) { Consume(1); Expression[] args = List <Expression>(Expression, false, null); last = Match(TokenID.RightParenthesis); expr = new StaticMethodCall(name, args); } else { expr = new StaticPropertyRef(name); } expr.SetLocation(first.Start, last.End); return(expr); }
public static void TestIsNonVoidExpression(Expression p, IToken ID1, Valuation valuation) { if (p is StaticMethodCall) { StaticMethodCall call = p as StaticMethodCall; if (call != null) { string key = call.MethodName + call.Arguments.Length; if (Utilities.CSharpMethods.ContainsKey(key)) { if (Utilities.CSharpMethods[key].ReturnType.Name == "Void") { throw new ParsingException(string.Format("Expression {0} must have a return value! ", p), ID1); } } } } else if (p is ClassMethodCall) { try { ClassMethodCall call = (ClassMethodCall)p; if (call != null && valuation.Variables.ContainsKey(call.Variable)) { MethodInfo methodInfo = valuation.Variables[call.Variable].GetType().GetMethod(call.MethodName); if (methodInfo != null) { if (methodInfo.ReturnType.Name == "Void") { throw new ParsingException( string.Format("Expression {0} must have a return value! ", p), ID1); } } } } catch (ParsingException) { throw; } catch (Exception) { //throw; } } }
public void CompileStaticMethodCall(StaticMethodCall staticCall) { XmlElement previousElement = currentElement; XmlElement tmpElement = document.CreateElement("StaticMethodCall"); tmpElement.SetAttribute("Name", staticCall.Name.ToString()); currentElement = document.CreateElement("Arguments"); foreach (Expression argument in staticCall.Arguments) { argument.AcceptCompiler(this); } tmpElement.AppendChild(currentElement); previousElement.AppendChild(tmpElement); currentElement = previousElement; }
/// <summary> /// Invokes a static method with the given arguments. /// </summary> /// <param name="method">The method's name</param> /// <param name="klass">The class from which to call a method</param> /// <param name="args">The arguments to pass to the method</param> /// <returns>The value returned by the method</returns> public static Dynamic Invoke(string method, Class klass, params object[] args) { var name = new QualifiedName(klass.Name, method); var literals = new Expression[args.Length]; for (int i = 0; i < args.Length; ++i) { literals[i] = new Literal(DynamicFactory.CreateDynamic(args[i])); } var call = new StaticMethodCall(name, literals); call.AcceptCompiler(Interpreter); return(Interpreter.ReturnedValue); }
public void CompileStaticMethodCall(StaticMethodCall staticCall) { textWriter.Write(SafeName(staticCall.Name)); DumpExpressionsList(staticCall.Arguments); }
// 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 static string GenerateLaTexString(Expression exp) { switch (exp.ExpressionType) { case ExpressionType.Variable: return(exp.ToString()); case ExpressionType.Constant: if (exp is BoolConstant) { return(((BoolConstant)exp).Value.ToString()); } else { return(exp.ToString()); } case ExpressionType.Record: { Record record = exp as Record; StringBuilder sb = new StringBuilder("["); for (int i = 0; i < record.Associations.Length - 1; i++) { Expression con = record.Associations[i]; sb.Append(GenerateLaTexString(con) + ", "); } sb.Append(GenerateLaTexString(record.Associations[record.Associations.Length - 1])); sb.Append("]"); return(sb.ToString()); } case ExpressionType.PrimitiveApplication: // First evaluate the first argument, then the second, and // then evaluate using evalPrimAppl. { PrimitiveApplication newexp = exp as PrimitiveApplication; if (newexp.Argument2 == null) { if (newexp.Operator == "~") { return("-" + GenerateLaTexString(newexp.Argument1)); } else { return(newexp.Operator + GenerateLaTexString(newexp.Argument1)); } } else { if (newexp.Operator == ".") { return(GenerateLaTexString(newexp.Argument1) + "[" + GenerateLaTexString(newexp.Argument2) + "]"); } else if (newexp.Operator == "mod") { return("(" + GenerateLaTexString(newexp.Argument1) + " \\% " + GenerateLaTexString(newexp.Argument2) + ")"); } else { string op = ""; switch (newexp.Operator) { case "&&": op = @"\land"; break; case "||": op = @"\lor"; break; case "==": op = @"=="; break; case "!=": op = @"\neq"; break; case ">=": op = @"\geq"; break; case "<=": op = @"\leq"; break; case "\\": op = @"\backslash"; break; default: op = newexp.Operator; break; } return("(" + GenerateLaTexString(newexp.Argument1) + " " + op + " " + GenerateLaTexString(newexp.Argument2) + ")"); } } } case ExpressionType.Assignment: { Assignment assign = exp as Assignment; return(assign.LeftHandSide + " = " + GenerateLaTexString(assign.RightHandSide) + ";"); } case ExpressionType.PropertyAssignment: { PropertyAssignment pa = (PropertyAssignment)exp; return(GenerateLaTexString(pa.RecordExpression) + "[" + GenerateLaTexString(pa.PropertyExpression) + "]=" + GenerateLaTexString(pa.RightHandExpression) + ";"); } case ExpressionType.If: // Conditionals are evaluated by evaluating the then-part or // else-part depending of the result of evaluating the condition. { If ifC = (If)exp; if (ifC.ElsePart != null) { return(" if (" + GenerateLaTexString(ifC.Condition) + ") \\{" + GenerateLaTexString(ifC.ThenPart) + "\\} else \\{" + GenerateLaTexString(ifC.ElsePart) + "\\}"); } else { return(" if (" + GenerateLaTexString(ifC.Condition) + ") \\{" + GenerateLaTexString(ifC.ThenPart) + "\\}"); } } case ExpressionType.Sequence: return(GenerateLaTexString(((Sequence)exp).FirstPart) + ";" + GenerateLaTexString(((Sequence)exp).SecondPart)); case ExpressionType.While: return("while (" + GenerateLaTexString(((While)exp).Test) + ") \\{" + GenerateLaTexString(((While)exp).Body) + "\\}"); case ExpressionType.StaticMethodCall: StaticMethodCall call = exp as StaticMethodCall; StringBuilder strbui = new StringBuilder("call(" + call.MethodName + ","); for (int i = 0; i < call.Arguments.Length; i++) { if (i == call.Arguments.Length - 1) { strbui.Append(call.Arguments[i].ToString()); } else { strbui.Append(call.Arguments[i] + ",~"); } } strbui.Append(")"); return(strbui.ToString()); } return(""); }
public static Expression TestMethod(StaticMethodCall call, IToken ID1, Dictionary <string, ChannelQueue> ChannelDatabase, Dictionary <string, Expression> ConstantDatabase, SpecificationBase Spec) //IToken methodName, int size { if (ChannelDatabase != null) { switch (call.MethodName) { case Common.Classes.Ultility.Constants.cfull: case Common.Classes.Ultility.Constants.cempty: case Common.Classes.Ultility.Constants.ccount: case Common.Classes.Ultility.Constants.csize: case Common.Classes.Ultility.Constants.cpeek: if (call.Arguments.Length != 1) { throw new ParsingException(call.MethodName + " can only take exactly one argument!", ID1); } string cname = call.Arguments[0].ToString(); if (!ChannelDatabase.ContainsKey(cname)) { throw new ParsingException(cname + " is not a valid channel name!", ID1); } else if (ChannelDatabase[cname].Size == 0) { throw new ParsingException(call + " cannot invoke on a synchronous channel!", ID1); } return(call); } foreach (Expression argument in call.Arguments) { if (ChannelDatabase.ContainsKey(argument.ToString())) { throw new ParsingException("Channel name " + argument.ToString() + " cannot be used in method call!", ID1); } } } string key = call.MethodName + call.Arguments.Length; if (!Utilities.CSharpMethods.ContainsKey(key)) { if (Spec == null || !Spec.MacroDefinition.ContainsKey(key)) { throw new ParsingException(string.Format(Resources.Can_NOT_find_the_method__0__with__1__parameters_in_the_imported_C__libraries_, call.MethodName, call.Arguments.Length), ID1); } else { Dictionary <string, Expression> constMapping = new Dictionary <string, Expression>(); List <string> para = Spec.MacroDefinition[key].Key; for (int i = 0; i < para.Count; i++) { constMapping.Add(para[i], call.Arguments[i]); } AddIntoUsageTable(Spec.UsageTable, call.MethodName, ID1); //+ "(" + Common.Classes.Ultility.Ultility.PPStringList(para) + ")" return(Spec.MacroDefinition[key].Value.ClearConstant(constMapping)); } } else { return(call); } }
public static Expression TestMethod(StaticMethodCall call, IToken ID1, Dictionary <string, ChannelQueue> ChannelDatabase, Dictionary <string, Expression> ConstantDatabase) { return(TestMethod(call, ID1, ChannelDatabase, ConstantDatabase, null)); }
public const double MINIMUM_DIFFERENCE = 0.000001; //0.000001; public static void TestIsBooleanExpression(Expression p, IToken ID1, string expression, Valuation valuation, Dictionary <string, Expression> ConstantDatabase) { if (ConstantDatabase.Count > 0) { p = p.ClearConstant(ConstantDatabase); } if (p is PrimitiveApplication) { string Operator = (p as PrimitiveApplication).Operator; if (Operator == "+" || Operator == "-" || Operator == "*" || Operator == "/" || Operator == "~" || Operator == "." || Operator == "mod") //Operator == "." || { throw new ParsingException("The expression " + p + " " + expression + " must be a boolean expression!", ID1); } else if (Operator == "||" || Operator == "&&" || Operator == "!") { //recursive test the component inside TestIsBooleanExpression((p as PrimitiveApplication).Argument1, ID1, expression, valuation, ConstantDatabase); if ((p as PrimitiveApplication).Argument2 != null) { TestIsBooleanExpression((p as PrimitiveApplication).Argument2, ID1, expression, valuation, ConstantDatabase); } } else if (Operator == ">=" || Operator == "<=" || Operator == ">" || Operator == "<") { //recursive test the component inside TestIsIntExpression((p as PrimitiveApplication).Argument1, ID1, expression, valuation, ConstantDatabase); if ((p as PrimitiveApplication).Argument2 != null) { TestIsIntExpression((p as PrimitiveApplication).Argument2, ID1, expression, valuation, ConstantDatabase); } } } else if (p is Variable) { if (valuation != null && valuation.Variables != null && valuation.Variables.ContainsKey(p.ExpressionID) && !(valuation.Variables[p.ExpressionID] is BoolConstant)) { throw new ParsingException(string.Format(Resources.The_variable__0__must_be_a_boolean_variable_, p + " " + expression), ID1); } } else if (p is StaticMethodCall) { StaticMethodCall call = p as StaticMethodCall; switch (call.MethodName) { case Common.Classes.Ultility.Constants.cfull: case Common.Classes.Ultility.Constants.cempty: return; } string key = call.MethodName + call.Arguments.Length; if (Utilities.CSharpMethods.ContainsKey(key)) { if (Utilities.CSharpMethods[key].ReturnType.Name == "Boolean") { return; } } else { throw new ParsingException(string.Format("The call {0} is not defined.", call.MethodName), ID1); } throw new ParsingException(string.Format(Resources.The_static_method_call__0__must_return_a_boolean_value_, p), ID1); } else if (p is ClassMethodCall) { ClassMethodCall call = p as ClassMethodCall; if (valuation.Variables.ContainsKey(call.Variable)) { MethodInfo methodInfo = valuation.Variables[call.Variable].GetType().GetMethod(call.MethodName); if (methodInfo != null) { if (methodInfo.ReturnType.Name == "Boolean") { return; } } } else { throw new ParsingException(string.Format("The call {0} may not be defined for variable {1}.", call.MethodName, call.Variable), ID1); } throw new ParsingException(string.Format(Resources.The_static_method_call__0__must_return_a_boolean_value_, p), ID1); } else if (p is Assignment) { Assignment assign = p as Assignment; TestIsBooleanExpression(assign.RightHandSide, ID1, expression, valuation, ConstantDatabase); } else if (p is PropertyAssignment) { PropertyAssignment assign = p as PropertyAssignment; TestIsBooleanExpression(assign.RightHandExpression, ID1, expression, valuation, ConstantDatabase); } else if (!(p is BoolConstant) && !(p is If) && !(p is While)) { throw new ParsingException(string.Format(Resources.The_expression__0__must_be_a_boolean_expression_, p + " " + expression), ID1); } }
//IToken methodName, int size public static Expression TestMethod(StaticMethodCall call, IToken ID1, Dictionary<string, ChannelQueue> ChannelDatabase, Dictionary<string, Expression> ConstantDatabase, SpecificationBase Spec) { if (ChannelDatabase != null) { switch (call.MethodName) { case Common.Classes.Ultility.Constants.cfull: case Common.Classes.Ultility.Constants.cempty: case Common.Classes.Ultility.Constants.ccount: case Common.Classes.Ultility.Constants.csize: case Common.Classes.Ultility.Constants.cpeek: if (call.Arguments.Length != 1) { throw new ParsingException(call.MethodName + " can only take exactly one argument!", ID1); } string cname = call.Arguments[0].ToString(); if (!ChannelDatabase.ContainsKey(cname)) { throw new ParsingException(cname + " is not a valid channel name!", ID1); } else if (ChannelDatabase[cname].Size == 0) { throw new ParsingException(call + " cannot invoke on a synchronous channel!", ID1); } return call; } foreach (Expression argument in call.Arguments) { if (ChannelDatabase.ContainsKey(argument.ToString())) { throw new ParsingException("Channel name " + argument.ToString() + " cannot be used in method call!", ID1); } } } string key = call.MethodName + call.Arguments.Length; if (!Utilities.CSharpMethods.ContainsKey(key)) { if (Spec == null || !Spec.MacroDefinition.ContainsKey(key)) { throw new ParsingException(string.Format(Resources.Can_NOT_find_the_method__0__with__1__parameters_in_the_imported_C__libraries_, call.MethodName, call.Arguments.Length), ID1); } else { Dictionary<string, Expression> constMapping = new Dictionary<string, Expression>(); List<string> para = Spec.MacroDefinition[key].Key; for (int i = 0; i < para.Count; i++) { constMapping.Add(para[i], call.Arguments[i]); } AddIntoUsageTable(Spec.UsageTable, call.MethodName, ID1); //+ "(" + Common.Classes.Ultility.Ultility.PPStringList(para) + ")" return Spec.MacroDefinition[key].Value.ClearConstant(constMapping); } } else { return call; } }
public static Expression TestMethod(StaticMethodCall call, IToken ID1, Dictionary<string, ChannelQueue> ChannelDatabase, Dictionary<string, Expression> ConstantDatabase) { return TestMethod(call, ID1, ChannelDatabase, ConstantDatabase, null); }