C# Base.PegNode类代码示例

	public override string TreeNodeToString(PegNode node)
        {
            string s= GetRuleNameFromId(node.id_);
            BERTreeNode berNode= node as BERTreeNode;
            if( berNode!=null ) s+= ": " + berNode.TreeNodeToString(src_);
            return s;
        }

 public static PegNode FindNodeInParents(PegNode node, EPegGrammar id)
 {
     for(; node!=null;node=node.parent_)
     {
         if( node.id_ == (int) id ) return node;
     }
     return null;
 }

 public static PegNode GetByPath(PegNode node, params int[] path)
 {
     for (int i = 0; i < path.Length; ++i)
     {
         if (node == null || node.id_ != path[i]) return null;
         if (i == path.Length - 1) return node; else node = node.child_;
     }
     return node;
 }

 private void AddTreeNode(TreeNode parent, PegNode node, NodeToString nodeToString)
 {
     if (node == null) return;
     string txt = nodeToString(node);
     if (node.parent_ == null) txt = "^" + txt;
     TreeNode tn = (parent == null ? tvParseTree.Nodes.Add(txt) : parent.Nodes.Add(txt));
     tn.Tag = node;
     AddTreeNode(tn, node.child_, nodeToString);
     AddTreeNode(parent, node.next_, nodeToString);
 }

        protected PegNode LessNodeCreator(ECreatorPhase phase, PegNode parentOrCreated, int id)
        {
            if (phase == ECreatorPhase.eCreate || phase == ECreatorPhase.eCreateAndComplete)
                if (parentOrCreated == null)
                    return new LessPegRootNode(id, src_);
                else
                    return new LessPegNode(parentOrCreated, id, GetRoot());

            return null;
        }

 public static PegNode FindNode(PegNode node, EPegGrammar id, int nodeDistance)
 {
     if (node == null || nodeDistance<=0) return null;
     if (node.id_ == (int)id) return node;
     PegNode foundNode = FindNode(node.child_, id, nodeDistance - 1);
     if (foundNode!=null) return foundNode;
     foundNode = FindNode(node.next_, id, nodeDistance - 1);
     if (foundNode != null) return foundNode;
     return null;
 }

 public static string PegNodeToXml(PegNode pn, string text)
 {
     var message = new StringBuilder(10000);
     var xml = XmlWriter.Create(new StringWriterWithEncoding(message, Encoding.UTF8),
                             DEFAULT_XML_WRITER_SETTINGS);
     xml.WriteStartDocument();
     PegNodeToXmlRecurse(pn, text, xml);
     xml.WriteEndDocument();
     xml.Close();
     return message.ToString();
 }

 public ParserPostProcessParams(string outputDirectory,string sourceFileTitle, string grammarFileName, PegNode root, byte[] byteSrc, TextWriter errOut)
 {
     outputDirectory_ = outputDirectory;
     sourceFileTitle_ = sourceFileTitle;
     grammarFileName_ = grammarFileName;
     root_ = root;
     src_ = null;
     byteSrc_ = byteSrc;
     errOut_ = errOut;
     maxLineLength_= 60;
     spacesPerTap_ = 4;
 }

 /// <summary>
 /// accessor: accessor_name '[' accessor_key ']'; 
 /// </summary>
 /// <param name="node"></param>
 /// <param name="element"></param>
 /// <returns></returns>
 private INode Accessor(PegNode node, Element element)
 {
     var ident = node.GetAsString(Src);
     var key = node.next_.GetAsString(Src).Replace("'", "");
     var el = element.NearestAs<Element>(ident);
     if (el!=null)
     {
         var prop = el.GetAs<Property>(key);
         if (((INode)prop) != null) return prop.Value;
     }
     return new Anonymous("");
 }

 public static void PegNodeToXmlRecurse(PegNode pn, string text, XmlWriter xml)
 {
     var name = pn.id_ > 0 ? Enum.GetName(typeof (EUPnPContentDirectorySearch), pn.id_) : "Node";
     xml.WriteStartElement(name);
     xml.WriteAttributeString("match", pn.GetAsString(text));
     if (pn.child_ != null)
     {
         PegNodeToXmlRecurse(pn.child_, text, xml);
     }
     xml.WriteEndElement();
     if (pn.next_ != null)
     {
         PegNodeToXmlRecurse(pn.next_, text, xml);
     }
 }

 private void WriteDefinite(BinaryWriter rw, PegNode pegNode)
 {
     PegNode child;
    if (pegNode == null) return;
    WriteTag(rw, pegNode);
    WriteLength(rw, pegNode);
    if (IsComposite(pegNode, out child))
    {
        WriteDefinite(rw, child);
    }
    else
    {
        Debug.Assert(pegNode.child_ != null && pegNode.child_.next_ != null && pegNode.child_.next_.next_ != null);
        WriteContent(rw, pegNode.child_.next_.next_);
    }
    WriteDefinite(rw, pegNode.next_);
 }

        public void ConvertStructType(PegNode blocknamenode, IBfsStructType block)
        {
            if (block == null)
                throw new AstConvertException("Type wasn't struct-like");

            block.SourceRange = GetSourceRange(blocknamenode);
            block.Name = GetNodeText(blocknamenode);

            PegNode nextNode = blocknamenode.next_;

            //If the structure has a Compression Method defined
            if ( nextNode != null && GetNodeId(nextNode) == EBinaryFileSchemaParser.compressionmethod)
            {
                block.CompressionMethod = GetNodeText(nextNode);
                block.CompressionRange = GetSourceRange(nextNode);
                nextNode = nextNode.next_;
            }

            //If a primitive type is present, then it is a comsumeable struct type
            if (nextNode != null && GetNodeId(nextNode) == EBinaryFileSchemaParser.primitivetype)
            {
                IBfsConsumptionType special = block as IBfsConsumptionType;
                special.PrimitiveType = ConvertPrimitiveType(nextNode);
                nextNode = nextNode.next_;
            }

            //For each of the fields the struct-type contains
            for(PegNode field = nextNode; field != null; field = field.next_)
            {
                if (GetNodeId(field) == EBinaryFileSchemaParser.field)
                {
                    BfsStructField fielditem = new BfsStructField();
                    fielditem.SourceRange = GetSourceRange(field);
                    ConvertStructField(field, fielditem);
                    block.StructFieldList.Add(fielditem);
                }
                else
                    if (GetNodeId(field) == EBinaryFileSchemaParser.localfield)
                        ConvertLocalField(field, block);
                    else
                        throw new AstConvertException("Node wasn't a field: " + GetNodeId(field));
            }
        }

 private uint GetLength(PegNode pegNode)
 {
     if (dictLength.ContainsKey(pegNode)) return dictLength[pegNode];
     if (pegNode.id_ == (int)EBERTree.ConstructedDelimValue ||
         pegNode.id_ == (int)EBERTree.ConstructedValue)
     {
         uint length = 0;
         for (PegNode child = pegNode.child_; child != null; child = child.next_)
         {
             length += GetLength(child);
         }
         dictLength.Add(pegNode, length);
         return length;
     }
     else if (pegNode.id_ == (int)EBERTree.PrimitiveValue)
     {
         uint length= (uint)(pegNode.match_.posEnd_ - pegNode.match_.posBeg_);
         dictLength.Add(pegNode, length);
         return length;
     }
     else if (pegNode.id_ == (int)EBERTree.TLV)
     {
         Debug.Assert(pegNode.child_ != null && pegNode.child_.next_ != null);
         PegNode tag = pegNode.child_, content = tag.next_.next_;
         uint length= (uint)(pegNode.child_.match_.posEnd_ - pegNode.child_.match_.posBeg_)
             + (uint)GetLengthEncodingLength(GetLength(content))
             + GetLength(content);
         dictLength.Add(pegNode, length);
         return length;
     }
     else
     {
         Debug.Assert(false);
         return 0;
     }
 }

 /// <summary>
 /// ruleset: selectors [{] ws prsimary ws [}] ws /  ws selectors ';' ws;
 /// </summary>
 /// <param name="node"></param>
 /// <param name="elementBlock"></param>
 private void RuleSet(PegNode node, ElementBlock elementBlock)
 {
     foreach (var el in Selectors(node.child_, els => StandardSelectors(elementBlock, els)))
         Primary(node.child_.next_, el);
 }

 private void WriteInDefinite(BinaryWriter rw, PegNode pegNode)
 {
     PegNode child;
     if (pegNode == null) return;
     bool bIsComposite = IsComposite(pegNode, out child);
     WriteTag(rw, pegNode);
     WriteLength(rw, pegNode,bIsComposite);
     if (bIsComposite)
     {
         for(;child!=null;child= child.next_)
         {
             WriteInDefinite(rw, child);
         }
         rw.Write((ushort)0x0000);
     }
     else
     {
         Debug.Assert(pegNode.child_ != null && pegNode.child_.next_ != null && pegNode.child_.next_.next_ != null);
         WriteContent(rw, pegNode.child_.next_.next_);
     }
 }