/// <summary>
/// Constructor
/// </summary>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="structure"></param>
/// <param name="associations"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public StructExpression(ModelElement root, ModelElement log, Expression structure,
Dictionary<Designator, Expression> associations, ParsingData parsingData)
: base(root, log, parsingData)
{
Structure = SetEnclosed(structure);
SetAssociation(associations);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="structure"></param>
/// <param name="associations"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public StructExpression(ModelElement root, ModelElement log, Expression structure,
Dictionary <Designator, Expression> associations, ParsingData parsingData)
: base(root, log, parsingData)
{
Structure = SetEnclosed(structure);
SetAssociation(associations);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this interpreter tree node is created</param>
/// <param name="log">The element on which logs should be added</param>
/// <param name="parsingData">Additional information about the parsing process</param>
protected InterpreterTreeNode(ModelElement root, ModelElement log, ParsingData parsingData)
{
Root = root;
RootLog = log;
StaticUsage = null;
ParsingData = parsingData;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="expression">the functional expression</param>
/// <param name="log"></param>
/// <param name="parameters">the function parameters</param>
/// <param name="root"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public FunctionExpression(ModelElement root, ModelElement log, List<Parameter> parameters, Expression expression,
ParsingData parsingData)
: base(root, log, parsingData)
{
Parameters = parameters;
Expression = SetEnclosed(expression);
InitDeclaredElements();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="expression">the functional expression</param>
/// <param name="log"></param>
/// <param name="parameters">the function parameters</param>
/// <param name="root"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public FunctionExpression(ModelElement root, ModelElement log, List <Parameter> parameters, Expression expression,
ParsingData parsingData)
: base(root, log, parsingData)
{
Parameters = parameters;
Expression = SetEnclosed(expression);
InitDeclaredElements();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">the root element for which this expression should be parsed</param>
/// <param name="log"></param>
/// <param name="boundVariableName">The name of the bound variable</param>
/// <param name="bindingExpression">The binding expression which provides the value of the variable</param>
/// <param name="expression">The expression to be evaluated</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public LetExpression(ModelElement root, ModelElement log, string boundVariableName, Expression bindingExpression,
Expression expression, ParsingData parsingData)
: base(root, log, parsingData)
{
BoundVariable = CreateBoundVariable(boundVariableName, null);
BindingExpression = SetEnclosed(bindingExpression);
Expression = SetEnclosed(expression);
InitDeclaredElements();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">the root element for which this expression should be parsed</param>
/// <param name="log"></param>
/// <param name="boundVariableName">The name of the bound variable</param>
/// <param name="bindingExpression">The binding expression which provides the value of the variable</param>
/// <param name="expression">The expression to be evaluated</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public LetExpression(ModelElement root, ModelElement log, string boundVariableName, Expression bindingExpression,
Expression expression, ParsingData parsingData)
: base(root, log, parsingData)
{
BoundVariable = CreateBoundVariable(boundVariableName, null);
BindingExpression = SetEnclosed(bindingExpression);
Expression = SetEnclosed(expression);
InitDeclaredElements();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="arguments"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public DerefExpression(ModelElement root, ModelElement log, List<Expression> arguments, ParsingData parsingData)
: base(root, log, parsingData)
{
if (arguments != null)
{
Arguments = arguments;
foreach (Expression expr in Arguments)
{
SetEnclosed(expr);
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="expression">The expression to stabilize</param>
/// <param name="initialValue">The initial value for this stabilisation computation</param>
/// <param name="condition">The condition which indicates that the stabilisation is not complete</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public StabilizeExpression(ModelElement root, ModelElement log, Expression expression, Expression initialValue,
Expression condition, ParsingData parsingData)
: base(root, log, parsingData)
{
Expression = SetEnclosed(expression);
InitialValue = SetEnclosed(initialValue);
Condition = SetEnclosed(condition);
LastIteration = CreateBoundVariable("PREVIOUS", null);
CurrentIteration = CreateBoundVariable("CURRENT", null);
InitDeclaredElements();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="expression">The expression to stabilize</param>
/// <param name="initialValue">The initial value for this stabilisation computation</param>
/// <param name="condition">The condition which indicates that the stabilisation is not complete</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public StabilizeExpression(ModelElement root, ModelElement log, Expression expression, Expression initialValue,
Expression condition, ParsingData parsingData)
: base(root, log, parsingData)
{
Expression = SetEnclosed(expression);
InitialValue = SetEnclosed(initialValue);
Condition = SetEnclosed(condition);
LastIteration = CreateBoundVariable("PREVIOUS", null);
CurrentIteration = CreateBoundVariable("CURRENT", null);
InitDeclaredElements();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="value"></param>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public StringExpression(ModelElement root, ModelElement log, string value, ParsingData parsingData)
: base(root, log, parsingData)
{
Image = value;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="value"></param>
/// <param name="type"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public NumberExpression(ModelElement root, ModelElement log, string value, Type type, ParsingData parsingData)
: base(root, log, parsingData)
{
Image = value;
Type = type;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this element is built</param>
/// <param name="log"></param>
/// <param name="called">The called function</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public Call(ModelElement root, ModelElement log, Expression called, ParsingData parsingData)
: base(root, log, parsingData)
{
Called = SetEnclosed(called);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this model is built</param>
/// <param name="log"></param>
/// <param name="designator"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public Term(ModelElement root, ModelElement log, Designator designator, ParsingData parsingData)
: base(root, log, parsingData)
{
Designator = SetEnclosed(designator);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this model is built</param>
/// <param name="log"></param>
/// <param name="designator"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public Term(ModelElement root, ModelElement log, Designator designator, ParsingData parsingData)
: base(root, log, parsingData)
{
Designator = SetEnclosed(designator);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="elements"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public ListExpression(ModelElement root, ModelElement log, List<Expression> elements, ParsingData parsingData)
: base(root, log, parsingData)
{
SetListElements(elements);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="arguments"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public DerefExpression(ModelElement root, ModelElement log, List <Expression> arguments, ParsingData parsingData)
: base(root, log, parsingData)
{
if (arguments != null)
{
Arguments = arguments;
foreach (Expression expr in Arguments)
{
SetEnclosed(expr);
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root for which this expression should be evaluated</param>
/// <param name="log"></param>
/// <param name="expression">The enclosed expression</param>
/// <param name="unaryOp">the unary operator for this unary expression</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public UnaryExpression(ModelElement root, ModelElement log, Expression expression, string unaryOp, ParsingData parsingData)
: base(root, log, parsingData)
{
Expression = SetEnclosed(expression);
UnaryOp = unaryOp;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root for which this expression should be evaluated</param>
/// <param name="log"></param>
/// <param name="term"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public UnaryExpression(ModelElement root, ModelElement log, Term term, ParsingData parsingData)
: base(root, log, parsingData)
{
Term = SetEnclosed(term);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="value"></param>
/// <param name="type"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public NumberExpression(ModelElement root, ModelElement log, string value, Type type, ParsingData parsingData)
: base(root, log, parsingData)
{
Image = value;
Type = type;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="image">The designator image</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public Designator(ModelElement root, ModelElement log, string image, ParsingData parsingData)
: base(root, log, parsingData)
{
Image = image;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root for which this expression should be evaluated</param>
/// <param name="log"></param>
/// <param name="expression">The enclosed expression</param>
/// <param name="unaryOp">the unary operator for this unary expression</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public UnaryExpression(ModelElement root, ModelElement log, Expression expression, string unaryOp, ParsingData parsingData)
: base(root, log, parsingData)
{
Expression = SetEnclosed(expression);
UnaryOp = unaryOp;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this model is built</param>
/// <param name="log"></param>
/// <param name="literal"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public Term(ModelElement root, ModelElement log, Expression literal, ParsingData parsingData)
: base(root, log, parsingData)
{
LiteralValue = SetEnclosed(literal);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this element is built</param>
/// <param name="log"></param>
/// <param name="called">The called function</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public Call(ModelElement root, ModelElement log, Expression called, ParsingData parsingData)
: base(root, log, parsingData)
{
Called = SetEnclosed(called);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this model is built</param>
/// <param name="log"></param>
/// <param name="literal"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public Term(ModelElement root, ModelElement log, Expression literal, ParsingData parsingData)
: base(root, log, parsingData)
{
LiteralValue = SetEnclosed(literal);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root for which this expression should be evaluated</param>
/// <param name="log"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
protected Expression(ModelElement root, ModelElement log, ParsingData parsingData)
: base(root, log, parsingData)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="value"></param>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public StringExpression(ModelElement root, ModelElement log, string value, ParsingData parsingData)
: base(root, log, parsingData)
{
Image = value;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root for which this expression should be evaluated</param>
/// <param name="log"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
protected Expression(ModelElement root, ModelElement log, ParsingData parsingData)
: base(root, log, parsingData)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root for which this expression should be evaluated</param>
/// <param name="log"></param>
/// <param name="term"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public UnaryExpression(ModelElement root, ModelElement log, Term term, ParsingData parsingData)
: base(root, log, parsingData)
{
Term = SetEnclosed(term);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="left"></param>
/// <param name="op"></param>
/// <param name="right"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public BinaryExpression(ModelElement root, ModelElement log, Expression left, Operator op, Expression right,
ParsingData parsingData)
: base(root, log, parsingData)
{
Left = SetEnclosed(left);
Operation = op;
Right = SetEnclosed(right);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="image">The designator image</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public Designator(ModelElement root, ModelElement log, string image, ParsingData parsingData)
: base(root, log, parsingData)
{
Image = image;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="elements"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public ListExpression(ModelElement root, ModelElement log, List <Expression> elements, ParsingData parsingData)
: base(root, log, parsingData)
{
SetListElements(elements);
}
