/// <summary> /// Finds a symbol in a sub declarator and adds it to retVal /// </summary> /// <param name="subDeclarator"></param> /// <param name="name"></param> /// <param name="retVal"></param> public static void Find(ISubDeclarator subDeclarator, string name, List <INamable> retVal) { if (subDeclarator != null) { CriticalSection.WaitOne(); try { // Ensure that the declared elements are initialized if (subDeclarator.DeclaredElements == null) { subDeclarator.InitDeclaredElements(); } if (name != null) { List <INamable> tmp; if (subDeclarator.DeclaredElements.TryGetValue(name, out tmp)) { retVal.AddRange(tmp); } } } finally { CriticalSection.ReleaseMutex(); } } }
/// <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> /// Provides all the values of type T along with their identification name /// </summary> /// <param name="root">The root element where search must be conducted</param> /// <param name="scope">The namespace where elements are declared</param> /// <param name="retVal">The result values</param> /// <param name="depth">The maximum depth in which the find must go</param> private void innerFindAllValues(object root, string scope, Dictionary <string, T> retVal, int depth) { if (root is ISubDeclarator) { ISubDeclarator subDeclarator = root as ISubDeclarator; if (subDeclarator != null) { if (subDeclarator.DeclaredElements == null) { subDeclarator.InitDeclaredElements(); } foreach (KeyValuePair <string, List <INamable> > element in subDeclarator.DeclaredElements) { string name = Utils.concat(scope, element.Key); List <INamable> values = element.Value; foreach (INamable value in values) { if (!retVal.ContainsKey(name) && value is T) { retVal[name] = value as T; } if (depth < MAX_DEPTH) { innerFindAllValues(value, name, retVal, depth + 1); } } } } } }
/// <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> /// Appends a namable in a dictionary /// </summary> /// <param name="subDeclarator"></param> /// <param name="name"></param> /// <param name="namable"></param> public static void AppendNamable(ISubDeclarator subDeclarator, string name, INamable namable) { if (namable != null) { if (!subDeclarator.DeclaredElements.ContainsKey(name)) { subDeclarator.DeclaredElements[name] = new List <INamable>(); } subDeclarator.DeclaredElements[name].Add(namable); } }
/// <summary> /// Provides the enclosing sub declarator /// </summary> /// <param name="modelElement"></param> /// <returns></returns> private static ISubDeclarator EnclosingSubDeclarator(IModelElement modelElement) { ISubDeclarator retVal = null; while (modelElement != null && retVal == null) { retVal = modelElement as ISubDeclarator; modelElement = modelElement.Enclosing as IModelElement; } return(retVal); }
/// <summary> /// Finds a symbol in a sub declarator and adds it to retVal /// </summary> /// <param name="subDeclarator"></param> /// <param name="name"></param> /// <param name="retVal"></param> public static void Find(ISubDeclarator subDeclarator, string name, List <INamable> retVal) { // Ensure that the declared elements are initialized if (subDeclarator.DeclaredElements == null) { subDeclarator.InitDeclaredElements(); } List <INamable> tmp; if (subDeclarator.DeclaredElements.TryGetValue(name, out tmp)) { retVal.AddRange(tmp); } }
/// <summary> /// Fills the retVal result set according to the subDeclarator class provided as parameter /// </summary> /// <param name="subDeclarator">The subdeclarator used to get the image</param> /// <param name="expectation">The expectatino of the desired element</param> /// <param name="asType">Indicates that we had to go from the values to the types to perform dereferencing</param> /// <param name="values">The return value to update</param> /// <return>the number of elements added</return> private int FillBySubdeclarator(ISubDeclarator subDeclarator, BaseFilter expectation, bool asType, ReturnValue values) { int retVal = 0; if (subDeclarator != null) { // Go to the beginning of the update chain ISubDeclarator currentDeclarator = subDeclarator; ModelElement modelElement = subDeclarator as ModelElement; while (modelElement != null) { if (modelElement.Updates != null) { currentDeclarator = modelElement.Updates as ISubDeclarator; } modelElement = modelElement.Updates; } while (currentDeclarator != null) { // Adds the elements of the current declarator List <INamable> tmp = new List <INamable>(); currentDeclarator.Find(Image, tmp); foreach (INamable namable in tmp) { retVal += addReference(namable, expectation, asType, values); } // Follow the update chain modelElement = currentDeclarator as ModelElement; if (modelElement != null && modelElement.UpdatedBy.Count == 1) { currentDeclarator = modelElement.UpdatedBy[0] as ISubDeclarator; } else { currentDeclarator = null; } } } values.ApplyUpdates(); return(retVal); }
/// <summary> /// Cleans up the declared elements dictionaries /// </summary> /// <param name="obj"></param> /// <param name="visitSubNodes"></param> public override void visit(IXmlBBase obj, bool visitSubNodes) { ModelElement modelElement = obj as ModelElement; if (modelElement != null && ClearCaches) { modelElement.ClearCache(); } ISubDeclarator subDeclarator = obj as ISubDeclarator; if (subDeclarator != null) { subDeclarator.InitDeclaredElements(); } base.visit(obj, visitSubNodes); }
/// <summary> /// Appends a namable in a dictionary /// </summary> /// <param name="subDeclarator"></param> /// <param name="name"></param> /// <param name="namable"></param> public static void AppendNamable(ISubDeclarator subDeclarator, string name, INamable namable) { if (namable != null && subDeclarator != null && subDeclarator.DeclaredElements != null) { CriticalSection.WaitOne(); try { if (!subDeclarator.DeclaredElements.ContainsKey(name)) { subDeclarator.DeclaredElements[name] = new List <INamable>(); } subDeclarator.DeclaredElements[name].Add(namable); } finally { CriticalSection.ReleaseMutex(); } } }
/// <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; List <INamable> tmp; if (subDeclarator.DeclaredElements.TryGetValue(value.Name, out tmp)) { foreach (INamable namable in tmp) { if (namable == value) { retVal = true; break; } } } return(retVal); }
/// <summary> /// Considers this sub declarator to create the list of choices /// </summary> /// <param name="prefix"></param> /// <param name="subDeclarator"></param> /// <param name="retVal"></param> private static void ConsiderSubDeclarator(string prefix, ISubDeclarator subDeclarator, ICollection <ObjectReference> retVal) { IVariable variable = subDeclarator as IVariable; if (variable != null) { subDeclarator = variable.Type as ISubDeclarator; } if (subDeclarator != null) { foreach (KeyValuePair <string, List <INamable> > pair in subDeclarator.DeclaredElements) { if (pair.Key.StartsWith(prefix)) { foreach (INamable namable in pair.Value) { retVal.Add(new ObjectReference(pair.Key, namable)); } } } } }
/// <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); if (EfsSystem.Instance.CheckParentRelationship && !(namable is EmptyValue)) { // Consistency check. // Empty value should not be considered because we can dereference 'Empty' IVariable subDeclVar = subDeclarator as IVariable; object enclosed = ((IEnclosed) namable).Enclosing; if (subDeclVar != null) { if (enclosed != subDeclVar.Value) { AddError("Consistency check failed : enclosed element's father relationship is inconsistent", RuleChecksEnum.SemanticAnalysisError); } } else { if (enclosed != subDeclarator) { // There is still an exception : when the element is declared in the default namespace if (subDeclarator != EfsSystem.Instance || enclosed != EfsSystem.Instance.FindByFullName("Default")) { AddError( "Consistency check failed : enclosed element's father relationship is inconsistent", RuleChecksEnum.SemanticAnalysisError); } } } } } } // Provide the result, if it is unique if (tmp2.Count == 1) { retVal = tmp2[0]; } } return retVal; }
/// <summary> /// Fills the retVal result set according to the subDeclarator class provided as parameter /// </summary> /// <param name="subDeclarator">The subdeclarator used to get the image</param> /// <param name="expectation">The expectatino of the desired element</param> /// <param name="asType">Indicates that we had to go from the values to the types to perform dereferencing</param> /// <param name="values">The return value to update</param> /// <return>the number of elements added</return> private int FillBySubdeclarator(ISubDeclarator subDeclarator, BaseFilter expectation, bool asType, ReturnValue values) { int retVal = 0; if (subDeclarator != null) { // Go to the beginning of the update chain ISubDeclarator currentDeclarator = subDeclarator; ModelElement modelElement = subDeclarator as ModelElement; while (modelElement != null) { if (modelElement.Updates != null) { currentDeclarator = modelElement.Updates as ISubDeclarator; } modelElement = modelElement.Updates; } while (currentDeclarator != null) { // Adds the elements of the current declarator List<INamable> tmp = new List<INamable>(); currentDeclarator.Find(Image, tmp); foreach (INamable namable in tmp) { retVal += addReference(namable, expectation, asType, values); } // Follow the update chain modelElement = currentDeclarator as ModelElement; if (modelElement != null && modelElement.UpdatedBy.Count == 1) { currentDeclarator = modelElement.UpdatedBy[0] as ISubDeclarator; } else { currentDeclarator = null; } } } values.ApplyUpdates(); return retVal; }
/// <summary> /// Finds an element in the model based on its decomposed name, where the index indicates which element have already been matched /// </summary> /// <param name="root">the root where search need be conducted</param> /// <param name="names">the decomposed name</param> /// <param name="index">the index where elements have already been matched</param> /// <param name="skipDefault">Indicates that the default namespace should not be considered as empty in the name</param> /// <returns></returns> private T findByName(object root, string[] names, int index, bool skipDefault) { T retVal = null; if (root != null) { if (root is ISubDeclarator && index < names.Length) { ISubDeclarator declarator = root as ISubDeclarator; // This is the last name to check and all names match. // Provide the first one with the correct type List <INamable> values = new List <INamable>(); declarator.Find(names[index], values); foreach (INamable namable in values) { if (index == names.Length - 1) { retVal = namable as T; if (retVal != null) { break; } } else { retVal = findByName(namable, names, index + 1, skipDefault); if (retVal != null) { break; } } } if (retVal == null && !skipDefault) { values.Clear(); declarator.Find("Default", values); foreach (INamable namable in values) { retVal = findByName(namable, names, index, true); if (retVal != null) { break; } } } } // Nothing has been found under this node, try with the enclosing node if (retVal == null && index == 0) { if (root is IModelElement) { IModelElement elt = root as IModelElement; if (elt.Enclosing != null) { retVal = findByName(elt.Enclosing, names, 0, skipDefault); } } } } 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> /// Provides the element referenced by this designator, given the enclosing element /// </summary> /// <param name="context"></param> /// <returns></returns> public INamable GetReference(InterpretationContext context) { INamable retVal = null; switch (Location) { case LocationEnum.Stack: retVal = context.LocalScope.GetVariable(Image); if (retVal == null) { AddError(Image + " not found on the stack", RuleChecksEnum.ExecutionFailed); } break; case LocationEnum.Instance: INamable instance = context.Instance; while (instance != null) { ISubDeclarator subDeclarator = instance as ISubDeclarator; if (subDeclarator != null) { INamable tmp = GetReferenceBySubDeclarator(subDeclarator); if (tmp != null) { if (retVal == null) { retVal = tmp; instance = null; } } } instance = EnclosingSubDeclarator(instance); } if (retVal == null) { AddError(Image + " not found in the current instance " + context.Instance.Name, RuleChecksEnum.ExecutionFailed); } break; case LocationEnum.This: retVal = context.Instance; break; case LocationEnum.Enclosing: ITypedElement typedElement = context.Instance as ITypedElement; while (typedElement != null && !(typedElement.Type is Structure)) { typedElement = typedElement.Enclosing as ITypedElement; } retVal = typedElement; break; case LocationEnum.Model: retVal = Ref; if (retVal == null) { AddError(Image + " not found in the enclosing model", RuleChecksEnum.ExecutionFailed); } break; case LocationEnum.NotDefined: AddError("Semantic analysis not performed on " + ToString(), RuleChecksEnum.ExecutionFailed); break; } 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); if (EfsSystem.Instance.CheckParentRelationship && !(namable is EmptyValue)) { // Consistency check. // Empty value should not be considered because we can dereference 'Empty' IVariable subDeclVar = subDeclarator as IVariable; object enclosed = ((IEnclosed)namable).Enclosing; if (subDeclVar != null) { if (enclosed != subDeclVar.Value) { AddError("Consistency check failed : enclosed element's father relationship is inconsistent", RuleChecksEnum.SemanticAnalysisError); } } else { if (enclosed != subDeclarator) { // There is still an exception : when the element is declared in the default namespace if (subDeclarator != EfsSystem.Instance || enclosed != EfsSystem.Instance.FindByFullName("Default")) { AddError( "Consistency check failed : enclosed element's father relationship is inconsistent", RuleChecksEnum.SemanticAnalysisError); } } } } } } // Provide the result, if it is unique if (tmp2.Count == 1) { retVal = tmp2[0]; } } return(retVal); }
/// <summary> /// Considers this sub declarator to create the list of choices /// </summary> /// <param name="prefix"></param> /// <param name="subDeclarator"></param> /// <param name="retVal"></param> private static void ConsiderSubDeclarator(string prefix, ISubDeclarator subDeclarator, ICollection<ObjectReference> retVal) { IVariable variable = subDeclarator as IVariable; if (variable != null) { subDeclarator = variable.Type as ISubDeclarator; } if (subDeclarator != null) { foreach (KeyValuePair<string, List<INamable>> pair in subDeclarator.DeclaredElements) { if (pair.Key.StartsWith(prefix)) { foreach (INamable namable in pair.Value) { retVal.Add(new ObjectReference(pair.Key, namable)); } } } } }
/// <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> /// Provides the list of model elements which correspond to the prefix given /// </summary> /// <param name="index">The location of the cursor in the text box</param> /// <param name="prefix">The prefix used to reduce the choices</param> /// <returns></returns> public SortedSet <ObjectReference> AllChoices(int index, string prefix) { SortedSet <ObjectReference> retVal = new SortedSet <ObjectReference>(); double val; bool isANumber = double.TryParse(CurrentPrefix(index - 1).Trim(), NumberStyles.Any, CultureInfo.InvariantCulture, out val); if (!isANumber) { ISubDeclarator subDeclarator = null; INamable namable = GetInstance(index); if (namable == null) { if (Text[index] != '.') { // Out of context search, create the corresponding context according to the current instance subDeclarator = EnclosingSubDeclarator(Instance as IModelElement); while (!(subDeclarator is Dictionary)) { ConsiderSubDeclarator(prefix, subDeclarator, retVal); subDeclarator = EnclosingSubDeclarator(((IModelElement)subDeclarator).Enclosing as IModelElement); } // Consider toplevel elements ConsiderSubDeclarator(prefix, EfsSystem.Instance, retVal); foreach (Dictionary dictionary in EfsSystem.Instance.Dictionaries) { ConsiderSubDeclarator(prefix, dictionary, retVal); } // Also add the templates foreach (string template in Templates) { if (template.StartsWith(prefix)) { retVal.Add(new ObjectReference(template, null)); } } } } else { subDeclarator = namable as ISubDeclarator; if (subDeclarator == null) { ITypedElement typedElement = namable as ITypedElement; if (typedElement != null && typedElement.Type is Structure) { subDeclarator = typedElement.Type as ISubDeclarator; } } } if (subDeclarator != null) { ConsiderSubDeclarator(prefix, subDeclarator, retVal); } } 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, Filter.AcceptableChoice expectation, bool lastElement) { ReturnValue retVal = new ReturnValue(this); if (instance == null) { // Special handling for THIS if (Image.CompareTo("THIS") == 0) { INamable currentElem = Root; while (currentElem != null) { Types.Type type = currentElem as Types.Type; if (type != null) { Types.StateMachine stateMachine = type as Types.StateMachine; while (stateMachine != null) { type = stateMachine; stateMachine = stateMachine.EnclosingStateMachine; } 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, 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.getPredefinedItem(Image), expectation, 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) { Utils.ISubDeclarator subDeclarator = currentNamable as Utils.ISubDeclarator; if (subDeclarator != null && !(subDeclarator is Dictionary)) { if (FillBySubdeclarator(subDeclarator, expectation, retVal) > 0 && lastElement) { return(retVal); } } currentNamable = enclosingSubDeclarator(currentNamable); } // . In the dictionaries declared in the system foreach (Dictionary dictionary in EFSSystem.Dictionaries) { if (FillBySubdeclarator(dictionary, expectation, retVal) > 0 && lastElement) { return(retVal); } Types.NameSpace defaultNameSpace = dictionary.findNameSpace("Default"); if (defaultNameSpace != null) { if (FillBySubdeclarator(defaultNameSpace, expectation, retVal) > 0 && lastElement) { return(retVal); } } } } else { // The instance is provided, hence, this is not the first designator in the . separated list of designators if (instance is Types.ITypedElement && !(instance is Constants.State)) { // If the instance is a typed element, dereference it to its corresponding type Types.ITypedElement element = instance as Types.ITypedElement; if (element.Type != EFSSystem.NoType) { instance = element.Type; } } // Find the element in all enclosing sub declarators of the instance while (instance != null) { Utils.ISubDeclarator subDeclarator = instance as Utils.ISubDeclarator; if (FillBySubdeclarator(subDeclarator, expectation, retVal) > 0) { instance = null; } else { if (instance is Dictionary) { instance = enclosingSubDeclarator(instance); } else { instance = null; } } } } return(retVal); }
/// <summary> /// Provides the element referenced by this designator, given the enclosing element /// </summary> /// <param name="enclosing"></param> /// <returns></returns> public INamable getReference(InterpretationContext context) { INamable retVal = null; switch (Location) { case LocationEnum.Stack: retVal = context.LocalScope.getVariable(Image); if (retVal == null) { AddError(Image + " not found on the stack"); } break; case LocationEnum.Instance: Utils.INamable instance = context.Instance; while (instance != null) { ISubDeclarator subDeclarator = instance as ISubDeclarator; if (subDeclarator != null) { INamable tmp = getReferenceBySubDeclarator(subDeclarator); if (tmp != null) { if (retVal == null) { retVal = tmp; instance = null; } } } instance = enclosingSubDeclarator(instance); } if (retVal == null) { AddError(Image + " not found in the current instance " + context.Instance.Name); } break; case LocationEnum.This: retVal = context.Instance; break; case LocationEnum.Model: retVal = Ref; if (retVal == null) { AddError(Image + " not found in the enclosing model"); } break; case LocationEnum.NotDefined: AddError("Semantic analysis not performed on " + ToString()); break; } return(retVal); }