C# ParseTreeNode.GetMappedChildNodes方法代码示例

        public override void Init(AstContext context, ParseTreeNode treeNode)
        {
            base.Init(context, treeNode);

            var node = treeNode.GetMappedChildNodes()[0];
            this.Label = node.Token.ValueString;
        }

 // 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 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

 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 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);
   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();
   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();
            this.Label = nodes[0].FindTokenAndGetText();

            // Make a nice display name.
            this.AsString = "Label: " + this.Label;
        }

 // 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();
   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);
   //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 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();
            foreach (var node in nodes.Where(e => e.AstNode is LineNode))
            {
                AddChild(String.Empty, node);
            }

            // Make a nice display name.
            this.AsString = "Lines";
        }