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; }
internal TreeContext(ParserPostProcessParams generatorParams) { generatorParams_ = generatorParams; root_ = generatorParams.root_; byteSrc_ = generatorParams.byteSrc_; errOut_ = generatorParams.errOut_; sErrorPrefix = "<BER_DEFINITE_CONVERTER> FILE:'" + generatorParams_.grammarFileName_ + "' "; }
public static PegNode FindNodeInParents(PegNode node, params EPegGrammar[] ids) { foreach (EPegGrammar id in ids) { PegNode foundNode = FindNodeInParents(node, id); if (foundNode != null) return foundNode; } 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 PegNode FindNode(PegNode node, int nodeDistance, params EPegGrammar[] ids)/*FIND_IN_SEMANTIC_BLOCK*/ { if (node == null || nodeDistance<=0) return null; foreach (EPegGrammar id in ids) { if (node.id_ == (int)id) return node; } PegNode foundNode = FindNode(node.child_, nodeDistance - 1,ids ); if (foundNode!=null) return foundNode; foundNode = FindNode(node.next_, nodeDistance - 1,ids ); if (foundNode != null) return foundNode; return null; }
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_); } }
/// <summary> /// primary: (import / declaration / ruleset / comment)* ; /// </summary> /// <param name="node"></param> /// <param name="elementBlock"></param> private ElementBlock Primary(PegNode node, ElementBlock elementBlock) { foreach (var nextPrimary in node.AsEnumerable()) { switch (nextPrimary.id_.ToEnLess()) { case EnLess.import: Import(nextPrimary.child_, elementBlock); //element.Children.AddRange(import); break; case EnLess.insert: Insert(nextPrimary.child_, elementBlock); //element.Children.AddRange(import); break; case EnLess.standard_ruleset: RuleSet(nextPrimary, elementBlock); break; case EnLess.mixin_ruleset: Mixin(nextPrimary,elementBlock); break; case EnLess.declaration: Declaration(nextPrimary.child_, elementBlock); break; } } return elementBlock; }
/// <summary> /// rgb:(rgb_node)(rgb_node)(rgb_node) / hex hex hex ; /// </summary> /// <param name="node"></param> /// <returns></returns> private INode RGB(PegNode node) { int r = 0, g = 0, b = 0; string tmp; var rgbNode = node.child_; //Fisrt node; if (rgbNode != null) { tmp = rgbNode.GetAsString(Src); r = int.Parse(tmp.Length==1 ? tmp+tmp : tmp, NumberStyles.HexNumber); rgbNode = rgbNode.next_; if (rgbNode != null) { tmp = rgbNode.GetAsString(Src); g = int.Parse(tmp.Length == 1 ? tmp + tmp : tmp, NumberStyles.HexNumber); rgbNode = rgbNode.next_; if (rgbNode != null) { tmp = rgbNode.GetAsString(Src); b = int.Parse(tmp.Length == 1 ? tmp + tmp : tmp, NumberStyles.HexNumber); } } } return new Color(r, g, b); }
private void WriteTag(BinaryWriter rw, PegNode pegNode) { Debug.Assert(pegNode.child_ != null); PegNode tagNode = pegNode.child_; Debug.Assert(tagNode.id_ == (int)EBERTree.OneOctetTag || tagNode.id_ == (int)EBERTree.MultiOctetTag); rw.Write(context_.byteSrc_, tagNode.match_.posBeg_, tagNode.match_.posEnd_ - tagNode.match_.posBeg_); }
private void BuildTree(PegNode root, NodeToString nodeToString) { tvParseTree.Nodes.Clear(); AddTreeNode(null, root, nodeToString); ExpandTop(10); }
/// <summary> /// variable: '@' [-_a-zA-Z0-9]+; /// </summary> /// <param name="node"></param> /// <returns></returns> private INode Variable(PegNode node) { return new Variable(node.GetAsString(Src)); }
private uint GetLength(PegNode pegNode) { uint length = (uint)(pegNode.match_.posEnd_ - pegNode.match_.posBeg_); return length; }
private void WriteLength(BinaryWriter rw, PegNode pegNode,bool bIsComposite) { Debug.Assert(pegNode.child_ != null && pegNode.child_.next_ != null); if (bIsComposite) { rw.Write((byte)0x80); } else { PegNode lengthNode = pegNode.child_.next_; uint length = GetLength(lengthNode.next_); int bytesToWrite = GetLengthEncodingLength(length); if (bytesToWrite == 1) { lengthBuffer[0] = (byte)length; } else { lengthBuffer[0] = (byte)((bytesToWrite - 1) | 0x80); int j = 1; for (int i = bytesToWrite - 1; i > 0; i--) { byte @byte = (byte)((length & (0xFF << 8 * (i - 1))) >> 8 * (i - 1)); lengthBuffer[j++] = @byte; } } rw.Write(lengthBuffer, 0, bytesToWrite); } }
/// <summary> /// selector : (s select element s)+ arguments? ; /// </summary> /// <param name="node"></param> /// <returns></returns> private IEnumerable<ElementBlock> Selector(PegNode node) { var enumerator = node.AsEnumerable().GetEnumerator(); while(enumerator.MoveNext()) { ElementBlock block; var selector = enumerator.Current.GetAsString(Src).Trim(); enumerator.MoveNext(); var name = enumerator.Current.GetAsString(Src); var next = enumerator.Current.next_; var isMixinWithArgs = next != null && next.ToEnLess() == EnLess.arguments; if (isMixinWithArgs) block = new PureMixinBlock(name, selector); else block = new ElementBlock(name, selector); if (isMixinWithArgs) { var arguments = GetMixinArguments(next, block); enumerator.MoveNext(); foreach (var argument in arguments) block.Add(argument); } yield return block; } }
private void WriteContent(BinaryWriter rw, PegNode pegNode) { Debug.Assert(pegNode.id_ == (int)EBERTree.PrimitiveValue); rw.Write(context_.byteSrc_, pegNode.match_.posBeg_, pegNode.match_.posEnd_ - pegNode.match_.posBeg_); }
/// <summary> /// selectors : ws selector (s ',' ws selector)* ws ; /// </summary> /// <param name="node"></param> /// <param name="action"></param> /// <returns></returns> private IEnumerable<ElementBlock> Selectors(PegNode node, Func<IEnumerable<ElementBlock>, IEnumerable<ElementBlock>> action) { foreach(var selector in node.AsEnumerable(x => x.id_.ToEnLess() == EnLess.selector)) { var selectors = Selector(selector); foreach(var s in action(selectors)) yield return s; } }
private bool IsComposite(PegNode pegNode,out PegNode child) { Debug.Assert(pegNode.child_ != null && pegNode.child_.next_ != null && pegNode.child_.next_.next_!=null); child = pegNode.child_.next_.next_; bool bIsComposite= child.id_ == (int)EBERTree.ConstructedDelimValue || child.id_ == (int)EBERTree.ConstructedValue; if (bIsComposite) child = child.child_; return bIsComposite; }
/// <summary> /// space_delimited_expressions: expression (WS expression)* important? ; /// </summary> /// <param name="node"></param> /// <param name="elementBlock"></param> /// <returns></returns> private IEnumerable<INode> SpaceDelimitedExpressions(PegNode node, ElementBlock elementBlock) { yield return Expression(node.child_, elementBlock); node = node.next_; //Tail while (node != null) { switch (node.id_.ToEnLess()) { case EnLess.expression: yield return Expression(node.child_, elementBlock); break; case EnLess.important: yield return new Keyword("!important"); break; } node = node.next_; } }