/// <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 types for this expression (used in semantic analysis) /// </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> /// <param name="last">indicates that this is the last element in a dereference chain</param> /// <returns></returns> public virtual ReturnValue getReferenceTypes(Utils.INamable instance, Filter.AcceptableChoice expectation, bool last) { ReturnValue retVal = new ReturnValue(this); SemanticAnalysis(instance, Filter.AllMatches); retVal.Add(GetExpressionType()); 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); } } }
/// <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 virtual ReturnValue GetReferenceTypes(INamable instance, BaseFilter expectation, bool last) { ReturnValue retVal = new ReturnValue(this); SemanticAnalysis(instance, AllMatches.INSTANCE); const bool asType = true; retVal.Add(GetExpressionType(), null, asType); 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> /// <paraparam name="expectation">Indicates the kind of element we are looking for</paraparam> /// <param name="last">indicates that this is the last element in a dereference chain</param> /// <returns></returns> public ReturnValue getReferenceTypes(Utils.INamable instance, Filter.AcceptableChoice expectation, bool last) { ReturnValue retVal = null; if (Designator != null) { retVal = new ReturnValue(); foreach (ReturnValueElement element in Designator.getReferences(instance, expectation, last).Values) { if (element.Value is Types.Type) { retVal.Add(element.Value); } } } else if (LiteralValue != null) { retVal = LiteralValue.getReferenceTypes(instance, expectation, true); } 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 ReturnValue GetReferenceTypes(INamable instance, BaseFilter expectation, bool last) { ReturnValue retVal = null; if (Designator != null) { retVal = new ReturnValue(); foreach (ReturnValueElement element in Designator.GetReferences(instance, expectation, last).Values) { if (element.Value is Type) { const bool asType = true; retVal.Add(element.Value, null, asType); } } } else if (LiteralValue != null) { retVal = LiteralValue.GetReferenceTypes(instance, expectation, true); } 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> /// 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 ReturnValue GetReferenceTypes(INamable instance, BaseFilter expectation, bool last) { ReturnValue retVal = null; if (Designator != null) { retVal = new ReturnValue(); foreach (ReturnValueElement element in Designator.GetReferences(instance, expectation, last).Values) { if (element.Value is Type) { const bool asType = true; retVal.Add(element.Value, null, asType); } } } else if (LiteralValue != null) { retVal = LiteralValue.GetReferenceTypes(instance, expectation, true); } 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> /// 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 virtual ReturnValue GetReferenceTypes(INamable instance, BaseFilter expectation, bool last) { ReturnValue retVal = new ReturnValue(this); SemanticAnalysis(instance, AllMatches.INSTANCE); const bool asType = true; retVal.Add(GetExpressionType(), null, asType); 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> /// <paraparam name="expectation">Indicates the kind of element we are looking for</paraparam> /// <param name="last">indicates that this is the last element in a dereference chain</param> /// <returns></returns> public virtual ReturnValue getReferenceTypes(Utils.INamable instance, Filter.AcceptableChoice expectation, bool last) { ReturnValue retVal = new ReturnValue(this); SemanticAnalysis(instance, Filter.AllMatches); retVal.Add(GetExpressionType()); 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> /// <paraparam name="expectation">Indicates the kind of element we are looking for</paraparam> /// <param name="last">indicates that this is the last element in a dereference chain</param> /// <returns></returns> public ReturnValue getReferenceTypes(Utils.INamable instance, Filter.AcceptableChoice expectation, bool last) { ReturnValue retVal = null; if (Designator != null) { retVal = new ReturnValue(); foreach (ReturnValueElement element in Designator.getReferences(instance, expectation, last).Values) { if (element.Value is Types.Type) { retVal.Add(element.Value); } } } else if (LiteralValue != null) { retVal = LiteralValue.getReferenceTypes(instance, expectation, true); } 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 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; }