public override bool CompareForEquality(Values.IValue left, Values.IValue right) // left == right { bool retVal = base.CompareForEquality(left, right); if (!retVal) { if (left.Type == right.Type) { Values.StructureValue leftValue = left as Values.StructureValue; Values.StructureValue rightValue = right as Values.StructureValue; if (left != null && right != null) { retVal = true; foreach (KeyValuePair <string, Variables.IVariable> pair in leftValue.SubVariables) { Variables.IVariable leftVar = pair.Value; Variables.IVariable rightVar = rightValue.getVariable(pair.Key); if (leftVar.Type != null) { retVal = leftVar.Type.CompareForEquality(leftVar.Value, rightVar.Value); if (!retVal) { break; } } } } } } return(retVal); }
/// <summary> /// Indicates whether the expression is based on a placeholder value, ommiting the parameter provided /// </summary> /// <param name="context">The current interpretation context</param> /// <param name="expression">The expression to evaluate</param> /// <returns></returns> private bool ExpressionBasedOnPlaceHolder(Interpreter.InterpretationContext context, Interpreter.BinaryExpression expression) { bool retVal = false; if (expression != null) { foreach (Types.ITypedElement element in expression.GetRightSides()) { Parameter parameter = element as Parameter; if (parameter != null) { Variables.IVariable variable = context.findOnStack(parameter); if (variable != null) { Values.PlaceHolder placeHolder = variable.Value as Values.PlaceHolder; if (placeHolder != null) { retVal = true; break; } } } } } return(retVal); }
/// <summary> /// Provides the graph of this function if it has been statically defined /// </summary> /// <param name="context">the context used to create the graph</param> /// <returns></returns> public virtual Graph createGraph(Interpreter.InterpretationContext context, Parameter parameter) { Graph retVal = Graph; if (retVal == null) { try { Interpreter.InterpretationContext ctxt = new Interpreter.InterpretationContext(context); if (Cases.Count > 0) { // For now, just create graphs for functions using 0 or 1 parameter. if (FormalParameters.Count == 0) { Values.IValue value = Evaluate(ctxt, new Dictionary <Variables.Actual, Values.IValue>()); retVal = Graph.createGraph(value, parameter); } else if (FormalParameters.Count == 1) { Parameter param = (Parameter)FormalParameters[0]; int token = ctxt.LocalScope.PushContext(); Values.IValue actualValue = null; if (parameter != null) { Variables.IVariable actual = ctxt.findOnStack(parameter); if (actual != null) { actualValue = actual.Value; } else { actualValue = new Values.PlaceHolder(parameter.Type, 1); } ctxt.LocalScope.setParameter(param, actualValue); } retVal = createGraphForParameter(ctxt, param); if (getCacheable() && actualValue is Values.PlaceHolder) { Graph = retVal; } ctxt.LocalScope.PopContext(token); } else { Values.IValue value = Evaluate(ctxt, new Dictionary <Variables.Actual, Values.IValue>()); retVal = Graph.createGraph(value, parameter); } } } catch (Exception e) { AddError("Cannot create graph of function, reason : " + e.Message); } } return(retVal); }
/// <summary> /// Constructor /// </summary> /// <param name="variable"></param> /// <param name="previousValue"></param> /// <param name="newValue"></param> public Change(Variables.IVariable variable, Values.IValue previousValue, Values.IValue newValue) { Variable = variable; PreviousValue = previousValue; NewValue = newValue; Applied = false; }
/// <summary> /// Stores the variable in this symbol table /// </summary> /// <param name="variable"></param> public void setVariable(Variables.IVariable variable) { if (variable == null) { System.Diagnostics.Debugger.Break(); } Values.Add(variable); }
public Variables.IVariable GetVariable(InterpretationContext context) { Variables.IVariable retVal = null; INamable reference = getReference(context); retVal = reference as Variables.IVariable; return(retVal); }
/// <summary> /// Provides the reference for this subdeclarator /// </summary> /// <param name="subDeclarator"></param> /// <returns></returns> private INamable getReferenceBySubDeclarator(ISubDeclarator subDeclarator) { INamable retVal = null; List <INamable> tmp = new List <INamable>(); subDeclarator.Find(Image, tmp); if (tmp.Count > 0) { // Remove duplicates List <INamable> tmp2 = new List <INamable>(); foreach (INamable namable in tmp) { bool found = false; foreach (INamable other in tmp2) { if (namable == other) { found = true; break; } } if (!found) { tmp2.Add(namable); // Consistency check. Variables.IVariable subDeclVar = subDeclarator as Variables.Variable; if (subDeclVar != null) { if (((IEnclosed)namable).Enclosing != subDeclVar.Value) { AddError("Consistency check failed : enclosed element's father relationship is inconsistent"); } } else { if (((IEnclosed)namable).Enclosing != subDeclarator) { AddError("Consistency check failed : enclosed element's father relationship is inconsistent"); } } } } // Provide the result, if it is unique if (tmp2.Count == 1) { retVal = tmp2[0]; } } return(retVal); }
/// <summary> /// Gets the value associated to a name /// </summary> /// <param name="name"></param> /// <returns></returns> public Variables.IVariable getVariable(string name) { Variables.IVariable retVal = null; if (Val.ContainsKey(name)) { retVal = Val[name] as Variables.IVariable; } return(retVal); }
/// <summary> /// Provides the changes performed by this statement /// </summary> /// <param name="context">The context on which the changes should be computed</param> /// <param name="changes">The list to fill with the changes</param> /// <param name="explanation">The explanatino to fill, if any</param> /// <param name="apply">Indicates that the changes should be applied immediately</param> public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation, bool apply) { Variables.IVariable variable = ListExpression.GetVariable(context); if (variable != null) { // HacK : ensure that the value is a correct rigth side // and keep the result of the right side operation Values.ListValue listValue = variable.Value.RightSide(variable, false) as Values.ListValue; variable.Value = listValue; if (listValue != null) { Values.ListValue newListValue = new Values.ListValue(listValue); int i = 0; foreach (Values.IValue current in newListValue.Val) { IteratorVariable.Value = current; if (conditionSatisfied(context)) { break; } i += 1; } if (i < newListValue.Val.Count) { Values.IValue value = Value.GetValue(context); if (value != null) { newListValue.Val[i] = value; Rules.Change change = new Rules.Change(variable, variable.Value, newListValue); changes.Add(change, apply); explanation.SubExplanations.Add(new ExplanationPart(Root, change)); } else { Root.AddError("Cannot find value for " + Value.ToString()); } } else { Root.AddError("Cannot find value in " + ListExpression.ToString() + " which satisfies " + Condition.ToString()); } } else { Root.AddError("Variable " + ListExpression.ToString() + " does not contain a list value"); } } else { Root.AddError("Cannot find variable for " + ListExpression.ToString()); } }
/// <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 virtual Values.IValue RightSide(Variables.IVariable variable, bool duplicate) { State retVal = this; while (retVal.StateMachine.AllValues.Count > 0) { retVal = (Constants.State)retVal.StateMachine.DefaultValue; } return(retVal); }
/// <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) { StructureValue retVal = this; if (duplicate) { retVal = new StructureValue(retVal); } retVal.Enclosing = variable; return(retVal); }
/// <summary> /// Sets the value of a given association /// </summary> /// <param name="name"></param> /// <param name="val"></param> public void set(Variables.IVariable variable) { if (Val.ContainsKey(variable.Name)) { Variables.IVariable var = Val[variable.Name] as Variables.IVariable; if (var != null) { var.Value = variable.Value; } } else { Val.Add(variable.Name, variable); } }
/// <summary> /// Indicates that the change list modifies the variable provided as parameter /// </summary> /// <param name="variable"></param> /// <returns></returns> public bool ImpactVariable(Variables.IVariable variable) { bool retVal = false; foreach (Change change in Changes) { if (change.Variable == variable) { retVal = true; break; } } return(retVal); }
/// <summary> /// Provides the variable referenced by this expression, if any /// </summary> /// <param name="context">The context on which the variable must be found</param> /// <returns></returns> public override Variables.IVariable GetVariable(InterpretationContext context) { Variables.IVariable retVal = null; if (Term != null) { retVal = Term.GetVariable(context); } else { AddError("Cannot get variable from expression" + ToString()); } return(retVal); }
/// <summary> /// Provides the variable referenced by this expression, if any /// </summary> /// <param name="context">The context on which the variable must be found</param> /// <returns></returns> public Variables.IVariable GetVariable(InterpretationContext context) { Variables.IVariable retVal = null; if (Designator != null) { retVal = Designator.GetVariable(context); } else if (LiteralValue != null) { retVal = null; } return(retVal); }
/// <summary> /// Indicates that the rule fired impacts the variable provided as parameter /// </summary> /// <param name="variable"></param> /// <returns></returns> public bool ImpactVariable(Variables.IVariable variable) { bool retVal = false; foreach (VariableUpdate variableUpdate in Updates) { retVal = variableUpdate.Changes.ImpactVariable(variable); if (retVal) { break; } } return(retVal); }
/// <summary> /// Provides the variable assocaited to the name provided /// </summary> /// <param name="name"></param> /// <returns></returns> public Variables.IVariable getVariable(string name) { Variables.IVariable retVal = null; for (int i = Values.Count - 1; i >= 0; i--) { Variables.IVariable element = Values[i]; if (element.Name.CompareTo(name) == 0) { retVal = element; break; } } return(retVal); }
/// <summary> /// Provides the actual variable which corresponds to this parameter on the stack /// </summary> /// <param name="parameter"></param> /// <returns></returns> public Variables.IVariable find(Parameter parameter) { Variables.IVariable retVal = null; for (int i = Values.Count - 1; i >= 0; i--) { Variables.IVariable var = Values[i]; if (parameter.Name.Equals(var.Name)) { retVal = var; break; } } return(retVal); }
/// <summary> /// Provides the set of rules which uses this variable /// </summary> /// <param name="node">the element to find in rules</param> /// <returns>the list of rules which use the element provided</returns> public static HashSet <Rules.RuleCondition> RulesUsingThisElement(Variables.IVariable node) { UsageVisitor visitor = new UsageVisitor(node); EFSSystem efsSystem = Utils.EnclosingFinder <EFSSystem> .find(node); if (efsSystem != null) { foreach (Dictionary dictionary in efsSystem.Dictionaries) { visitor.visit(dictionary); } } return(visitor.Usages); }
public override Graph createGraph(Interpreter.InterpretationContext context, Parameter parameter) { Graph retVal = null; Variables.IVariable variable = context.findOnStack(Value); if (variable != null) { retVal = Graph.createGraph(Functions.Function.getDoubleValue(variable.Value), parameter); } else { AddError("Cannot find variable " + Value + " on the stack"); } return(retVal); }
/// <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); }
/// <summary> /// Provides the variables used by this expression /// </summary> public List <Variables.IVariable> GetVariables() { List <Variables.IVariable> retVal = new List <Variables.IVariable>(); List <Utils.INamable> tmp = new List <Utils.INamable>(); fill(tmp, Filter.IsVariable); foreach (Utils.INamable namable in tmp) { Variables.IVariable variable = namable as Variables.IVariable; if (variable != null) { retVal.Add(variable); } } return(retVal); }
/// <summary> /// Provides the changes performed by this statement /// </summary> /// <param name="context">The context on which the changes should be computed</param> /// <param name="changes">The list to fill with the changes</param> /// <param name="explanation">The explanatino to fill, if any</param> /// <param name="apply">Indicates that the changes should be applied immediately</param> public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation, bool apply) { Variables.IVariable var = VariableIdentification.GetVariable(context); if (var != null) { string tmp = var.FullName; Values.IValue value = Expression.GetValue(context); if (value != null) { value = value.RightSide(var, true); } Rules.Change change = new Rules.Change(var, var.Value, value); changes.Add(change, apply); explanation.SubExplanations.Add(new ExplanationPart(Root, change)); } else { AddError("Cannot find variable " + VariableIdentification.ToString()); } }
/// <summary> /// Gets the unbound parameters from the function definition and place holders /// </summary> /// <param name="context"></param> /// <param name="function"></param> /// <returns></returns> private List <Parameter> getUnboundParameter(InterpretationContext context, Functions.Function function) { List <Parameter> retVal = new List <Parameter>(); if (function != null) { foreach (Parameter formal in function.FormalParameters) { Variables.IVariable actual = context.findOnStack(formal); if (actual != null) { Values.PlaceHolder placeHolder = actual.Value as Values.PlaceHolder; if (placeHolder != null) { retVal.Add(formal); } } } } return(retVal); }
/// <summary> /// Provides the changes performed by this statement /// </summary> /// <param name="context">The context on which the changes should be computed</param> /// <param name="changes">The list to fill with the changes</param> /// <param name="explanation">The explanatino to fill, if any</param> /// <param name="apply">Indicates that the changes should be applied immediately</param> public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation, bool apply) { Variables.IVariable variable = ListExpression.GetVariable(context); if (variable != null) { // HacK : ensure that the value is a correct rigth side // and keep the result of the right side operation Values.ListValue listValue = variable.Value.RightSide(variable, false) as Values.ListValue; variable.Value = listValue; if (listValue != null) { int token = context.LocalScope.PushContext(); context.LocalScope.setVariable(IteratorVariable); foreach (Values.IValue value in listValue.Val) { if (value != EFSSystem.EmptyValue) { IteratorVariable.Value = value; if (conditionSatisfied(context)) { Call.GetChanges(context, changes, explanation, apply); } } } context.LocalScope.PopContext(token); } else { Root.AddError("List expression does not evaluate to a list value"); } } else { Root.AddError("Cannot find variable for " + ListExpression.ToString()); } }
public override void visit(Generated.RuleCondition obj, bool subNodes) { Rules.RuleCondition ruleCondition = obj as Rules.RuleCondition; if (ruleCondition != null) { try { bool found = false; ruleCondition.Messages.Clear(); foreach (Rules.PreCondition preCondition in ruleCondition.PreConditions) { Interpreter.BinaryExpression expression = checkExpression(preCondition, preCondition.Expression) as Interpreter.BinaryExpression; if (expression != null) { if (expression.IsSimpleEquality()) { Types.ITypedElement variable = expression.Left.Ref as Types.ITypedElement; if (variable != null) { if (variable.Type != null) { // Check that when preconditions are based on a request, // the corresponding action affects the value Request.Disabled to the same variable if (variable.Type.Name.Equals("Request") && expression.Right != null && expression.Right is Interpreter.UnaryExpression) { Values.IValue val2 = expression.Right.Ref as Values.IValue; if (val2 != null && "Response".CompareTo(val2.Name) == 0) { if (ruleCondition != null) { found = false; foreach (Rules.Action action in ruleCondition.Actions) { Variables.IVariable var = OverallVariableFinder.INSTANCE.findByName(action, preCondition.findVariable()); Interpreter.Statement.VariableUpdateStatement update = action.Modifies(var); if (update != null) { Interpreter.UnaryExpression updateExpr = update.Expression as Interpreter.UnaryExpression; if (updateExpr != null) { Values.IValue val3 = updateExpr.Ref as Values.IValue; if (val3 != null && val3.Name.CompareTo("Disabled") == 0) { found = true; break; } } } } if (!found) { preCondition.AddError("Rules where the Pre conditions is based on a Request type variable must assign that variable the value 'Request.Disabled'"); } } } } } // Check that the outgoing variables are not read if (variable.Mode == Generated.acceptor.VariableModeEnumType.aOutgoing) { if (ruleCondition.Reads(variable)) { preCondition.AddError("An outgoing variable cannot be read"); } } // Check that the incoming variables are not modified if (variable.Mode == Generated.acceptor.VariableModeEnumType.aIncoming) { if (ruleCondition.Modifies(variable) != null) { preCondition.AddError("An incoming variable cannot be written"); } } } } } } } catch (Exception exception) { ruleCondition.AddException(exception); } } base.visit(obj, subNodes); }
/// <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; } } }
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); }
/// <summary> /// Provides the changes performed by this statement /// </summary> /// <param name="context">The context on which the changes should be computed</param> /// <param name="changes">The list to fill with the changes</param> /// <param name="explanation">The explanatino to fill, if any</param> /// <param name="apply">Indicates that the changes should be applied immediately</param> public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation, bool apply) { Variables.IVariable variable = ListExpression.GetVariable(context); if (variable != null) { // HacK : ensure that the value is a correct rigth side // and keep the result of the right side operation Values.ListValue listValue = variable.Value.RightSide(variable, false) as Values.ListValue; variable.Value = listValue; if (listValue != null) { Values.IValue value = Value.GetValue(context); if (value != null) { Values.ListValue newListValue = new Values.ListValue(listValue); int index = newListValue.Val.IndexOf(EFSSystem.EmptyValue); if (index >= 0) { newListValue.Val[index] = value; } else { // List is full, try to remove an element before inserting the new element if (ReplaceElement != null) { Values.IValue removeValue = ReplaceElement.GetValue(context); index = newListValue.Val.IndexOf(removeValue); if (index >= 0) { newListValue.Val[index] = value; } else { Root.AddError("Cannot remove replacing element " + removeValue.Name); } } else { Root.AddError("Cannot add new element in list value : list is full"); } } Rules.Change change = new Rules.Change(variable, variable.Value, newListValue); changes.Add(change, apply); explanation.SubExplanations.Add(new ExplanationPart(Root, change)); } else { Root.AddError("Cannot find value for " + Value.ToString()); } } else { Root.AddError("Variable " + ListExpression.ToString() + " does not contain a list value"); } } else { Root.AddError("Cannot find variable for " + ListExpression.ToString()); } }
/// <summary> /// Indicates whether this rule uses the typed element /// </summary> /// <param name="variable"></param> /// <returns></returns> public bool Uses(Variables.IVariable variable) { return(Modifies(variable) != null || Reads(variable)); }