/// <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>
/// 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(Utils.INamable instance, Filter.AcceptableChoice expectation)
{
bool retVal = base.SemanticAnalysis(instance, expectation);
if (retVal)
{
Ref = null;
ReturnValue tmp = Arguments[0].getReferences(instance, Filter.AllMatches, false);
if (tmp.IsEmpty)
{
tmp = Arguments[0].getReferenceTypes(instance, Filter.AllMatches, false);
}
if (!tmp.IsEmpty)
{
for (int i = 1; i < Arguments.Count; i++)
{
ReturnValue tmp2 = tmp;
tmp = new ReturnValue(Arguments[i]);
foreach (ReturnValueElement elem in tmp2.Values)
{
tmp.Merge(elem, Arguments[i].getReferences(elem.Value, Filter.AllMatches, i == (Arguments.Count - 1)));
}
if (tmp.IsEmpty)
{
AddError("Cannot find " + Arguments[i].ToString() + " in " + Arguments[i - 1].ToString());
}
}
}
else
{
AddError("Cannot evaluate " + Arguments[0].ToString());
}
tmp.filter(expectation);
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;
ReturnValueElement current = tmp.Values[0];
for (int i = Arguments.Count - 1; i > 0; i--)
{
current = current.PreviousElement;
Arguments[i].SemanticAnalysis(current.Value);
}
Arguments[0].SemanticAnalysis();
}
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 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(Utils.INamable instance, Filter.AcceptableChoice expectation)
{
bool retVal = base.SemanticAnalysis(instance, expectation);
if (retVal)
{
Ref = null;
ReturnValue tmp = Arguments[0].getReferences(instance, Filter.AllMatches, false);
if (tmp.IsEmpty)
{
tmp = Arguments[0].getReferenceTypes(instance, Filter.AllMatches, false);
}
if (!tmp.IsEmpty)
{
for (int i = 1; i < Arguments.Count; i++)
{
ReturnValue tmp2 = tmp;
tmp = new ReturnValue(Arguments[i]);
foreach (ReturnValueElement elem in tmp2.Values)
{
tmp.Merge(elem, Arguments[i].getReferences(elem.Value, Filter.AllMatches, i == (Arguments.Count - 1)));
}
if (tmp.IsEmpty)
{
AddError("Cannot find " + Arguments[i].ToString() + " in " + Arguments[i - 1].ToString());
}
}
}
else
{
AddError("Cannot evaluate " + Arguments[0].ToString());
}
tmp.filter(expectation);
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;
ReturnValueElement current = tmp.Values[0];
for (int i = Arguments.Count - 1; i > 0; i--)
{
current = current.PreviousElement;
Arguments[i].SemanticAnalysis(current.Value);
}
Arguments[0].SemanticAnalysis();
}
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>
/// 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.IsUnique)
{
Arguments[0].Ref = retVal.Values[0].Value;
}
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] + " in " + Arguments[i - 1], RuleChecksEnum.SemanticAnalysisError);
}
if (retVal.IsUnique)
{
Arguments[i].Ref = retVal.Values[0].Value;
}
}
}
else
{
AddError("Cannot evaluate " + Arguments[0], RuleChecksEnum.SemanticAnalysisError);
}
retVal.Filter(expectation);
return(retVal);
}