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_;
}
}
