/// <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>
/// 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 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;
}