/// <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) { // ListExpression if (ListExpression != null) { ListExpression.SemanticAnalysis(instance, IsRightSide.INSTANCE); StaticUsage.AddUsages(ListExpression.StaticUsage, Usage.ModeEnum.Read); Collection collectionType = ListExpression.GetExpressionType() as Collection; if (collectionType != null) { StaticUsage.AddUsage(collectionType, Root, Usage.ModeEnum.Type); IteratorVariable.Type = collectionType.Type; PreviousIteratorVariable.Type = collectionType.Type; } else { AddError("Cannot determine collection type on list expression " + ToString(), RuleChecksEnum.SemanticAnalysisError); } } else { AddError("List expression not provided", RuleChecksEnum.SemanticAnalysisError); } } return(retVal); }
/// <summary> /// Performs the semantic analysis of the statement /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(INamable instance = null) { bool retVal = base.SemanticAnalysis(instance); if (retVal) { // ListExpression if (ListExpression != null) { ListExpression.SemanticAnalysis(instance); StaticUsage.AddUsages(ListExpression.StaticUsage, Usage.ModeEnum.ReadAndWrite); Collection collectionType = ListExpression.GetExpressionType() as Collection; if (collectionType != null) { IteratorVariable.Type = collectionType.Type; } } else { AddError("List expression not provided", RuleChecksEnum.SemanticAnalysisError); } // Condition if (Condition != null) { Condition.SemanticAnalysis(instance); StaticUsage.AddUsages(Condition.StaticUsage, Usage.ModeEnum.Read); } } 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) { Type elementType = null; if (ListElements != null) { foreach (Expression expr in ListElements) { expr.SemanticAnalysis(instance, expectation); StaticUsage.AddUsages(expr.StaticUsage, null); Type current = expr.GetExpressionType(); if (elementType == null) { elementType = current; } else { if (!current.Match(elementType)) { AddError("Cannot mix types " + current + " and " + elementType + "in collection", RuleChecksEnum.SemanticAnalysisError); } } } } if (elementType != null) { ExpressionType = (Collection)acceptor.getFactory().createCollection(); ExpressionType.Type = elementType; ExpressionType.Name = "ListOf_" + elementType.FullName; ExpressionType.Enclosing = Root.EFSSystem; ExpressionType.setMaxSize(ListElements.Count); StaticUsage.AddUsage(elementType, Root, Usage.ModeEnum.Type); } else { ExpressionType = new GenericCollection(EfsSystem.Instance); } } 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) { // Condition if (Condition != null) { Condition.SemanticAnalysis(instance, expectation); StaticUsage.AddUsages(Condition.StaticUsage, Usage.ModeEnum.Read); } } 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) { Ref = null; ReturnValue tmp = GetReferences(instance, expectation, false); if (tmp.IsUnique) { // Unique element has been found. Reference it and perform the semantic analysis // on all dereferenced expression, now that the context is known for each expression Ref = tmp.Values[0].Value; StaticUsage.AddUsage(Ref, Root, null); References referenceFilter; ReturnValueElement current = tmp.Values[0]; for (int i = Arguments.Count - 1; i > 0; i--) { referenceFilter = new References(current.Value); current = current.PreviousElement; Arguments[i].SemanticAnalysis(current.Value, referenceFilter); StaticUsage.AddUsages(Arguments[i].StaticUsage, null); StaticUsage.AddUsage(Arguments[i].Ref, Root, null); } referenceFilter = new References(current.Value); Arguments[0].SemanticAnalysis(null, referenceFilter); StaticUsage.AddUsages(Arguments[0].StaticUsage, null); StaticUsage.AddUsage(Arguments[0].Ref, Root, null); } else if (tmp.IsAmbiguous) { // Several possible interpretations for this deref expression, not allowed AddError("Expression " + ToString() + " may have several interpretations " + tmp + ", please disambiguate", RuleChecksEnum.SemanticAnalysisError); } else { // No possible interpretation for this deref expression, not allowed AddError("Expression " + ToString() + " has no interpretation", RuleChecksEnum.SemanticAnalysisError); } } 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> /// 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) { // Binding expression if (BindingExpression != null) { BindingExpression.SemanticAnalysis(instance, IsRightSide.INSTANCE); StaticUsage.AddUsages(BindingExpression.StaticUsage, Usage.ModeEnum.Read); Type bindingExpressionType = BindingExpression.GetExpressionType(); if (bindingExpressionType != null) { StaticUsage.AddUsage(bindingExpressionType, Root, Usage.ModeEnum.Type); BoundVariable.Type = bindingExpressionType; } else { AddError("Cannot determine binding expression type for " + ToString(), RuleChecksEnum.SemanticAnalysisError); } } else { AddError("Binding expression not provided", RuleChecksEnum.SemanticAnalysisError); } // The evaluated expression if (Expression != null) { Expression.SemanticAnalysis(instance, expectation); StaticUsage.AddUsages(Expression.StaticUsage, Usage.ModeEnum.Read); } else { AddError("Value expression not provided", RuleChecksEnum.SemanticAnalysisError); } } 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) { if (Expression != null) { Expression.SemanticAnalysis(instance, AllMatches.INSTANCE); StaticUsage.AddUsages(Expression.StaticUsage, null); } else { AddError("Function body not provided", RuleChecksEnum.SemanticAnalysisError); } } return(retVal); }
/// <summary> /// Performs the semantic analysis of the statement /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(INamable instance = null) { bool retVal = base.SemanticAnalysis(instance); if (retVal) { if (Call != null) { Call.SemanticAnalysis(instance); StaticUsage.AddUsages(Call.StaticUsage, Usage.ModeEnum.Call); } else { AddError("Called procedure not provided", RuleChecksEnum.SemanticAnalysisError); } } 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) { // Iterator expression if (IteratorExpression != null) { IteratorExpression.SemanticAnalysis(instance, AllMatches.INSTANCE); StaticUsage.AddUsages(IteratorExpression.StaticUsage, Usage.ModeEnum.Read); } else { AddError("Iterator expression not provided", RuleChecksEnum.SemanticAnalysisError); } } 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) { // Called if (Called != null) { Called.SemanticAnalysis(instance, IsCallable.INSTANCE); StaticUsage.AddUsages(Called.StaticUsage, Usage.ModeEnum.Call); // Actual parameters foreach (Expression actual in ActualParameters) { actual.SemanticAnalysis(instance, IsActualParameter.INSTANCE); StaticUsage.AddUsages(actual.StaticUsage, Usage.ModeEnum.Read); } foreach (KeyValuePair <Designator, Expression> pair in NamedActualParameters) { ICallable called = Called.Ref as ICallable; if (called != null) { pair.Key.Ref = called.GetFormalParameter(pair.Key.Image); StaticUsage.AddUsage(pair.Key.Ref, Root, Usage.ModeEnum.Parameter); } pair.Value.SemanticAnalysis(instance, IsActualParameter.INSTANCE); StaticUsage.AddUsages(pair.Value.StaticUsage, Usage.ModeEnum.Read); } ParameterAssociation = CreateParameterAssociation(Called.Ref as ICallable); } else { AddError("Called function not provided", RuleChecksEnum.SemanticAnalysisError); } } 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) { 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> /// Performs the semantic analysis of the statement /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(INamable instance = null) { bool retVal = base.SemanticAnalysis(instance); if (retVal) { // Value if (Value != null) { Value.SemanticAnalysis(instance); StaticUsage.AddUsages(Value.StaticUsage, Usage.ModeEnum.Read); } else { AddError("Value to insert not provided", RuleChecksEnum.SemanticAnalysisError); } // ListExpression if (ListExpression != null) { ListExpression.SemanticAnalysis(instance, IsLeftSide.INSTANCE); StaticUsage.AddUsages(ListExpression.StaticUsage, Usage.ModeEnum.ReadAndWrite); } else { AddError("List expression not provided", RuleChecksEnum.SemanticAnalysisError); } // ReplaceElement if (ReplaceElement != null) { ReplaceElement.SemanticAnalysis(instance); StaticUsage.AddUsages(ReplaceElement.StaticUsage, Usage.ModeEnum.Read); } } 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) { // Structure if (Structure != null) { Structure.SemanticAnalysis(instance, IsStructure.INSTANCE); StaticUsage.AddUsages(Structure.StaticUsage, Usage.ModeEnum.Type); // Structure field Association if (Associations != null) { Structure structureType = Structure.Ref as Structure; foreach (KeyValuePair <Designator, Expression> pair in Associations) { if (structureType != null) { pair.Key.Ref = structureType.FindStructureElement(pair.Key.Image); StaticUsage.AddUsage(pair.Key.Ref, Root, Usage.ModeEnum.Parameter); } pair.Value.SemanticAnalysis(instance, IsRightSide.INSTANCE); StaticUsage.AddUsages(pair.Value.StaticUsage, Usage.ModeEnum.Read); } } } else { AddError("Structure type not specified", RuleChecksEnum.SemanticAnalysisError); } } return(retVal); }
/// <summary> /// Performs the semantic analysis of the statement /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(INamable instance = null) { bool retVal = base.SemanticAnalysis(instance); if (retVal) { // VariableIdentification if (VariableIdentification != null) { VariableIdentification.SemanticAnalysis(instance, IsLeftSide.INSTANCE); StaticUsage.AddUsages(VariableIdentification.StaticUsage, Usage.ModeEnum.Write); } else { AddError("Altered variable not specified", RuleChecksEnum.SemanticAnalysisError); } // Expression Expression.SemanticAnalysis(instance, IsRightSide.INSTANCE); StaticUsage.AddUsages(Expression.StaticUsage, Usage.ModeEnum.Read); } return(retVal); }
/// <summary> /// Performs the semantic analysis of the statement /// </summary> /// <param name="instance">the reference instance on which this element should analysed</param> /// <returns>True if semantic analysis should be continued</returns> public override bool SemanticAnalysis(INamable instance = null) { bool retVal = base.SemanticAnalysis(instance); if (retVal) { // ListExpression Collection collectionType = null; if (ListExpression != null) { ListExpression.SemanticAnalysis(instance); StaticUsage.AddUsages(ListExpression.StaticUsage, Usage.ModeEnum.ReadAndWrite); collectionType = ListExpression.GetExpressionType() as Collection; if (collectionType != null) { IteratorVariable.Type = collectionType.Type; } else { AddError("Cannot determine collection type", RuleChecksEnum.SemanticAnalysisError); } } else { AddError("List expression not provided", RuleChecksEnum.SemanticAnalysisError); } // Value if (Value != null) { Value.SemanticAnalysis(instance); StaticUsage.AddUsages(Value.StaticUsage, Usage.ModeEnum.Read); Type valueType = Value.GetExpressionType(); if (valueType != null) { if (collectionType != null && !valueType.Match(collectionType.Type)) { AddError("Type of " + Value + " does not match collection type " + collectionType, RuleChecksEnum.SemanticAnalysisError); } } else { AddError("Cannot determine type of " + Value, RuleChecksEnum.SemanticAnalysisError); } } else { AddError("Replacement value not provided", RuleChecksEnum.SemanticAnalysisError); } // Condition if (Condition != null) { Condition.SemanticAnalysis(instance); StaticUsage.AddUsages(Condition.StaticUsage, Usage.ModeEnum.Read); } } return(retVal); }