/// <summary> /// Checks the expression and appends errors to the root tree node when inconsistencies are found /// </summary> public override void CheckExpression() { Structure structureType = Structure.GetExpressionType() as Structure; if (structureType != null) { if (structureType.IsAbstract) { AddError("Instantiation of abstract types is forbidden", RuleChecksEnum.SyntaxError); } foreach (KeyValuePair <Designator, Expression> pair in Associations) { Designator name = pair.Key; Expression expression = pair.Value; List <INamable> targets = new List <INamable>(); structureType.Find(name.Image, targets); if (targets.Count > 0) { expression.CheckExpression(); Type type = expression.GetExpressionType(); if (type != null) { if (type.IsAbstract) { AddError("Instantiation of abstract types is forbidden", RuleChecksEnum.SyntaxError); } else { foreach (INamable namable in targets) { ITypedElement element = namable as ITypedElement; if (element != null && element.Type != null) { if (!element.Type.Match(type)) { AddError("Expression " + expression + " type (" + type.FullName + ") does not match the target element " + element.Name + " type (" + element.Type.FullName + ")", RuleChecksEnum.SyntaxError); } } } } } else { AddError("Expression " + expression + " type cannot be found", RuleChecksEnum.SyntaxError); } } else { Root.AddError("Cannot find " + name + " in structure " + Structure); } } } else { AddError("Cannot find structure type " + Structure, RuleChecksEnum.SyntaxError); } }
/// <summary> /// Checks the expression and appends errors to the root tree node when inconsistencies are found /// </summary> public override void CheckExpression() { base.CheckExpression(); BindingExpression.CheckExpression(); Expression.CheckExpression(); }
private void CheckActualAgainstFormal(Dictionary <string, Expression> actuals, Expression expression, Parameter parameter) { actuals[parameter.Name] = expression; expression.CheckExpression(); Type argumentType = expression.GetExpressionType(); if (argumentType == null) { AddError("Cannot evaluate argument type for argument " + expression, RuleChecksEnum.SemanticAnalysisError); } else { if (parameter.Type == null) { AddError("Cannot evaluate formal parameter type for " + parameter.Name, RuleChecksEnum.SemanticAnalysisError); } else { if (!parameter.Type.Match(argumentType)) { AddError("Invalid argument " + expression + " type, expected " + parameter.Type.FullName + ", actual " + argumentType.FullName, RuleChecksEnum.SemanticAnalysisError); } } } }
/// <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() { base.CheckExpression(); InitialValue.CheckExpression(); Type initialValueType = InitialValue.GetExpressionType(); if (initialValueType != null) { Expression.CheckExpression(); 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, RuleChecksEnum.SemanticAnalysisError); } } else { AddError("Cannot determine type of expression " + Expression, RuleChecksEnum.SemanticAnalysisError); } Type conditionType = Condition.GetExpressionType(); if (conditionType != null) { if (!(conditionType is BoolType)) { AddError("Condition " + Condition + " does not evaluate to a boolean", RuleChecksEnum.SemanticAnalysisError); } } else { AddError("Cannot determine type of condition " + Condition, RuleChecksEnum.SyntaxError); } } else { AddError("Cannot determine type of the initial value " + InitialValue, RuleChecksEnum.SemanticAnalysisError); } }
private void CheckActualAgainstFormal(Dictionary<string, Expression> actuals, Expression expression, Parameter parameter) { actuals[parameter.Name] = expression; expression.CheckExpression(); Type argumentType = expression.GetExpressionType(); if (argumentType == null) { AddError("Cannot evaluate argument type for argument " + expression); } else { if (parameter.Type == null) { AddError("Cannot evaluate formal parameter type for " + parameter.Name); } else { if (!parameter.Type.Match(argumentType)) { AddError("Invalid argument " + expression + " type, expected " + parameter.Type.FullName + ", actual " + argumentType.FullName); } } } }