/// <summary> /// Sets the value associated to the explanation /// </summary> /// <param name="explain"></param> /// <param name="namable"></param> public static void SetNamable(ExplanationPart explain, INamable namable) { if (explain != null) { explain.RightPart = namable; } }
public static string GetUniqueName <T>(this INamable namable, string newName, string oldName, IList <T> array) where T : INamable { int suffix = 0; bool uniqueName = false; string currentName = ""; while (!uniqueName) { uniqueName = true; currentName = newName; if (suffix > 0) { currentName += suffix.ToString(); } foreach (INamable element in array) { if (element != namable && element.Name == currentName && element.Name != oldName) { uniqueName = false; break; } } suffix += 1; } return(currentName); }
/// <summary> /// Constructor /// </summary> /// <param name="element">The element for which this explanation part is created</param> /// <param name="message">The message to display. MAKE SURE you do not use string concatenation to create this message</param> /// <param name="rightPart">The value associated to the message, if any</param> public ExplanationPart(ModelElement element, string message, INamable rightPart = null) { Element = element; Message = message; RightPart = rightPart; SubExplanations = new List <ExplanationPart>(); }
/// <summary> /// Constructor /// </summary> /// <param name="element">The element for which this explanation part is created</param> /// <param name="leftPart">The left path to associate to this explanation</param> /// <param name="rightPart">The value associate to this left part</param> public ExplanationPart(ModelElement element, object leftPart, INamable rightPart = null) { Element = element; LeftPart = leftPart; RightPart = rightPart; SubExplanations = new List <ExplanationPart>(); }
public static string GetUniqueName(this INamable namable, IList <INamable> array, string newName, string oldName) { int suffix = 0; bool uniqueName = false; string currentName = ""; while (!uniqueName) { uniqueName = true; currentName = newName; if (suffix > 0) { currentName += suffix.ToString(); } for (int i = 0; i < array.Count; i++) { INamable element = array[i]; if (element != namable && element.Name == currentName && element.Name != oldName) { uniqueName = false; break; } } suffix += 1; } return(currentName); }
/// <summary> /// Provides the value of the prefix of the expression /// </summary> /// <param name="context">The context on which the value must be found</param> /// <param name="elementCount">The number of elements to consider</param> /// <param name="explain"></param> /// <returns></returns> public INamable GetPrefixValue(InterpretationContext context, int elementCount, ExplanationPart explain) { INamable retVal = null; InterpretationContext ctxt = new InterpretationContext(context); for (int i = 0; i < elementCount; i++) { if (retVal != null) { ctxt.Instance = retVal; } retVal = Arguments[i].GetValue(ctxt, explain); if (retVal == null) { retVal = Arguments[i].Ref; } if (retVal == EfsSystem.Instance.EmptyValue) { break; } } if (retVal == null) { AddError(ToString() + " prefix does not refer to a value", RuleChecksEnum.ExecutionFailed); } return(retVal); }
/// <summary> /// Indicates whether this expression references an instance /// </summary> /// <returns></returns> public override bool IsInstance() { bool retVal = true; int count = Arguments.Count; for (int i = count - 1; i >= 0; i--) { INamable aNamable = Arguments[i].Ref; if (aNamable is Variable || aNamable is Function || aNamable is Types.Enum || aNamable is Constants.EnumValue || aNamable is Constants.State) { break; } if ((aNamable is NameSpace) || (aNamable is Structure)) { retVal = Arguments[i].IsInstance(); break; } } return(retVal); }
/// <summary> /// Constructor /// </summary> /// <param name="id"></param> /// <param name="instance"></param> /// <param name="priority"></param> public ModelEvent(string id, INamable instance, acceptor.RulePriority?priority) { Id = id; Message = id; Instance = instance; Priority = priority; }
/// <summary> /// Provides the textual representation of the namable provided /// </summary> /// <param name="namable"></param> /// <returns></returns> public String explainNamable(INamable namable) { String retVal = ""; if (namable != null) { retVal = namable.Name; Function fonction = namable as Function; if (fonction != null) { if (fonction.Graph != null) { retVal = fonction.Graph.ToString(); } else if (fonction.Surface != null) { retVal = fonction.Surface.ToString(); } } else { Values.IValue value = namable as Values.IValue; if (value != null) { retVal = value.LiteralName; } } } return(retVal); }
/// <summary> /// Indicates whether the declarator contains the value provided as parameter /// </summary> /// <param name="subDeclarator"></param> /// <param name="value"></param> /// <returns></returns> public static bool ContainsValue(ISubDeclarator subDeclarator, INamable value) { bool retVal = false; if (subDeclarator != null) { CriticalSection.WaitOne(); try { List <INamable> tmp; if (subDeclarator.DeclaredElements.TryGetValue(value.Name, out tmp)) { foreach (INamable namable in tmp) { if (namable == value) { retVal = true; break; } } } } finally { CriticalSection.ReleaseMutex(); } } return(retVal); }
/// <summary> /// Constructor /// </summary> /// <param name="element">The element for which this explanation part is created</param> /// <param name="leftPart">The left path to associate to this explanation</param> /// <param name="rightPart">The value associate to this left part</param> public ExplanationPart(ModelElement element, object leftPart, INamable rightPart = null) { Element = element; LeftPart = leftPart; RightPart = rightPart; SubExplanations = new List<ExplanationPart>(); }
/// <summary> /// Gets the reference of the designator if it covers the position given /// </summary> /// <param name="designator"></param> protected override void VisitDesignator(Designator designator) { if (ShouldCheck(designator)) { Type type = designator.Ref as Type; if (Context == null && type != null) { Context = type; } ITypedElement element = designator.Ref as ITypedElement; if (Context == null && element != null) { Context = element; } ICallable callable = designator.Ref as ICallable; if (Context == null && callable != null) { Context = callable; } NameSpace nameSpace = designator.Ref as NameSpace; if (Context == null && nameSpace != null) { Context = nameSpace; } } }
/// <summary> /// Adds a reference which satisfies the provided expectation in the result set /// </summary> /// <param name="namable"></param> /// <param name="expectation"></param> /// <param name="asType">Indicates that we had to move from instance to type to perform the deferencing</param> /// <param name="resultSet"></param> private int addReference(INamable namable, BaseFilter expectation, bool asType, ReturnValue resultSet) { int retVal = 0; if (namable != null) { if (expectation.AcceptableChoice(namable)) { if (asType) { if (!(namable is IValue) && !(namable is Type)) { resultSet.Add(namable); retVal += 1; } else if (namable is State) { // TODO : Refactor model to avoid this resultSet.Add(namable); retVal += 1; } } else { resultSet.Add(namable); retVal += 1; } } } return(retVal); }
/// <summary> /// Provides the value associated to this Expression /// </summary> /// <param name="context">The context on which the value must be found</param> /// <returns></returns> public override Values.IValue GetValue(InterpretationContext context) { INamable retVal = Ref as Values.IValue; if (retVal == null) { InterpretationContext ctxt = new InterpretationContext(context); for (int i = 0; i < Arguments.Count; i++) { if (retVal != null) { ctxt.Instance = retVal; } retVal = Arguments[i].GetValue(ctxt); if (retVal == EFSSystem.EmptyValue) { break; } } } if (retVal == null) { AddError(ToString() + " does not refer to a value"); } return(retVal as Values.IValue); }
/// <summary> /// Provides the variable designated by this designator according to the interpretation context /// </summary> /// <param name="context"></param> /// <returns></returns> public IVariable GetVariable(InterpretationContext context) { INamable reference = GetReference(context); IVariable retVal = reference as IVariable; return(retVal); }
/// <summary> /// Constructor /// </summary> /// <param name="id"></param> /// <param name="instance"></param> /// <param name="priority"></param> public ModelEvent(string id, INamable instance, acceptor.RulePriority? priority) { Id = id; Message = id; Instance = instance; Priority = priority; }
/// <summary> /// Allows to refresh the view, when the selected model changed /// </summary> /// <param name="context"></param> /// <returns>true if refresh should be performed</returns> public override bool HandleSelectionChange(Context.SelectionContext context) { bool retVal = base.HandleSelectionChange(context); if (retVal) { INamable namable = DisplayedModel; if (namable != null) { Text = namable.Name + " history"; } else { Text = "History"; } historyTreeView.Root = DisplayedModel; if (historyTreeView.Nodes.Count > 0) { historyTreeView.SelectedNode = historyTreeView.Nodes[0] as ChangeTreeNode; } else { historyTreeView.SelectedNode = null; Properties.SelectedObject = null; } } return(retVal); }
/// <summary> /// Constructor /// </summary> /// <param name="instance">The instance on which interpretation should be performed</param> public InterpretationContext(INamable instance) { LocalScope = new SymbolTable(); Instance = instance; UseDefaultValue = true; HasSideEffects = false; }
/// <summary> /// Constructor /// </summary> /// <param name="other">Copies the other interpretation context contents</param> /// <param name="instance">The evaluation instance</param> public InterpretationContext(InterpretationContext other, INamable instance) { LocalScope = other.LocalScope; Instance = instance; UseDefaultValue = true; HasSideEffects = other.HasSideEffects; }
/// <summary> /// Provides the instance related to a character index in the textbox /// </summary> /// <param name="index"></param> /// <returns></returns> protected INamable GetInstance(int index) { INamable retVal = null; if (Model != null) { InterpreterTreeNode node = Parse(EditionTextBox.Text); if (node != null) { ContextGrabber grabber = new ContextGrabber(); retVal = grabber.GetContext(index, node); } if (retVal == null) { // Perform a fuzzy search by trying to find the corresponding expression text string text = GetExpressionText(EditionTextBox.Text, index); node = Parse(text); index = text.Length - 1; if (node != null) { ContextGrabber grabber = new ContextGrabber(); retVal = grabber.GetContext(index, node); } } } return(retVal); }
/// <summary> /// Provides the value of the prefix of the expression /// </summary> /// <param name="context">The context on which the value must be found</param> /// <param name="elementCount">The number of elements to consider</param> /// <returns></returns> public INamable GetPrefixValue(InterpretationContext context, int elementCount) { INamable retVal = null; InterpretationContext ctxt = new InterpretationContext(context); for (int i = 0; i < elementCount; i++) { if (retVal != null) { ctxt.Instance = retVal; } retVal = Arguments[i].GetValue(ctxt); if (retVal == null) { retVal = Arguments[i].Ref; } if (retVal == EFSSystem.EmptyValue) { break; } } if (retVal == null) { AddError(ToString() + " prefix does not refer to a value"); } 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) { // 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> /// Constructor /// </summary> /// <param name="element">The element for which this explanation part is created</param> /// <param name="message">The message to display. MAKE SURE you do not use string concatenation to create this message</param> /// <param name="rightPart">The value associated to the message, if any</param> public ExplanationPart(ModelElement element, string message, INamable rightPart = null) { Element = element; Message = message; RightPart = rightPart; SubExplanations = new List<ExplanationPart>(); }
/// <summary> /// Gets the context (type or namespace) for a given position /// </summary> /// <param name="position">The position in the source text</param> /// <param name="node">The base node on which the search should be performed</param> /// <returns></returns> public INamable GetContext(int position, InterpreterTreeNode node) { Position = position; Context = null; visitInterpreterTreeNode(node); return(Context); }
public Variables.IVariable GetVariable(InterpretationContext context) { Variables.IVariable retVal = null; INamable reference = getReference(context); retVal = reference as Variables.IVariable; return(retVal); }
/// <summary> /// Adds a reference which satisfies the provided expectation in the result set /// </summary> /// <param name="namable"></param> /// <param name="expectation"></param> /// <param name="resultSet"></param> private void addReference(INamable namable, Filter.AcceptableChoice expectation, ReturnValue resultSet) { if (namable != null) { if (expectation(namable)) { resultSet.Add(namable); } } }
public static string GetUniqueName <T>(this INamable namable, string newName, string oldName, string emptyName, IList <T> array) where T : INamable { string name = namable.GetUniqueName(newName, oldName, array); if (string.IsNullOrEmpty(newName)) { name = namable.GetUniqueName(emptyName, oldName, array); } return(name); }
private void EditionTextBox_MouseHover(object sender, EventArgs e) { Point location = MouseLocation; INamable instance = GetInstance(location); location.Offset(10, 10); const bool considerMouseMove = true; ExplainAndShow(instance, location, considerMouseMove); }
/// <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> /// Explains a list of namables and shows the associated textbox /// </summary> /// <param name="namable">The namable to explain</param> /// <param name="location"> /// The location where the explain box should be displayed. If empty is displayed, the location is /// computed based on the combo box location /// </param> /// <param name="sensibleToMouseMove">Indicates that the explain box should be closed when the mouse moves</param> private void ExplainAndShow(INamable namable, Point location, bool sensibleToMouseMove) { explainRichTextBox.Text = ""; if (namable != null) { TextualExplanation explanation = new TextualExplanation(); ITextualExplain textualExplain = namable as ITextualExplain; if (textualExplain != null) { textualExplain.GetExplain(explanation, false); } explainRichTextBox.Text = explanation.Text; explainRichTextBox.ProcessAllLines(); if (location == Point.Empty) { if (SelectionComboBox.DroppedDown) { explainRichTextBox.Location = new Point( SelectionComboBox.Location.X + SelectionComboBox.Size.Width, SelectionComboBox.Location.Y + SelectionComboBox.Size.Height ); } else { explainRichTextBox.Location = new Point( SelectionComboBox.Location.X, SelectionComboBox.Location.Y + SelectionComboBox.Size.Height ); } } else { explainRichTextBox.Location = new Point( Math.Min(location.X, EditionTextBox.Size.Width - explainRichTextBox.Size.Width), Math.Min(location.Y, EditionTextBox.Size.Height - explainRichTextBox.Size.Height)); } ConsiderMouseMoveToCloseExplanation = sensibleToMouseMove; explainRichTextBox.Size = new Size(400, 200); if (explainRichTextBox.Size.Width >= Size.Width * 0.8) { explainRichTextBox.Size = new Size((int)(Size.Width * 0.8), explainRichTextBox.Size.Height); } if (explainRichTextBox.Size.Height >= Size.Height * 0.8) { explainRichTextBox.Size = new Size(explainRichTextBox.Size.Width, (int)(Size.Height * 0.8)); } explainRichTextBox.Show(); EditionTextBox.SendToBack(); } }
/// <summary> /// Predicate which indicates whether the namable provided matches the expectation for the semantic analysis /// </summary> /// <param name="value"></param> /// <returns></returns> public override bool AcceptableChoice(INamable value) { bool retVal = base.AcceptableChoice(value); if (!retVal) { return value is Parameter; } return retVal; }
public static string GetUniqueName(this INamable namable, IList <INamable> array, string newName, string oldName, string emptyName) { string name = namable.GetUniqueName(array, newName, oldName); if (string.IsNullOrEmpty(newName)) { name = namable.GetUniqueName(array, emptyName, oldName); } return(name); }
/// <summary> /// Predicate which indicates whether the namable provided matches the expectation for the semantic analysis /// </summary> /// <param name="value"></param> /// <returns></returns> public override bool AcceptableChoice(INamable value) { bool retVal = base.AcceptableChoice(value); if (!retVal) { retVal = IsCallable.Predicate(value); } return(retVal); }
/// <summary> /// Predicate which indicates whether the namable provided matches the expectation for the semantic analysis /// </summary> /// <param name="value"></param> /// <returns></returns> public override bool AcceptableChoice(INamable value) { bool retVal = base.AcceptableChoice(value); if (!retVal) { retVal = IsCallable.Predicate(value); } 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(INamable instance, BaseFilter expectation) { bool retVal = base.SemanticAnalysis(instance, expectation); if (retVal) { // Iterator expression IteratorExpression.SemanticAnalysis(instance, AllMatches.INSTANCE); StaticUsage.AddUsages(IteratorExpression.StaticUsage, Usage.ModeEnum.Read); } return retVal; }
public Rename( INamable Target, string Title, bool ReadOnly ) : this() { NamingTarget = Target; NewName.Text = Target.Name; NewName.IsReadOnly = ReadOnly; NewName.SelectAll(); if ( !string.IsNullOrEmpty( Title ) ) { TitleBlock.Text = Title; } }
/// <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); } } } } 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) { // Accumulator if (AccumulatorVariable != null) { AccumulatorVariable.Type = GetExpressionType(); } if (DefinedAccumulator != null) { DefinedAccumulator.SemanticAnalysis(instance, AllMatches.INSTANCE); } if (Accumulator != null) { Accumulator.SemanticAnalysis(instance, AllMatches.INSTANCE); StaticUsage.AddUsages(Accumulator.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 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"); } // Condition if (Condition != null) { Condition.SemanticAnalysis(instance); StaticUsage.AddUsages(Condition.StaticUsage, Usage.ModeEnum.Read); } } return retVal; }
/// <summary> /// Provides the enclosing sub declarator /// </summary> /// <param name="instance"></param> /// <returns></returns> private INamable EnclosingSubDeclarator(INamable instance) { INamable retVal = instance; do { retVal = enclosing(retVal); } while (retVal != null && !(retVal is ISubDeclarator)); return retVal; }
/// <summary> /// Adds a reference which satisfies the provided expectation in the result set /// </summary> /// <param name="namable"></param> /// <param name="expectation"></param> /// <param name="asType">Indicates that we had to move from instance to type to perform the deferencing</param> /// <param name="resultSet"></param> private int addReference(INamable namable, BaseFilter expectation, bool asType, ReturnValue resultSet) { int retVal = 0; if (namable != null) { if (expectation.AcceptableChoice(namable)) { if (asType) { if (!(namable is IValue) && !(namable is Type)) { resultSet.Add(namable); retVal += 1; } else if (namable is State) { // TODO : Refactor model to avoid this resultSet.Add(namable); retVal += 1; } } else { resultSet.Add(namable); retVal += 1; } } } return retVal; }
/// <summary> /// Provides the possible references for this designator (only available during semantic analysis) /// </summary> /// <param name="instance">the instance on which this element should be found.</param> /// <param name="expectation">the expectation on the element found</param> /// <param name="lastElement">Indicates that this element is the last one in a dereference chain</param> /// <returns></returns> public ReturnValue GetReferences(INamable instance, BaseFilter expectation, bool lastElement) { ReturnValue retVal = new ReturnValue(this); if (instance == null) { // Special handling for THIS or ENCLOSING if (Image == ThisKeyword || Image == EnclosingKeyword) { INamable currentElem = Root; while (currentElem != null) { Type type = currentElem as Type; if (type != null) { StateMachine stateMachine = type as StateMachine; while (stateMachine != null) { type = stateMachine; stateMachine = stateMachine.EnclosingStateMachine; } // Enclosing does not references state machines. if (!(Image == EnclosingKeyword && type is StateMachine)) { retVal.Add(type); return retVal; } } currentElem = enclosing(currentElem); } return retVal; } // No enclosing instance. Try to first name of a . separated list of names // . First in the enclosing expression InterpreterTreeNode current = this; while (current != null) { ISubDeclarator subDeclarator = current as ISubDeclarator; if (FillBySubdeclarator(subDeclarator, expectation, false, retVal) > 0) { // If this is the last element in the dereference chain, stop at first match if (lastElement) { return retVal; } current = null; } else { current = current.Enclosing; } } // . In the predefined elements addReference(EfsSystem.Instance.GetPredefinedItem(Image), expectation, false, retVal); if (lastElement && !retVal.IsEmpty) { return retVal; } // . In the enclosing items, except the enclosing dictionary since dictionaries are handled in a later step INamable currentNamable = Root; while (currentNamable != null) { ISubDeclarator subDeclarator = currentNamable as ISubDeclarator; if (subDeclarator != null && !(subDeclarator is Dictionary)) { if (FillBySubdeclarator(subDeclarator, expectation, false, retVal) > 0 && lastElement) { return retVal; } } currentNamable = EnclosingSubDeclarator(currentNamable); } // . In the dictionaries declared in the system foreach (Dictionary dictionary in EfsSystem.Instance.Dictionaries) { if (FillBySubdeclarator(dictionary, expectation, false, retVal) > 0 && lastElement) { return retVal; } NameSpace defaultNameSpace = dictionary.FindNameSpace("Default"); if (defaultNameSpace != null) { if (FillBySubdeclarator(defaultNameSpace, expectation, false, retVal) > 0 && lastElement) { return retVal; } } } } else { // The instance is provided, hence, this is not the first designator in the . separated list of designators bool asType = false; if (instance is ITypedElement && !(instance is State)) { // If the instance is a typed element, dereference it to its corresponding type ITypedElement element = instance as ITypedElement; if (element.Type != EfsSystem.Instance.NoType) { instance = element.Type; asType = true; } } // Find the element in all enclosing sub declarators of the instance while (instance != null) { ISubDeclarator subDeclarator = instance as ISubDeclarator; if (FillBySubdeclarator(subDeclarator, expectation, asType, retVal) > 0) { instance = null; } else { if (instance is Dictionary) { instance = EnclosingSubDeclarator(instance); } else { instance = null; } } } } return retVal; }
/// <summary> /// Predicate, so that the code can be reused /// </summary> /// <param name="value"></param> /// <returns></returns> public static bool Predicate(INamable value) { return value is IValue || value is Parameter; }
/// <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) { // Accumulator AccumulatorVariable.Type = GetExpressionType(); if (DefinedAccumulator != null) { DefinedAccumulator.SemanticAnalysis(instance, AllMatches.INSTANCE); Accumulator.SemanticAnalysis(instance, AllMatches.INSTANCE); StaticUsage.AddUsages(Accumulator.StaticUsage, Usage.ModeEnum.Read); } else { AddError("Accumulator 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 (Term != null) { Term.SemanticAnalysis(instance, expectation, true); StaticUsage = Term.StaticUsage; } else if (Expression != null) { Expression.SemanticAnalysis(instance, expectation); StaticUsage = Expression.StaticUsage; } } return retVal; }
/// <summary> /// Provides the possible references types for this expression (used in semantic analysis) /// </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> /// <param name="last">indicates that this is the last element in a dereference chain</param> /// <returns></returns> public override ReturnValue GetReferenceTypes(INamable instance, BaseFilter expectation, bool last) { ReturnValue retVal = ReturnValue.Empty; if (Term != null) { retVal = Term.GetReferenceTypes(instance, expectation, last); } else { if (Expression != null) { retVal = Expression.GetReferenceTypes(instance, expectation, true); } } return retVal; }
/// <summary> /// Predicate, so that the code can be reused /// </summary> /// <param name="value"></param> /// <returns></returns> public static bool Predicate(INamable value) { return value is Type; }
/// <summary> /// Predicate which indicates whether the namable provided matches the expectation for the semantic analysis /// </summary> /// <param name="value"></param> /// <returns></returns> public override bool AcceptableChoice(INamable value) { return Predicate(value); }
/// <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 Value.SemanticAnalysis(instance); StaticUsage.AddUsages(Value.StaticUsage, Usage.ModeEnum.Read); // ListExpression ListExpression.SemanticAnalysis(instance, IsLeftSide.INSTANCE); StaticUsage.AddUsages(ListExpression.StaticUsage, Usage.ModeEnum.ReadAndWrite); // ReplaceElement if (ReplaceElement != null) { ReplaceElement.SemanticAnalysis(instance); StaticUsage.AddUsages(ReplaceElement.StaticUsage, Usage.ModeEnum.Read); } } return retVal; }
/// <summary> /// Performs the semantic analysis of the term /// </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> /// <param name="lastElement">Indicates that this element is the last one in a dereference chain</param> /// <returns>True if semantic analysis should be continued</returns> public void SemanticAnalysis(INamable instance, BaseFilter expectation, bool lastElement) { ReturnValue tmp = GetReferences(instance, expectation, lastElement); if (Image != ThisKeyword && Image != EnclosingKeyword) { tmp.Filter(expectation); } if (tmp.IsUnique) { Ref = tmp.Values[0].Value; } if (StaticUsage == null) { StaticUsage = new Usages(); StaticUsage.AddUsage(Ref, Root, null); } }
/// <summary> /// Creates a sub explanation for the explain provided as parameter /// </summary> /// <param name="explain"></param> /// <param name="leftPart"></param> /// <param name="rightPart"></param> /// <returns></returns> public static ExplanationPart CreateSubExplanation(ExplanationPart explain, object leftPart, INamable rightPart = null) { ExplanationPart retVal = null; if (explain != null) { retVal = new ExplanationPart(explain.Element, leftPart, rightPart); explain.SubExplanations.Add(retVal); } return retVal; }
/// <summary> /// Provides the enclosing element /// </summary> /// <param name="retVal"></param> /// <returns></returns> private INamable enclosing(INamable retVal) { IEnclosed enclosed = retVal as IEnclosed; if (enclosed != null) { retVal = enclosed.Enclosing as INamable; } else { retVal = null; } return retVal; }
/// <summary> /// Indicates whether the list of object references contains the provided model element /// </summary> /// <param name="choices"></param> /// <param name="model"></param> /// <returns></returns> private bool Contains(IEnumerable<ObjectReference> choices, INamable model) { bool retVal = false; foreach (ObjectReference objectReference in choices) { if (objectReference.Model == model) { retVal = true; break; } } return retVal; }
/// <summary> /// Provides the possible references for this expression (only available during semantic analysis) /// </summary> /// <param name="instance">the instance on which this element should be found.</param> /// <param name="expectation">the expectation on the element found</param> /// <param name="last">indicates that this is the last element in a dereference chain</param> /// <returns></returns> public override ReturnValue getReferences(INamable instance, BaseFilter expectation, bool last) { ReturnValue retVal = Arguments[0].getReferences(instance, AllMatches.INSTANCE, false); if (retVal.IsEmpty) { retVal = Arguments[0].getReferenceTypes(instance, AllMatches.INSTANCE, false); } // When variables & parameters are found, only consider the first one // which is the one that is closer in the tree { ReturnValue tmp2 = retVal; retVal = new ReturnValue(); ReturnValueElement variable = null; foreach (ReturnValueElement elem in tmp2.Values) { if (elem.Value is Parameter || elem.Value is IVariable) { if (variable == null) { variable = elem; retVal.Values.Add(elem); } } else { retVal.Values.Add(elem); } } } if (!retVal.IsEmpty) { for (int i = 1; i < Arguments.Count; i++) { ReturnValue tmp2 = retVal; retVal = new ReturnValue(Arguments[i]); foreach (ReturnValueElement elem in tmp2.Values) { bool removed = false; ModelElement model = elem.Value as ModelElement; if (model != null) { removed = model.IsRemoved; } if (!removed) { retVal.Merge(elem, Arguments[i].getReferences(elem.Value, AllMatches.INSTANCE, i == (Arguments.Count - 1))); } } if (retVal.IsEmpty) { AddError("Cannot find " + Arguments[i].ToString() + " in " + Arguments[i - 1].ToString()); } } } else { AddError("Cannot evaluate " + Arguments[0].ToString()); } retVal.filter(expectation); return retVal; }
/// <summary> /// Provides the textual representation of the namable provided /// </summary> /// <param name="namable"></param> /// <returns></returns> private string explainNamable(INamable namable) { string retVal = ""; if (namable != null) { retVal = namable.Name; Function fonction = namable as Function; if (fonction != null) { if (fonction.Graph != null) { retVal = fonction.Graph.ToString(); } else if (fonction.Surface != null) { retVal = fonction.Surface.ToString(); } } else { IValue value = namable as IValue; if (value != null) { retVal = value.LiteralName; } } } 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(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.ToString() + ", please disambiguate"); } else { // No possible interpretation for this deref expression, not allowed AddError("Expression " + ToString() + " has no interpretation"); } } 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 semantical analysis should be performed</returns> public virtual bool SemanticAnalysis(INamable instance = null) { bool retVal = !SemanticalAnalysisDone; if (retVal) { StaticUsage = new Usages(); SemanticalAnalysisDone = true; } return retVal; }
/// <summary> /// Predicate, so that the code can be reused /// </summary> /// <param name="value"></param> /// <returns></returns> public static bool Predicate(INamable value) { return (value is IValue); }