/// <summary> /// Checks the expression and appends errors to the root tree node when inconsistencies are found /// </summary> public override void CheckExpression() { base.CheckExpression(); Type initialValueType = InitialValue.GetExpressionType(); if (initialValueType != null) { Collection listExpressionType = ListExpression.GetExpressionType() as Collection; if (listExpressionType != null) { IteratorExpression.CheckExpression(); } } else { AddError("Cannot determine initial value expression type for " + ToString(), RuleChecksEnum.SemanticAnalysisError); } bool refToResultFound = false; foreach (Usage usage in IteratorExpression.StaticUsage.AllUsages) { if (usage.Referenced == AccumulatorVariable && usage.Mode == Usage.ModeEnum.Read) { refToResultFound = true; break; } } if (!refToResultFound) { AddError("REDUCE expressions should reference RESULT variable", RuleChecksEnum.SyntaxError); } }
/// <summary> /// Performs the semantic analysis of the expression /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <paraparam name="expectation">Indicates the kind of element we are looking for</paraparam> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(Utils.INamable instance, Filter.AcceptableChoice expectation) { bool retVal = base.SemanticAnalysis(instance, expectation); if (retVal) { InitialValue.SemanticAnalysis(instance, Filter.AllMatches); AccumulatorVariable.Type = InitialValue.GetExpressionType(); } return(retVal); }
/// <summary> /// Performs the semantic analysis of the expression /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <paraparam name="expectation">Indicates the kind of element we are looking for</paraparam> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(Utils.INamable instance, Filter.AcceptableChoice expectation) { bool retVal = base.SemanticAnalysis(instance, expectation); if (retVal) { InitialValue.SemanticAnalysis(instance, Filter.IsRightSide); Expression.SemanticAnalysis(instance, Filter.AllMatches); Condition.SemanticAnalysis(instance, Filter.AllMatches); LastIteration.Type = InitialValue.GetExpressionType(); CurrentIteration.Type = InitialValue.GetExpressionType(); } return(retVal); }
/// <summary> /// Performs the semantic analysis of the expression /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <param name="expectation">Indicates the kind of element we are looking for</param> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(INamable instance, BaseFilter expectation) { bool retVal = base.SemanticAnalysis(instance, expectation); if (retVal) { // InitialValue if (InitialValue != null) { InitialValue.SemanticAnalysis(instance, IsRightSide.INSTANCE); StaticUsage.AddUsages(InitialValue.StaticUsage, Usage.ModeEnum.Read); LastIteration.Type = InitialValue.GetExpressionType(); CurrentIteration.Type = InitialValue.GetExpressionType(); StaticUsage.AddUsage(InitialValue.GetExpressionType(), Root, Usage.ModeEnum.Type); } else { AddError("Initial value not provided", RuleChecksEnum.SemanticAnalysisError); } // Expression if (Expression != null) { Expression.SemanticAnalysis(instance, AllMatches.INSTANCE); StaticUsage.AddUsages(Expression.StaticUsage, Usage.ModeEnum.Read); } else { Root.AddError("Accumulator expression value not provided"); } // Condition if (Condition != null) { Condition.SemanticAnalysis(instance, AllMatches.INSTANCE); StaticUsage.AddUsages(Condition.StaticUsage, Usage.ModeEnum.Read); } else { Root.AddError("Stop condition not provided"); } } 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(); Types.Type initialValueType = InitialValue.GetExpressionType(); if (initialValueType != null) { Types.Collection listExpressionType = ListExpression.GetExpressionType() as Types.Collection; if (listExpressionType != null) { IteratorExpression.checkExpression(); } } else { AddError("Cannot determine initial value expression type for " + ToString()); } }
/// <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); } }
/// <summary> /// Performs the semantic analysis of the expression /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <param name="expectation">Indicates the kind of element we are looking for</param> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(INamable instance, BaseFilter expectation) { bool retVal = base.SemanticAnalysis(instance, expectation); if (retVal) { if (InitialValue != null) { InitialValue.SemanticAnalysis(instance, AllMatches.INSTANCE); StaticUsage.AddUsages(InitialValue.StaticUsage, Usage.ModeEnum.Read); AccumulatorVariable.Type = InitialValue.GetExpressionType(); } else { AddError("Initial value not provided", RuleChecksEnum.SemanticAnalysisError); } } return(retVal); }
/// <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> /// Provides the type of this expression /// </summary> /// <param name="context">The interpretation context</param> /// <returns></returns> public override Types.Type GetExpressionType() { return(InitialValue.GetExpressionType()); }