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(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(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]); }