public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var node = treeNode.GetMappedChildNodes()[0];
this.Label = node.Token.ValueString;
}
/// <summary>
/// Finds a mapped grand-child of the parse-tree node and returns its AST node, if the expected AST type matches.
/// </summary>
/// <typeparam name="TargetAst">Expected AST type.</typeparam>
/// <param name="parseNode">Original parse-tree node.</param>
/// <param name="childIndex">Child item position.</param>
/// <param name="grandChildIndex">Grand-child item position.</param>
/// <returns>Grand-child AST node, if it matches the expected type. Null otherwise.</returns>
public static TargetAst GetGrandChildAst <TargetAst>(this ParseTreeNode parseNode, int childIndex, int grandChildIndex) where TargetAst : BaseAstNode
{
var childNode = parseNode?.GetMappedChildNodes().GetSafeItem(childIndex);
var grandChildNode = childNode?.GetMappedChildNodes().GetSafeItem(grandChildIndex);
return(grandChildNode?.AstNode as TargetAst);
}
// this is where data is initially passed to the item
public override void Init(AstContext context, ParseTreeNode treeNode)
{
string sVal = treeNode.FindTokenAndGetText();
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
var functionOrProperty = AddChild("FunctionOrId", nodes[0]);
if (functionOrProperty is SelectFunctionNode)
{
_TheFunction = (SelectFunctionNode)functionOrProperty;
}
else if (functionOrProperty is SelectPropertyNode)
{
_PropNode = (SelectPropertyNode)functionOrProperty;
}
else
{
throw new Exception("Unmanaged type in selectmemberaccessnode");
}
if (nodes.Count > 1)
{
var child = AddChild("Queue", nodes[1]);
string sval = nodes[1].FindTokenAndGetText();
if (child is LeftObjectNode)
{
_queue = (LeftObjectNode)child;
}
}
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
_target = AddChild("Target", nodes.First());
_index = AddChild("Index", nodes.Last());
AsString = "[" + _index + "]";
}
public virtual void BuildAst(ParseTreeNode parseNode)
{
var term = parseNode.Term;
if (term.Flags.IsSet(TermFlags.NoAstNode) || parseNode.AstNode != null) return;
//children first
var processChildren = !parseNode.Term.Flags.IsSet(TermFlags.AstDelayChildren) &&
parseNode.ChildNodes.Count > 0;
if (processChildren)
{
var mappedChildNodes = parseNode.GetMappedChildNodes();
for (var i = 0; i < mappedChildNodes.Count; i++)
BuildAst(mappedChildNodes[i]);
}
//create the node
//We know that either NodeCreator or DefaultNodeCreator is set; VerifyAstData create the DefaultNodeCreator
var config = term.AstConfig;
if (config.NodeCreator != null)
{
config.NodeCreator(Context, parseNode);
// We assume that Node creator method creates node and initializes it, so parser does not need to call
// IAstNodeInit.Init() method on node object. But we do call AstNodeCreated custom event on term.
}
else
{
//Invoke the default creator compiled when we verified the data
parseNode.AstNode = config.DefaultNodeCreator();
//Initialize node
var iInit = parseNode.AstNode as IAstNodeInit;
if (iInit != null)
iInit.Init(Context, parseNode);
}
//Invoke the event on term
term.OnAstNodeCreated(parseNode);
} //method
/// <summary>
/// Finds a mapped child of the parse-tree node and returns its string token, if it has any.
/// </summary>
/// <param name="parseNode">Original parse-tree node.</param>
/// <param name="index">Item position.</param>
/// <returns>String token of the child parse-node, if it has any. Empty string otherwise.</returns>
public static string GetChildString(this ParseTreeNode parseNode, int index)
{
var childNode = parseNode?.GetMappedChildNodes().GetSafeItem(index);
string childNodeStr = childNode?.FindTokenAndGetText();
return(childNodeStr ?? "");
}
/// <summary>
/// Finds a mapped grand-child of the parse-tree node and returns its string token, if it has any.
/// </summary>
/// <param name="parseNode">Original parse-tree node.</param>
/// <param name="childIndex">Child item position.</param>
/// <param name="grandChildIndex">Grand-child item position.</param>
/// <returns>String token of the grand-child parse-node, if it has any. Empty string otherwise.</returns>
public static string GetGrandChildString(this ParseTreeNode parseNode, int childIndex, int grandChildIndex)
{
var childNode = parseNode?.GetMappedChildNodes().GetSafeItem(childIndex);
var grandChildNode = childNode?.GetMappedChildNodes().GetSafeItem(grandChildIndex);
string grandChildNodeStr = grandChildNode?.FindTokenAndGetText();
return(grandChildNodeStr ?? "");
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
Test = AddChild("Test", nodes[0]);
IfTrue = AddChild("IfTrue", nodes[1]);
if (nodes.Count > 2)
IfFalse = AddChild("IfFalse", nodes[2]);
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
ParseTreeNodeList nodes = treeNode.GetMappedChildNodes();
this.unOpNode = AddChild("unOpNode", nodes[0]);
this.termNode = AddChild("termNode", nodes[1]);
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
functionName = nodes[2];
CallArgs = AddChild("CallArgs", nodes[3]);
Body = AddChild("Body", nodes[4]);
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
TargetRef = AddChild("Target", nodes[0]);
TargetRef.UseType = NodeUseType.CallTarget;
_targetName = nodes[0].FindTokenAndGetText();
Arguments = AddChild("Args", nodes[1]);
AsString = "Call " + _targetName;
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
OpSymbol = nodes[0].FindTokenAndGetText();
Argument = AddChild("Arg", nodes[1]);
base.AsString = OpSymbol + "(unary op)";
var interpContext = (InterpreterAstContext)context;
base.ExpressionType = interpContext.OperatorHandler.GetUnaryOperatorExpressionType(OpSymbol);
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
_left = AddChild("Target", nodes[0]);
var right = nodes[nodes.Count - 1];
_memberName = right.FindTokenAndGetText();
ErrorAnchor = right.Span.Location;
AsString = "." + _memberName;
}
// this is where data is initially passed to the item
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
if (nodes.Count > 0)
{
propName = nodes[0].FindTokenAndGetText();
}
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
FixingId = nodes[0].FindTokenAndGetText();
ScheduleId = nodes[2].FindTokenAndGetText();
AsString = "Fixing ";
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
if (nodes.Count > 2)
{
AddChild("Node", nodes[1]);
}
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
//System.Console.WriteLine(nodes.Count());
//nodes.ForEach((node) => System.Console.WriteLine(node));
//nodes.ForEach((node) => AddChild("Stmt", node));
VarNames = AddChild("VarNames", nodes[1]);
}
public override void Init(AstContext context, ParseTreeNode parseNode)
{
var children = parseNode.GetMappedChildNodes();
Label = AddChild(children[0]) as IdentNode;
if (Label is null)
{
throw new System.Exception("Expected child to be an ident!");
}
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
TargetRef = AddChild("Target", nodes[0]);
targetName = TargetRef.AsString;
Arguments = AddChild("Args", nodes[1]);
AsString = "Call " + targetName;
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
Target = AddChild("Target", nodes[0]);
memberName = nodes[1].FindTokenAndGetText();
ErrorAnchor = nodes[1].Span.Location;
AsString = "." + memberName;
}
public override void Initialize(AstContext context, ParseTreeNode treeNode)
{
base.Initialize(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
OpSymbol = nodes[0].FindTokenAndGetText();
Argument = AddChild("Arg", nodes[1]);
AsString = OpSymbol + "(unary op)";
ExpressionType = OperatorHandler.GetUnaryOperatorExpressionType(OpSymbol);
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
this.Label = nodes[0].FindTokenAndGetText();
// Make a nice display name.
this.AsString = "Label: " + this.Label;
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
Expr = AddChild("Expr", nodes[0]);
functionName = nodes[1];
Args = AddChild("Args", nodes[2]);
BlockArg = AddChild("BlockArg", nodes[3]);
}
public override void Init(AstContext context, ParseTreeNode parseNode)
{
foreach (var child in parseNode.GetMappedChildNodes())
{
if (!(child.AstNode is null))
{
AddChild(child);
}
}
}
// this is where data is initially passed to the item
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
if (nodes.Count == 1)
{
actualnode = (AstNode)nodes[0].AstNode;
AddChild(string.Empty, nodes[0]);
}
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
Flag = AddChild("Flag: ", nodes[1]);
Condition = AddChild("Condition: ", nodes[2]);
Update = AddChild("Update: ", nodes[3]);
Block = AddChild("Block: ", nodes[4]);
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
ParseTreeNodeList nodes = treeNode.GetMappedChildNodes();
Left = AddChild("Left", nodes[0]);
Op = nodes[1];
Right = AddChild("Right", nodes[2]);
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
Condition = AddChild("Condition", nodes[1]);
Body = AddChild("Body", nodes[0]);
AsString = "Do While Loop";
}
public override void BuildAst(ParseTreeNode parseNode)
{
if (parseNode.Term.Flags.IsSet(TermFlags.IsList) && parseNode.Term.Flags.IsSet(TermFlags.NoAstNode))
{ // HACK: the default BuildAst does not proceed the children of the list node (is it a bug in Irony, or what?)
var mappedChildNodes = parseNode.GetMappedChildNodes();
foreach (var mappedChildNode in mappedChildNodes)
BuildAst(mappedChildNode);
}
else
base.BuildAst(parseNode);
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
this.Label = nodes[0].FindTokenAndGetText();
// Make a nice display name.
this.AsString = "Label: " + this.Label;
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
target = AddChild("Target", nodes[1]) as IdentifierNode;
parameters = AddChild("Parameters", nodes[2]) as ParamListNode;
isExtension = string.Equals(nodes[3].FindTokenAndGetText(), "extension", StringComparison.CurrentCultureIgnoreCase);
AsString = "<extern " + (isExtension ? "Extension " : "") + "Function " + target.AsString + "[" + parameters.ChildNodes.Count + "]>";
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
var numberNode = nodes[0];
var registerNode = nodes[1];
this.Value = ms_valueLookup[registerNode.Token.ValueString];
this.NextWord = Convert.ToUInt16(numberNode.Token.Value);
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
FindOpAndDetectPostfix(nodes);
int argIndex = IsPostfix? 0 : 1;
Argument = AddChild(NodeUseType.ValueReadWrite, "Arg", nodes[argIndex]);
BinaryOpSymbol = OpSymbol[0].ToString(); //take a single char out of ++ or --
var interpContext = (InterpreterAstContext)context;
BinaryOp = interpContext.OperatorHandler.GetOperatorExpressionType(BinaryOpSymbol);
base.AsString = OpSymbol + (IsPostfix ? "(postfix)" : "(prefix)");
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
ParseTreeNodeList nodes = treeNode.GetMappedChildNodes();
foreach (var node in nodes)
{
this.numList.Add(AddChild("numList", node));
}
}
/// <summary>
/// Initialization of the AST node. Specifies conversion from parse-tree node to AST node.
/// </summary>
/// <param name="treeNode">Parse-tree node.</param>
public override void Init(ParseTreeNode treeNode)
{
TypedIdentifiers = new List <Tuple <string, string> >();
var childNodes = treeNode.GetMappedChildNodes();
var listOfTypeListsN = (childNodes.Count > 0) ? childNodes[0] : null;
if (listOfTypeListsN != null)
{
foreach (var singleTypedList in listOfTypeListsN.GetMappedChildNodes())
{
var typedListBlocks = singleTypedList.GetMappedChildNodes();
var identifiersList = (typedListBlocks.Count > 0) ? typedListBlocks[0] : null;
var typeDeclaration = (typedListBlocks.Count > 1) ? typedListBlocks[1] : null;
string type = "";
if (typeDeclaration != null)
{
var typeDeclStruct = typeDeclaration.GetMappedChildNodes();
bool typeDeclared = (typeDeclStruct.Count > 1);
if (typeDeclared)
{
var typeDeclItemList = typeDeclStruct[1].GetMappedChildNodes();
var typeOrEitherTypeList = (typeDeclItemList.Count > 1) ? typeDeclItemList[1] : null;
if (typeOrEitherTypeList != null)
{
var eitherTypeList = typeOrEitherTypeList.GetMappedChildNodes();
foreach (var eitherType in eitherTypeList)
{
type += (type.Length > 0) ? ";" : "";
type += eitherType.FindTokenAndGetText();
}
}
else
{
type = typeDeclItemList[0].FindTokenAndGetText();
}
}
}
if (identifiersList != null)
{
foreach (var identifierItem in identifiersList.GetMappedChildNodes())
{
string identifier = identifierItem.FindTokenAndGetText();
TypedIdentifiers.Add(Tuple.Create(identifier, type));
}
}
}
}
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
TargetRef = AddChild("Target", nodes[0]);
TargetRef.UseType = NodeUseType.CallTarget;
_targetName = nodes[0].FindTokenAndGetText();
Arguments = AddChild("Args", nodes[1]);
AsString = "Call " + _targetName;
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
IterVarBlock = AddChild("IterVar", nodes[0]);
InExpr = AddChild("InExpr", nodes[1]);
Block = AddChild("ForeachBlock", nodes[2]);
AsString = "Forech Loop";
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
//child #0 is usually a keyword like "def"
var nodes = treeNode.GetMappedChildNodes();
NameNode = AddChild("Name", nodes[1]);
Lambda = new LambdaNode(context, treeNode, nodes[2], nodes[3]);
Lambda.Parent = this;
AsString = "<Function " + NameNode.AsString + ">";
//Lamda will set treeNode.AstNode to itself, we need to set it back to "this" here
treeNode.AstNode = this; //
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
Test = AddChild("Test", nodes[0]);
IfTrue = AddChild("IfTrue", nodes[1]);
if (nodes.Count > 2)
{
IfFalse = AddChild("IfFalse", nodes[2]);
}
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
var hasVar = nodes[0].ChildNodes[0].ChildNodes.Count > 0;
if (hasVar)
{
exceptionVar = (IdentifierNode)AddChild("exceptionVar", nodes[0].ChildNodes[0].ChildNodes[0]);
}
block = AddChild("Block", nodes[1]);
}
} //null, Block, if
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
Condition = AddChild("Condition: ", nodes[1]);
Block = AddChild("Block: ", nodes[2]);
if (nodes.Count > 4)
{
Else = AddChild("Else: ", nodes[4]);
}
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
Condition = AddChild("Condition", nodes[0]);
IfBlock = AddChild("IfBlock", nodes[1]);
if (nodes.Count > 2)
{
ElseBlock = AddChild("ElseBlock", nodes[2]);
}
}
public override void Initialize(AstContext context, ParseTreeNode treeNode)
{
base.Initialize(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
_left = AddChild("Target", nodes[0]);
var right = nodes[nodes.Count - 1];
_memberName = right.FindTokenAndGetText();
ErrorAnchor = right.Span.Location;
AsString = "." + _memberName;
}
public override void Init(Irony.Ast.AstContext context, ParseTreeNode parseNode)
{
base.Init(context, parseNode);
var nodes = parseNode.GetMappedChildNodes();
if (nodes.Any())
{
Expression = AddChild("Expression", nodes[0]);
}
AsString = "return" + (nodes.Any() ? " Expression" : "");
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
foreach (var node in nodes.Where(e => e.AstNode is LineNode))
{
AddChild(String.Empty, node);
}
// Make a nice display name.
this.AsString = "Lines";
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
Left = AddChild("Arg", nodes[0]);
Right = AddChild("Arg", nodes[2]);
var opToken = nodes[1].FindToken();
OpSymbol = opToken.Text;
var ictxt = context as InterpreterAstContext;
Op = ictxt.OperatorHandler.GetOperatorExpressionType(OpSymbol);
// Set error anchor to operator, so on error (Division by zero) the explorer will point to
// operator node as location, not to the very beginning of the first operand.
ErrorAnchor = opToken.Location;
AsString = Op + "(operator)";
}
AstNode _singleChild; //stores a single child when child count == 1, for fast access
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
foreach (var child in nodes) {
//don't add if it is null; it can happen that "statement" is a comment line and statement's node is null.
// So to make life easier for language creator, we just skip if it is null
if (child.AstNode != null)
AddChild(string.Empty, child);
}
AsString = "Statement List";
if (ChildNodes.Count == 0) {
AsString += " (Empty)";
} else
ChildNodes[ChildNodes.Count - 1].Flags |= AstNodeFlags.IsTail;
}
// this is where data is initially passed to the item
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
if (nodes.Count == 2)
{
// todo: consider model
if (nodes[1].AstNode != null)
{
ElementList = nodes[1];
// AddChild(string.Empty, nodes[1]);
// this.AsString += "(child children: " + child.ChildNodes.Count);
}
}
}
// this is where data is initially passed to the item
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
// gets the argument list
if (nodes.Count > 1)
{
Arguments = new AstNode[nodes[1].ChildNodes.Count];
for (int i = 0; i < nodes[1].ChildNodes.Count; i++)
{
var nd = AddChild("Arg" + i.ToString(), nodes[1].ChildNodes[i]);
Arguments[i] = nd;
}
}
function = treeNode;
}
// this is where data is initially passed to the item
public override void Init(AstContext context, ParseTreeNode treeNode)
{
string sVal = treeNode.FindTokenAndGetText();
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
property = treeNode;
if (nodes.Count > 1)
{
var child = AddChild("Queue", nodes[1]);
string sval = nodes[1].FindTokenAndGetText();
if (child is LeftObjectNode)
{
_queue = (LeftObjectNode)child;
}
}
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
var astNode = nodes[0].AstNode as IContainsLabelAndInstruction;
AddChild(String.Empty, nodes[0]);
this.Label = astNode.Label;
this.Instruction = astNode.Instruction;
// Make a nice display name.
this.AsString = "Line";
if (ChildNodes.Count == 0)
{
this.AsString += " (Empty)";
}
}
// this is where data is initially passed to the item
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
if (nodes.Count > 0)
{
if (nodes[0].AstNode != null)
{
_root = (AstNode)nodes[0].AstNode;
AddChild("Root", nodes[0]);
}
if (nodes.Count > 1)
{
_Queue = (LeftObjectNode)nodes[1].AstNode;
AddChild("Queue", nodes[1]);
}
}
}
// this is where data is initially passed to the item
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
if (nodes.Count == 2)
{
if (nodes[0] != null)
{
thisNode = nodes[0];
// AddChild(string.Empty, nodes[0]);
}
if (nodes[1].AstNode != null)
{
child = (SelectChildrenNodeMot)nodes[1].AstNode;
AddChild(string.Empty, nodes[1]);
// this.AsString += "(child children: " + child.ChildNodes.Count);
}
}
else
this.AsString = "nochildren";
}
public override void Init(AstContext context, ParseTreeNode treeNode) {
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
Target = AddChild(NodeUseType.ValueWrite, "To", nodes[0]);
//Get Op and baseOp if it is combined assignment
AssignmentOp = nodes[1].FindTokenAndGetText();
if (string.IsNullOrEmpty(AssignmentOp))
AssignmentOp = "=";
BinaryExpressionType = CustomExpressionTypes.NotAnExpression;
//There maybe an "=" sign in the middle, or not - if it is marked as punctuation; so we just take the last node in child list
Expression = AddChild(NodeUseType.ValueRead, "Expr", nodes[nodes.Count - 1]);
AsString = AssignmentOp + " (assignment)";
// TODO: this is not always correct: in Pascal the assignment operator is :=.
IsAugmented = AssignmentOp.Length > 1;
if (IsAugmented) {
var ictxt = context as InterpreterAstContext;
base.ExpressionType = ictxt.OperatorHandler.GetOperatorExpressionType(AssignmentOp);
BinaryExpressionType = ictxt.OperatorHandler.GetBinaryOperatorForAugmented(this.ExpressionType);
Target.UseType = NodeUseType.ValueReadWrite;
}
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
if (nodes.Count == 1 && nodes[0].AstNode as MtFork != null)
{
nodes = nodes[0].GetMappedChildNodes();
}
foreach (var child in nodes)
{
// Only allow non-null, mtchains!
if (child.AstNode != null)
{
_chains.Add(AddChild(string.Empty, child) as MtAstNode);
}
}
AsString = "Fork";
}
// this is where data is initially passed to the item
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
}
public override void Init(AstContext context, ParseTreeNode parseNode)
{
var mappedNodes = parseNode.GetMappedChildNodes();
InitImpl(context, parseNode, mappedNodes[0], mappedNodes[1]);
}
public override void Init(AstContext context, ParseTreeNode treeNode)
{
base.Init(context, treeNode);
var nodes = treeNode.GetMappedChildNodes();
globalNode = AddChild("Args", nodes[2]);
}
