コード例 #1
0
        /// <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(Utils.INamable instance)
        {
            bool retVal = base.SemanticAnalysis(instance);

            if (retVal)
            {
                ListExpression.SemanticAnalysis(instance);
                Types.Collection collectionType = ListExpression.GetExpressionType() as Types.Collection;
                if (collectionType != null)
                {
                    IteratorVariable.Type = collectionType.Type;
                }

                Value.SemanticAnalysis(instance);
                Types.Type valueType = Value.GetExpressionType();
                if (valueType != null)
                {
                    if (!valueType.Match(collectionType.Type))
                    {
                        AddError("Type of " + Value + " does not match collection type " + collectionType);
                    }
                }
                else
                {
                    AddError("Cannot determine type of " + Value);
                }

                if (Condition != null)
                {
                    Condition.SemanticAnalysis(instance);
                }
            }

            return(retVal);
        }
コード例 #2
0
        /// <summary>
        /// Checks the statement for semantical errors
        /// </summary>
        public override void CheckStatement()
        {
            Value.checkExpression();

            Types.Collection targetListType = ListExpression.GetExpressionType() as Types.Collection;
            if (targetListType != null)
            {
                Types.Type elementType = Value.GetExpressionType();
                if (elementType != targetListType.Type)
                {
                    Root.AddError("Inserted element type does not corresponds to list type");
                }

                Condition.checkExpression();
                Types.BoolType conditionType = Condition.GetExpressionType() as Types.BoolType;
                if (conditionType == null)
                {
                    Root.AddError("Condition does not evaluates to boolean");
                }
            }
            else
            {
                Root.AddError("Cannot determine collection type of " + ListExpression);
            }
        }
コード例 #3
0
        /// <summary>
        /// Checks the expression and appends errors to the root tree node when inconsistencies are found
        /// </summary>
        public override void checkExpression()
        {
            base.checkExpression();

            Types.Collection listExpressionType = ListExpression.GetExpressionType() as Types.Collection;
            if (listExpressionType != null)
            {
                IteratorExpression.checkExpression();
            }
        }
コード例 #4
0
        /// <summary>
        /// Checks the statement for semantical errors
        /// </summary>
        public override void CheckStatement()
        {
            InterpretationContext context = new InterpretationContext(Root);

            Types.Collection listExpressionType = ListExpression.GetExpressionType() as Types.Collection;
            if (listExpressionType == null)
            {
                Root.AddError("Target does not references a list variable");
            }

            context.LocalScope.setVariable(IteratorVariable);
            Call.CheckStatement(context);
        }
コード例 #5
0
        /// <summary>
        /// Evaluates the rules associated to a single variable
        /// </summary>
        /// <param name="priority"></param>
        /// <param name="activations"></param>
        /// <param name="variable"></param>
        private void EvaluateVariable(Generated.acceptor.RulePriority priority, HashSet <Activation> activations, Variables.IVariable variable)
        {
            if (variable != null)
            {
                if (variable.Type is Types.Structure)
                {
                    List <Rules.RuleCondition> rules     = new List <RuleCondition>();
                    Types.Structure            structure = variable.Type as Types.Structure;
                    foreach (Rule rule in structure.Rules)
                    {
                        rule.Evaluate(this, priority, variable, rules);
                    }
                    Activation.RegisterRules(activations, rules, variable);

                    StructureValue value = variable.Value as StructureValue;
                    if (value != null)
                    {
                        foreach (Variables.IVariable subVariable in value.SubVariables.Values)
                        {
                            EvaluateVariable(priority, activations, subVariable);
                        }
                    }
                }
                else if (variable.Type is Types.StateMachine)
                {
                    List <Rules.RuleCondition> rules = new List <RuleCondition>();
                    EvaluateStateMachine(rules, priority, variable);
                    Activation.RegisterRules(activations, rules, variable);
                }
                else if (variable.Type is Types.Collection)
                {
                    Types.Collection collectionType = variable.Type as Types.Collection;
                    if (variable.Value != EFSSystem.EmptyValue)
                    {
                        ListValue val = variable.Value as ListValue;

                        int i = 1;
                        foreach (IValue subVal in val.Val)
                        {
                            Variables.Variable tmp = new Variables.Variable();
                            tmp.Name  = variable.Name + '[' + i + ']';
                            tmp.Type  = collectionType.Type;
                            tmp.Value = subVal;
                            EvaluateVariable(priority, activations, tmp);
                            i = i + 1;
                        }
                    }
                }
            }
        }
コード例 #6
0
        /// <summary>
        /// Provides the type of this expression
        /// </summary>
        /// <param name="context">The interpretation context</param>
        /// <returns></returns>
        public override Types.Type GetExpressionType()
        {
            Types.Type retVal = null;

            Types.Collection listType = ListExpression.GetExpressionType() as Types.Collection;
            if (listType != null)
            {
                retVal = listType.Type;
            }
            else
            {
                AddError("Cannot evaluate list type of " + ToString());
            }

            return(retVal);
        }
コード例 #7
0
        /// <summary>
        /// Creates a valid right side IValue, according to the target variable (left side)
        /// </summary>
        /// <param name="variable">The target variable</param>
        /// <param name="duplicate">Indicates that a duplication of the variable should be performed</param>
        /// <returns></returns>
        public override Values.IValue RightSide(Variables.IVariable variable, bool duplicate)
        {
            ListValue retVal = this;

            //  Complete the list with empty values
            Types.Collection collectionType = variable.Type as Types.Collection;
            if (collectionType != null)
            {
                Values.EmptyValue emptyValue = EFSSystem.EmptyValue;
                while (retVal.Val.Count < collectionType.getMaxSize())
                {
                    retVal.Val.Add(emptyValue);
                }
            }
            retVal.Enclosing = variable;

            return(retVal);
        }
コード例 #8
0
        /// <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());
            }
        }
コード例 #9
0
        /// <summary>
        /// Provides the value of the function
        /// </summary>
        /// <param name="instance">the instance on which the function is evaluated</param>
        /// <param name="actuals">the actual parameters values</param>
        /// <returns>The value for the function application</returns>
        public override Values.IValue Evaluate(Interpreter.InterpretationContext context, Dictionary <Variables.Actual, Values.IValue> actuals)
        {
            Values.IValue retVal = null;

            int token = context.LocalScope.PushContext();

            AssignParameters(context, actuals);

            Types.Collection collectionType = (Types.Collection)EFSSystem.findType(OverallNameSpaceFinder.INSTANCE.findByName(EFSSystem.Dictionaries[0], "Kernel.SpeedAndDistanceMonitoring.TargetSupervision"), "Kernel.SpeedAndDistanceMonitoring.TargetSupervision.Targets");
            Values.ListValue collection     = new Values.ListValue(collectionType, new List <Values.IValue>());

            // compute targets from the MRSP
            Function function1 = context.findOnStack(Targets1).Value as Functions.Function;

            if (function1 != null && !function1.Name.Equals("EMPTY"))
            {
                Graph graph1 = createGraphForValue(context, function1);
                ComputeTargets(graph1.Function, collection);
            }

            // compute targets from the MA
            Function function2 = context.findOnStack(Targets2).Value as Functions.Function;

            if (function2 != null && !function2.Name.Equals("EMPTY"))
            {
                Graph graph2 = createGraphForValue(context, function2);
                ComputeTargets(graph2.Function, collection);
            }

            // compute targets from the SR
            Function function3 = context.findOnStack(Targets3).Value as Functions.Function;

            if (function3 != null && !function3.Name.Equals("EMPTY"))
            {
                Graph graph3 = createGraphForValue(context, function3);
                ComputeTargets(graph3.Function, collection);
            }

            context.LocalScope.PopContext(token);

            retVal = collection;
            return(retVal);
        }
コード例 #10
0
 /// <summary>
 /// Checks the statement for semantical errors
 /// </summary>
 public override void CheckStatement()
 {
     Types.Collection targetListType = ListExpression.GetExpressionType() as Types.Collection;
     if (targetListType == null)
     {
         Root.AddError("Cannot determine type of " + ListExpression);
     }
     else
     {
         if (Condition != null)
         {
             Condition.checkExpression();
             Types.BoolType conditionType = Condition.GetExpressionType() as Types.BoolType;
             if (conditionType == null)
             {
                 Root.AddError("Condition does not evaluates to boolean");
             }
         }
     }
 }
コード例 #11
0
        /// <summary>
        /// Provides the type of this expression
        /// </summary>
        /// <param name="context">The interpretation context</param>
        /// <returns></returns>
        public override Types.Type GetExpressionType()
        {
            Types.Type retVal = null;

            Types.Type iteratorType = IteratorExpression.GetExpressionType();
            if (iteratorType != null)
            {
                Types.Collection collection = (Types.Collection)Generated.acceptor.getFactory().createCollection();
                collection.Enclosing = EFSSystem;
                collection.Type      = iteratorType;

                retVal = collection;
            }
            else
            {
                AddError("Cannot evaluate iterator type for " + ToString());
            }

            return(retVal);
        }
コード例 #12
0
        /// <summary>
        /// Checks the statement for semantical errors
        /// </summary>
        public override void CheckStatement()
        {
            Value.checkExpression();

            Types.Collection targetListType = ListExpression.GetExpressionType() as Types.Collection;
            if (targetListType != null)
            {
                Types.Type elementType = Value.GetExpressionType();
                if (elementType != targetListType.Type)
                {
                    Root.AddError("Inserted element type does not corresponds to list type");
                }
            }
            else
            {
                Root.AddError("Cannot determine collection type of " + ListExpression);
            }

            if (ReplaceElement != null)
            {
                Types.Type replaceElementType = ReplaceElement.GetExpressionType();
                if (replaceElementType != null)
                {
                    if (targetListType.Type != null)
                    {
                        if (replaceElementType != targetListType.Type)
                        {
                            Root.AddError("The replace element type (" + replaceElementType.FullName + ") does not correspond to the list type (" + targetListType.Type.FullName + ")");
                        }
                    }
                    else
                    {
                        Root.AddError("Cannot determine list element's type for " + targetListType.FullName);
                    }
                }
                else
                {
                    Root.AddError("Cannot determine replacement element type");
                }
            }
        }
コード例 #13
0
        /// <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(Utils.INamable instance)
        {
            bool retVal = base.SemanticAnalysis(instance);

            if (retVal)
            {
                ListExpression.SemanticAnalysis(instance);
                Types.Collection collectionType = ListExpression.GetExpressionType() as Types.Collection;
                if (collectionType != null)
                {
                    IteratorVariable.Type = collectionType.Type;
                }

                if (Condition != null)
                {
                    Condition.SemanticAnalysis(instance);
                }
            }

            return(retVal);
        }
コード例 #14
0
        /// <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)
            {
                Types.Type elementType = null;

                foreach (Expression expr in ListElements)
                {
                    expr.SemanticAnalysis(instance, expectation);
                    Types.Type current = expr.GetExpressionType();
                    if (elementType == null)
                    {
                        elementType = current;
                    }
                    else
                    {
                        if (current != elementType)
                        {
                            AddError("Cannot mix types " + current.ToString() + " and " + elementType.ToString() + "in collection");
                        }
                    }
                }

                if (elementType != null)
                {
                    ExpressionType           = (Types.Collection)Generated.acceptor.getFactory().createCollection();
                    ExpressionType.Type      = elementType;
                    ExpressionType.Name      = "ListOf_" + elementType.FullName;
                    ExpressionType.Enclosing = Root.EFSSystem;
                }
                else
                {
                    ExpressionType = new Types.GenericCollection(EFSSystem);
                }
            }

            return(retVal);
        }
コード例 #15
0
        /// <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)
            {
                ListExpression.SemanticAnalysis(instance, Filter.IsRightSide);

                Types.Collection collectionType = ListExpression.GetExpressionType() as Types.Collection;
                if (collectionType != null)
                {
                    IteratorVariable.Type         = collectionType.Type;
                    PreviousIteratorVariable.Type = collectionType.Type;
                }
                else
                {
                    AddError("Cannot determine collection type on list expression " + ToString());
                }
            }

            return(retVal);
        }
コード例 #16
0
        /// <summary>
        /// Provides the value of the function
        /// </summary>
        /// <param name="instance">the instance on which the function is evaluated</param>
        /// <param name="actuals">the actual parameters values</param>
        /// <param name="localScope">the values of local variables</param>
        /// <returns>The value for the function application</returns>
        public override Values.IValue Evaluate(Interpreter.InterpretationContext context, Dictionary <Variables.Actual, Values.IValue> actuals)
        {
            Values.IValue retVal = null;

            int token = context.LocalScope.PushContext();

            AssignParameters(context, actuals);

            Values.ListValue value = context.findOnStack(Collection) as Values.ListValue;
            if (value != null)
            {
                Types.Collection collectionType = value.Type as Types.Collection;
                if (collectionType != null && collectionType.Type != null)
                {
                    Types.Type elementType = collectionType.Type;

                    int i = 0;
                    while (i < value.Val.Count && value.Val[i] != EFSSystem.EmptyValue)
                    {
                        i += 1;
                    }

                    if (i < value.Val.Count)
                    {
                        retVal       = elementType.DefaultValue;
                        value.Val[i] = retVal;
                    }
                    else
                    {
                        AddError("Cannot allocate element in list : list full");
                    }
                }
            }
            context.LocalScope.PopContext(token);

            return(retVal);
        }
コード例 #17
0
        /// <summary>
        /// Fills the given structure with the values provided from the database
        /// </summary>
        /// <param name="aNameSpace">Namespace of the structure</param>
        /// <param name="fields">Fields to be copied into the structure</param>
        /// <param name="index">Index (of fields list) from which we have to start copying</param>
        /// <param name="aStructure">The structure to be filled</param>
        private void FillStructure(Types.NameSpace aNameSpace, ArrayList fields, ref int index, Values.StructureValue aStructure)
        {
            int j = 0;

            for (int i = index; i < fields.Count; i++)
            {
                Tests.DBElements.DBField field = fields[i] as Tests.DBElements.DBField;

                KeyValuePair <string, Variables.IVariable> pair = aStructure.SubVariables.ElementAt(j);
                Variables.IVariable variable = pair.Value;

                if (variable.Name.StartsWith(field.Variable))  // we use StartsWith and not Equals because we can have N_ITER_1 and N_ITER
                {
                    if (variable.Type is Types.Enum)
                    {
                        Types.Enum type = variable.Type as Types.Enum;
                        foreach (DataDictionary.Constants.EnumValue enumValue in type.Values)
                        {
                            int value = Int32.Parse(enumValue.getValue());
                            if (value == field.Value)
                            {
                                variable.Value = enumValue;
                                j++;
                                break;
                            }
                        }
                    }
                    else if (variable.Type is Types.Range)
                    {
                        Types.Range type = variable.Type as Types.Range;
                        variable.Value = new Values.IntValue(type, (decimal)field.Value);
                        j++;
                    }
                    else
                    {
                        throw new Exception("Unhandled variable type");
                    }
                    if (field.Variable.Equals("N_ITER")) // we have to create a sequence
                    {
                        KeyValuePair <string, Variables.IVariable> sequencePair = aStructure.SubVariables.ElementAt(j);
                        Variables.IVariable sequenceVariable = sequencePair.Value;
                        Types.Collection    collectionType   = (Types.Collection)EFSSystem.findType(aNameSpace, sequenceVariable.TypeName);
                        Values.ListValue    sequence         = new Values.ListValue(collectionType, new List <Values.IValue>());

                        for (int k = 0; k < field.Value; k++)
                        {
                            Types.Structure       structureType  = (Types.Structure)EFSSystem.findType(aNameSpace, sequence.CollectionType.Type.FullName);
                            Values.StructureValue structureValue = new Values.StructureValue(structureType, structureType.NameSpace);
                            FillStructure(aNameSpace, fields, ref index, structureValue);
                            sequence.Val.Add(structureValue);
                        }
                        sequenceVariable.Value = sequence;
                        j++;
                    }
                }

                // if all the fields of the structue are filled, we terminated
                if (j == aStructure.SubVariables.Count)
                {
                    index = i;
                    break;
                }
            }
        }
コード例 #18
0
        private string format_eurobalise_message(DBElements.DBMessage message)
        {
            DataDictionary.Types.NameSpace nameSpace = OverallNameSpaceFinder.INSTANCE.findByName(EFSSystem.Dictionaries[0], "Messages");
            Types.Structure       structureType      = (Types.Structure)EFSSystem.findType(nameSpace, "Messages.EUROBALISE.Message");
            Values.StructureValue structure          = new Values.StructureValue(structureType, nameSpace);

            int index = 0;

            FillStructure(nameSpace, message.Fields, ref index, structure); // fills the message fields


            // then we fill the packets
            KeyValuePair <string, Variables.IVariable> subSequencePair = structure.SubVariables.ElementAt(structure.SubVariables.Count - 1);

            Variables.IVariable subSequenceVariable = subSequencePair.Value;

            Types.Collection collectionType = (Types.Collection)EFSSystem.findType(nameSpace, "Messages.EUROBALISE.Collection1");
            Values.ListValue collection     = new Values.ListValue(collectionType, new List <Values.IValue>());

            Types.Structure       subStructure1Type = (Types.Structure)EFSSystem.findType(nameSpace, "Messages.EUROBALISE.SubStructure1");
            Values.StructureValue subStructure1     = new Values.StructureValue(subStructure1Type, nameSpace);

            Types.Structure       packetStructure = (Types.Structure)EFSSystem.findType(nameSpace, "Messages.PACKET.TRACK_TO_TRAIN.Message");
            Values.StructureValue packetValue     = new Values.StructureValue(packetStructure, nameSpace);

            // will contain the list of all packets of the message and then be added to the structure packetValue
            ArrayList subStructures = new ArrayList();

            foreach (DBElements.DBPacket packet in message.Packets)
            {
                Tests.DBElements.DBField nidPacketField = packet.Fields[0] as Tests.DBElements.DBField;

                if (nidPacketField.Value != 255)  // 255 means "end of information"
                {
                    Values.StructureValue subStructure = FindStructure(nidPacketField.Value);

                    index = 0;
                    FillStructure(nameSpace, packet.Fields, ref index, subStructure);

                    subStructures.Add(subStructure);
                }
            }

            // the collection of the message packets is copied to the structure packetValue
            int i = 0;

            foreach (KeyValuePair <string, Variables.IVariable> pair in packetValue.SubVariables)
            {
                if (i == subStructures.Count)
                {
                    break;
                }
                string variableName = pair.Key;
                Values.StructureValue structureValue = subStructures[i] as Values.StructureValue;
                if (structureValue.Structure.FullName.Contains(variableName))
                {
                    Variables.IVariable variable = pair.Value;
                    variable.Value = structureValue;
                    i++;
                }
            }

            subStructure1.SubVariables.ElementAt(0).Value.Value = packetValue;
            collection.Val.Add(subStructure1);
            subSequenceVariable.Value = collection;

            return(structure.Name);
        }
コード例 #19
0
        /// <summary>
        /// Provides the type of this expression
        /// </summary>
        /// <returns></returns>
        public override Types.Type GetExpressionType()
        {
            Types.Type retVal = null;

            Types.Type leftType = Left.GetExpressionType();
            if (leftType == null)
            {
                AddError("Cannot determine expression type (1) for " + Left.ToString());
            }
            else
            {
                Types.Type rightType = Right.GetExpressionType();
                if (rightType == null)
                {
                    AddError("Cannot determine expression type (2) for " + Right.ToString());
                }
                else
                {
                    switch (Operation)
                    {
                    case OPERATOR.EXP:
                    case OPERATOR.MULT:
                    case OPERATOR.DIV:
                    case OPERATOR.ADD:
                    case OPERATOR.SUB:
                        if (leftType.Match(rightType))
                        {
                            if (leftType is Types.IntegerType || leftType is Types.DoubleType)
                            {
                                retVal = rightType;
                            }
                            else
                            {
                                retVal = leftType;
                            }
                        }
                        else
                        {
                            retVal = leftType.CombineType(rightType, Operation);
                        }

                        break;

                    case OPERATOR.AND:
                    case OPERATOR.OR:
                        if (leftType == EFSSystem.BoolType && rightType == EFSSystem.BoolType)
                        {
                            retVal = EFSSystem.BoolType;
                        }
                        break;

                    case OPERATOR.EQUAL:
                    case OPERATOR.NOT_EQUAL:
                    case OPERATOR.LESS:
                    case OPERATOR.LESS_OR_EQUAL:
                    case OPERATOR.GREATER:
                    case OPERATOR.GREATER_OR_EQUAL:
                        if (leftType.Match(rightType) || rightType.Match(leftType))
                        {
                            retVal = EFSSystem.BoolType;
                        }
                        break;

                    case OPERATOR.IN:
                    case OPERATOR.NOT_IN:
                        Types.Collection collection = rightType as Types.Collection;
                        if (collection != null)
                        {
                            if (collection.Type == null)
                            {
                                retVal = EFSSystem.BoolType;
                            }
                            else if (collection.Type == leftType)
                            {
                                retVal = EFSSystem.BoolType;
                            }
                        }
                        else
                        {
                            Types.StateMachine stateMachine = rightType as Types.StateMachine;
                            if (stateMachine != null && leftType.Match(stateMachine))
                            {
                                retVal = EFSSystem.BoolType;
                            }
                        }
                        break;

                    case OPERATOR.UNDEF:
                        break;
                    }
                }
            }

            return(retVal);
        }
コード例 #20
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="type"></param>
 public ListValue(Types.Collection type, List <IValue> val)
     : base(type, val)
 {
 }
コード例 #21
0
        /// <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)
            {
                Types.Type elementType = null;

                foreach (Expression expr in ListElements)
                {
                    expr.SemanticAnalysis(instance, expectation);
                    Types.Type current = expr.GetExpressionType();
                    if (elementType == null)
                    {
                        elementType = current;
                    }
                    else
                    {
                        if (current != elementType)
                        {
                            AddError("Cannot mix types " + current.ToString() + " and " + elementType.ToString() + "in collection");
                        }
                    }
                }

                if (elementType != null)
                {
                    ExpressionType = (Types.Collection)Generated.acceptor.getFactory().createCollection();
                    ExpressionType.Type = elementType;
                    ExpressionType.Name = "ListOf_" + elementType.FullName;
                    ExpressionType.Enclosing = Root.EFSSystem;
                }
                else
                {
                    ExpressionType = new Types.GenericCollection(EFSSystem);
                }
            }

            return retVal;
        }