public override void visit(Generated.Case obj, bool visitSubNodes)
{
Functions.Case cas = obj as Functions.Case;
try
{
Interpreter.Expression expression = cas.Expression;
if (expression != null)
{
expression.checkExpression();
Types.Type expressionType = cas.Expression.GetExpressionType();
if (expressionType != null)
{
if (!cas.EnclosingFunction.ReturnType.Match(expressionType))
{
cas.AddError("Expression type (" + expressionType.FullName + ") does not match function return type (" + cas.EnclosingFunction.ReturnType.Name + ")");
}
}
else
{
cas.AddError("Cannot determine expression type (6) for " + cas.Expression.ToString());
}
}
else
{
cas.AddError("Cannot evaluate expression " + cas.ExpressionText);
}
}
catch (Exception e)
{
cas.AddException(e);
}
base.visit(obj, visitSubNodes);
}
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>
/// 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);
}
/// <summary>
/// Checks the expression and appends errors to the root tree node when inconsistencies are found
/// </summary>
public override void checkExpression()
{
base.checkExpression();
if (Term != null)
{
Term.checkExpression();
}
if (Expression != null)
{
Expression.checkExpression();
}
}
/// <summary>
/// Checks the expression and appends errors to the root tree node when inconsistencies are found
/// </summary>
public override void checkExpression()
{
Types.Structure structureType = Structure.GetExpressionType() as Types.Structure;
if (structureType != null)
{
foreach (KeyValuePair <string, Expression> pair in Associations)
{
string name = pair.Key;
Expression expression = pair.Value;
List <Utils.INamable> targets = new List <Utils.INamable>();
structureType.Find(name, targets);
if (targets.Count > 0)
{
expression.checkExpression();
Types.Type type = expression.GetExpressionType();
if (type != null)
{
foreach (Utils.INamable namable in targets)
{
Types.ITypedElement element = namable as Types.ITypedElement;
if (element != null && element.Type != null)
{
if (!element.Type.Match(type))
{
AddError("Expression " + expression.ToString() + " type (" + type.FullName + ") does not match the target element " + element.Name + " type (" + element.Type.FullName + ")");
}
}
}
}
else
{
AddError("Expression " + expression.ToString() + " type cannot be found");
}
}
else
{
Root.AddError("Cannot find " + name + " in structure " + Structure.ToString());
}
}
}
else
{
AddError("Cannot find structure type " + Structure.ToString());
}
}
/// <summary>
/// Checks the expression and appends errors to the root tree node when inconsistencies are found
/// </summary>
/// <param name="context">The interpretation context</param>
public override void checkExpression()
{
base.checkExpression();
InitialValue.checkExpression();
Types.Type initialValueType = InitialValue.GetExpressionType();
if (initialValueType != null)
{
Expression.checkExpression();
Types.Type expressionType = Expression.GetExpressionType();
if (expressionType != null)
{
if (expressionType != initialValueType)
{
AddError("Expression " + Expression + " has not the same type (" + expressionType.FullName + " than initial value " + InitialValue + " type " + initialValueType.FullName);
}
}
else
{
AddError("Cannot determine type of expression " + Expression);
}
Types.Type conditionType = Condition.GetExpressionType();
if (conditionType != null)
{
if (!(conditionType is Types.BoolType))
{
AddError("Condition " + Condition + " does not evaluate to a boolean");
}
}
else
{
AddError("Cannot determine type of condition " + Condition);
}
}
else
{
AddError("Cannot determine type of the initial value " + InitialValue);
}
}
/// <summary>
/// Checks the expression and appends errors to the root tree node when inconsistencies are found
/// </summary>
/// <param name="context">The interpretation context</param>
public override void checkExpression()
{
base.checkExpression();
Expression.checkExpression();
}
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);
}
}
}
}
