/// <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");
}
}
}