public override Expression ClearConstant(Dictionary <string, Expression> constMapping) { if (Argument2 != null) { return(new PrimitiveApplication(Operator, Argument1.ClearConstant(constMapping), Argument2.ClearConstant(constMapping))); } else { return(new PrimitiveApplication(Operator, Argument1.ClearConstant(constMapping))); } }
public IndexedExpression ClearConstant(Dictionary <string, Expression> constMapping) { Expression newExpression = Expression.ClearConstant(constMapping); List <ParallelDefinition> newDefinitions = new List <ParallelDefinition>(Definitions.Count); foreach (ParallelDefinition definition in Definitions) { newDefinitions.Add(definition.ClearConstant(constMapping)); } return(new IndexedExpression(Operator, newDefinitions, newExpression)); }
public override Expression ClearConstant(Dictionary <string, Expression> constMapping) { Expression[] newArgs = new Expression[Arguments.Length]; for (int i = 0; i < Arguments.Length; i++) { newArgs[i] = Arguments[i].ClearConstant(constMapping); } return(new ClassMethodCallInstance(Variable.ClearConstant(constMapping), MethodName, newArgs)); }
public override Expression ClearConstant(Dictionary <string, Expression> constMapping) { return(new If(Condition.ClearConstant(constMapping), ThenPart.ClearConstant(constMapping), ElsePart == null ? null : ElsePart.ClearConstant(constMapping))); }
public override Expression ClearConstant(Dictionary <string, Expression> constMapping) { return(new While(Test.ClearConstant(constMapping), Body.ClearConstant(constMapping))); }
public override Expression ClearConstant(Dictionary <string, Expression> constMapping) { return(new ClassProperty(Variable.ClearConstant(constMapping), PropertyName)); }
public override Expression ClearConstant(Dictionary <string, Expression> constMapping) { return(new ClassPropertyAssignment(ClassProperty.ClearConstant(constMapping) as ClassProperty, RightHandExpression.ClearConstant(constMapping))); }
public override Expression ClearConstant(Dictionary <string, Expression> constMapping) { return(new Sequence(FirstPart.ClearConstant(constMapping), SecondPart.ClearConstant(constMapping))); }
public override Expression ClearConstant(Dictionary <string, Expression> constMapping) { return(new LetDefinition(Variable, RightHandExpression.ClearConstant(constMapping))); }
public override Expression ClearConstant(Dictionary <string, Expression> constMapping) { return(new Assignment((constMapping.ContainsKey(LeftHandSide)? constMapping[LeftHandSide].ExpressionID: LeftHandSide), RightHandSide.ClearConstant(constMapping))); }
public override Expression ClearConstant(Dictionary <string, Expression> constMapping) { return(new PropertyAssignment(RecordExpression.ClearConstant(constMapping), PropertyExpression.ClearConstant(constMapping), RightHandExpression.ClearConstant(constMapping))); }
public static void UpdateClockBounds(Expression expression, Dictionary<string, Expression> constantDB, int oldCeiling, int oldFloor, out int ceiling, out int floor) { try { if (constantDB.Count > 0) { expression = expression.ClearConstant(constantDB); } if (!expression.HasVar) { ExpressionValue rhv = EvaluatorDenotational.Evaluate(expression, null); if (rhv is IntConstant) { IntConstant v = rhv as IntConstant; ceiling = Math.Max(v.Value, oldCeiling); floor = Math.Min(v.Value, oldFloor); return; } } } catch (Exception ex) { } ceiling = oldCeiling; floor = oldFloor; }
public static void TestIsIntExpression(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 == "!" || Operator == ">=" || Operator == "<=") { throw new ParsingException(string.Format(Resources.The_expression__0__must_be_an_integer_expression_, p + " " + expression), ID1); } //else //{ // //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 IntConstant)) { throw new ParsingException(string.Format(Resources.The_variable__0__must_be_an_integer_variable_, p + " " + expression), ID1); } } else if (p is StaticMethodCall) { StaticMethodCall call = p as StaticMethodCall; switch (call.MethodName) { case Common.Classes.Ultility.Constants.ccount: case Common.Classes.Ultility.Constants.csize: return; } string key = call.MethodName + call.Arguments.Length; if (Utilities.CSharpMethods.ContainsKey(key)) { if (Utilities.CSharpMethods[key].ReturnType.Name == "Int32") { 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_an_integer_value_, ID1.Text), 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 == "Int32") { 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_method_call__0__must_return_an_integer_value_, p), ID1); } else if (p is Assignment) { Assignment assign = p as Assignment; TestIsIntExpression(assign.RightHandSide,ID1, expression, valuation, ConstantDatabase); } else if (p is PropertyAssignment) { PropertyAssignment assign = p as PropertyAssignment; TestIsIntExpression(assign.RightHandExpression, ID1, expression, valuation, ConstantDatabase); } else if (!(p is IntConstant) && !(p is ClassMethodCall) && !(p is If) && !(p is While) ) { throw new ParsingException(string.Format(Resources.The_expression__0__must_be_an_integer_expression_, p + " " + expression), ID1); } }
public static IntConstant EvaluateIntExpression(Expression exp, IToken token, Dictionary<string, Expression> constantDB) { try { if (constantDB.Count > 0) { exp = exp.ClearConstant(constantDB); } if (exp.HasVar) { List<string> vars = exp.GetVars(); throw new ParsingException(string.Format(Resources.Variables___0___can_not_be_used_in_this_expression_, Classes.Ultility.Ultility.PPStringList(vars)) + exp, token); } ExpressionValue rhv = EvaluatorDenotational.Evaluate(exp, null); if (rhv is IntConstant) { return rhv as IntConstant; } else { throw new ParsingException(Resources.The_expression_should_return_an_integer_value_, token); } } catch (Exception ex) { throw new ParsingException(ex.Message, token); } }
//public static void CheckParameterVarUsedInMathExpression(Expression e1, Dictionary<string, string> ParameterVariables, IToken token) //{ // if (e1 is Variable) // { // string name = ((Variable) e1).VarName; // if (ParameterVariables.ContainsKey(name)) // { // throw new ParsingException("Can not use parameter variable " + name + " in math expression!", token); // } // } //} public static void CheckTimedExpressionWithGlobalVariable(Expression e1, IToken token, Dictionary<string, Expression> ConstantDatabase, List<IToken> GlobalVarNames) { if (ConstantDatabase.Count > 0) { e1 = e1.ClearConstant(ConstantDatabase); } List<string> evars = e1.GetVars(); if (evars.Count >= 1) { foreach (string evar in evars) { foreach (IToken gvar in GlobalVarNames) { if (gvar.Text == evar) { throw new ParsingException("Global variable (" + evar + ") cannot be used in timed process!", token); } } } } }