/// <summary> /// Checks an expression associated to a model element /// </summary> /// <param name="model">The model element on which the expression is defined</param> /// <param name="expression">The expression to check</param> /// <returns>the expression parse tree</returns> private Interpreter.Expression checkExpression(ModelElement model, string expression) { Interpreter.Expression retVal = null; Interpreter.Parser parser = model.EFSSystem.Parser; try { retVal = parser.Expression(model, expression); if (retVal != null) { retVal.checkExpression(); Types.Type type = retVal.GetExpressionType(); if (type == null) { model.AddError("Cannot determine expression type (5) for " + retVal.ToString()); } } else { model.AddError("Cannot parse expression"); } } catch (Exception exception) { model.AddException(exception); } return(retVal); }
private void CheckActualAgainstFormal(Dictionary<string, Expression> actuals, Expression expression, Parameter parameter) { actuals[parameter.Name] = expression; expression.checkExpression(); Types.Type argumentType = expression.GetExpressionType(); if (argumentType == null) { AddError("Cannot evaluate argument type for argument " + expression.ToString()); } else { if (parameter.Type == null) { AddError("Cannot evaluate formal parameter type for " + parameter.Name); } else { if (!parameter.Type.Match(argumentType)) { AddError("Invalid argument " + expression.ToString() + " type, expected " + parameter.Type.FullName + ", actual " + argumentType.FullName); } } } }
/// <summary> /// Ensures that the parameter provided corresponds to a function double->double /// </summary> /// <param name="root">Element on which the errors shall be attached</param> /// <param name="context">The context used to evaluate the expression</param> /// <param name="expression">The expression which references the function</param> /// <param name="count">the expected number of parameters</param> protected virtual void CheckFunctionalParameter(ModelElement root, InterpretationContext context, Expression expression, int count) { Type type = expression.GetExpressionType(); Function function = type as Function; if (function != null) { if (function.FormalParameters.Count == count) { foreach (Parameter parameter in function.FormalParameters) { if (!parameter.Type.IsDouble()) { root.AddError(expression.ToString() + " does not takes a double for parameter " + parameter.Name); } } } else { root.AddError(expression.ToString() + " does not take " + count + "parameter(s) as input"); } if (!function.ReturnType.IsDouble()) { root.AddError(expression.ToString() + " does not return a double"); } } else { if (!type.IsDouble()) { root.AddError(expression.ToString() + " type is not double"); } } }