/// <summary>
/// Determines the set of rules in a specific namespace to be applied.
/// </summary>
/// <param name="priority">The priority for which this activation is requested</param>
/// <param name="activations">The set of activations to be filled</param>
/// <param name="nameSpace">The namespace to consider</param>
/// <returns></returns>
private void SetupNameSpaceActivations(Generated.acceptor.RulePriority priority, HashSet <Activation> activations, Types.NameSpace nameSpace)
{
// Finds all activations in sub namespaces
foreach (Types.NameSpace subNameSpace in nameSpace.SubNameSpaces)
{
SetupNameSpaceActivations(priority, activations, subNameSpace);
}
List <Rules.RuleCondition> rules = new List <Rules.RuleCondition>();
foreach (Rule rule in nameSpace.Rules)
{
rules.Clear();
rule.Evaluate(this, priority, rule, rules);
Activation.RegisterRules(activations, rules, nameSpace);
}
foreach (Functions.Procedure procedure in nameSpace.Procedures)
{
rules.Clear();
Activation.RegisterRules(activations, rules, procedure);
}
foreach (Variables.IVariable variable in nameSpace.Variables)
{
EvaluateVariable(priority, activations, variable);
}
}
/// <summary>
/// Fills the given structure with the values provided from the database
/// </summary>
/// <param name="aNameSpace">Namespace of the structure</param>
/// <param name="fields">Fields to be copied into the structure</param>
/// <param name="index">Index (of fields list) from which we have to start copying</param>
/// <param name="aStructure">The structure to be filled</param>
private void FillStructure(Types.NameSpace aNameSpace, ArrayList fields, ref int index, Values.StructureValue aStructure)
{
int j = 0;
for (int i = index; i < fields.Count; i++)
{
Tests.DBElements.DBField field = fields[i] as Tests.DBElements.DBField;
KeyValuePair <string, Variables.IVariable> pair = aStructure.SubVariables.ElementAt(j);
Variables.IVariable variable = pair.Value;
if (variable.Name.StartsWith(field.Variable)) // we use StartsWith and not Equals because we can have N_ITER_1 and N_ITER
{
if (variable.Type is Types.Enum)
{
Types.Enum type = variable.Type as Types.Enum;
foreach (DataDictionary.Constants.EnumValue enumValue in type.Values)
{
int value = Int32.Parse(enumValue.getValue());
if (value == field.Value)
{
variable.Value = enumValue;
j++;
break;
}
}
}
else if (variable.Type is Types.Range)
{
Types.Range type = variable.Type as Types.Range;
variable.Value = new Values.IntValue(type, (decimal)field.Value);
j++;
}
else
{
throw new Exception("Unhandled variable type");
}
if (field.Variable.Equals("N_ITER")) // we have to create a sequence
{
KeyValuePair <string, Variables.IVariable> sequencePair = aStructure.SubVariables.ElementAt(j);
Variables.IVariable sequenceVariable = sequencePair.Value;
Types.Collection collectionType = (Types.Collection)EFSSystem.findType(aNameSpace, sequenceVariable.TypeName);
Values.ListValue sequence = new Values.ListValue(collectionType, new List <Values.IValue>());
for (int k = 0; k < field.Value; k++)
{
Types.Structure structureType = (Types.Structure)EFSSystem.findType(aNameSpace, sequence.CollectionType.Type.FullName);
Values.StructureValue structureValue = new Values.StructureValue(structureType, structureType.NameSpace);
FillStructure(aNameSpace, fields, ref index, structureValue);
sequence.Val.Add(structureValue);
}
sequenceVariable.Value = sequence;
j++;
}
}
// if all the fields of the structue are filled, we terminated
if (j == aStructure.SubVariables.Count)
{
index = i;
break;
}
}
}
/// <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);
}
