public static string CollectTree(IParsingTreeNode node)
{
var v = new RulesParsingTreePrinter();
node.Visit(v);
return(v._sb.ToString());
}
public static IParsingTreeTerminal FindLastTerminal(IParsingTreeNode node)
{
var visitor = new LastTerminalSearcher();
node.Visit(visitor);
return(visitor.Result);
}
public ParsingTreeNodeInfo(IParsingTreeNode node, ISourceTextReader textReader, Func <IParsingTreeGroup, ParsingTreeNodeInfo, IEnumerable <ParsingTreeNodeInfo> > childsAccessor, bool fullInfo, ParsingTreeNodeInfo parent = null)
{
this.Node = node;
this.Parent = parent;
var terminal = node as IParsingTreeTerminal;
if (terminal != null)
{
this.Text = "'" + textReader.GetText(terminal.From, terminal.To) + "'";
if (fullInfo)
{
this.Text = (node.Rule == null ? "<NULL>" : node.Rule.Name) + ": " +
(node.Expression == null ? "<NULL>" : node.Expression.ToString()) + "; " + this.Text;
}
}
var group = node as IParsingTreeGroup;
if (group != null)
{
this.Childs = childsAccessor(group, this);
this.Text = node.Rule == null ? "<NULL>" : node.Rule.Name;
if (fullInfo)
{
this.Text += ": " + (node.Expression == null ? "<NULL>" : node.Expression.ToString()) + ";";
}
}
}
public MappingContext <TContext> Translate(IParsingTreeNode node, TContext contextObj)
{
var context = new MappingContext <TContext>(this);
context.Context = contextObj;
context.Result = _maps[node.Rule.TokenId].action.DynamicInvoke(node, context);
return(context);
}
public void TraverseFragment(IParsingTreeNode root, IParsingTreeWalkerHandler handler, Location locFrom, Location locTo)
{
if (root == null)
{
throw new ArgumentNullException("Argument 'root' cannot be null!");
}
_stack.Clear();
_stack.Push((ParsingTreeNode.Group)root);
while (_stack.Count > 0)
{
var n = _stack.Count;
var currNode = _stack.Pop();
var g = currNode as ParsingTreeNode.Group;
var t = currNode as ParsingTreeNode.Terminal;
if (g != null)
{
if (g.Location > locTo)
{
continue;
}
_stack.Push(null);
handler.EnterGroup(g);
foreach (ParsingTreeNode.ParsedNode item in g.GetRuleChilds(true))
{
_stack.Push(item);
}
}
else if (t != null)
{
if (t.From > locTo)
{
continue;
}
handler.Terminal(t);
if (t.To < locFrom)
{
return;
}
}
else if (currNode == null)
{
handler.ExitGroup();
}
else
{
throw new NotImplementedException("");
}
}
}
private void PrintNode(IParsingTreeNode node)
{
for (int i = 0; i < _i; i++)
{
_sb.Append(_s);
}
_sb.Append(node.GetType().Name);
_sb.AppendFormat(" @{0} {1} ", (node as ParsingTreeNode).Location, node.Rule);
_sb.AppendLine(((ParsingTreeNode)node).GrammarNode.ToString());
}
static IEnumerable <IParsingTreeNode <T> > GetChildren <T>(this IParsingTreeNode <T> node)
{
var child = node.Child;
while (child != null)
{
yield return(child);
child = child.NextChild;
}
}
private void SetTrees(IParsingTreeNode root, ISourceTextReader textReader)
{
Func <IParsingTreeGroup, ParsingTreeNodeInfo, IEnumerable <ParsingTreeNodeInfo> > childsAccessor = null;
childsAccessor = (n, p) => n.Childs.Select(nc => new ParsingTreeNodeInfo(nc, textReader, childsAccessor, true, p)).ToArray();
this.FullTree = new ParsingTreeNodeInfo(root, textReader, childsAccessor, true);
Func <IParsingTreeGroup, ParsingTreeNodeInfo, IEnumerable <ParsingTreeNodeInfo> > filteredChildsAccessor = null;
filteredChildsAccessor = (n, p) => n.GetRuleChilds().Select(nc => new ParsingTreeNodeInfo(nc, textReader, filteredChildsAccessor, false, p)).ToArray();
this.FilteredTree = new ParsingTreeNodeInfo(root, textReader, filteredChildsAccessor, false);
}
public TemporaryReparsingGroup(IParsingTreeNode oldNode, ParserNode node, Location fromLoc, Location toLoc, TemporaryGroup parent, TemporaryChildNode child)
: base(node, oldNode.Location, parent, child)
{
this.OldGroup = oldNode as IParsingTreeGroup;
this.ReparsingFrom = fromLoc;
this.ReparsingTo = toLoc;
if (this.OldGroup == null)
{
throw new ReparsingFailException();
}
}
public static string GetContent(this IParsingTreeNode node, ISourceTextReader reader)
{
var from = node.GetFromLocation();
if (from.HasValue)
{
var to = node.GetToLocation();
return(reader.GetText(from.Value, to.Value));
}
else
{
return(string.Empty);
}
}
internal static IParsingTreeNode[] GetRuleChildsArray(this IParsingTreeNode node)
{
if (node is IParsingTreeTerminal)
{
throw new InvalidOperationException();
}
var g = node as IParsingTreeGroup;
if (g == null)
{
throw new InvalidOperationException();
}
return(g.GetRuleChilds().ToArray());
}
public static IEnumerable <IParsingTreeNode> EnumerateRuleChilds(this IParsingTreeNode node, bool disableExpanding = false, bool skipOmitFragments = true)
{
if (node is IParsingTreeTerminal)
{
throw new InvalidOperationException();
}
var g = node as IParsingTreeGroup;
if (g == null)
{
throw new InvalidOperationException();
}
return(g.GetRuleChilds(disableExpanding, skipOmitFragments));
}
public static TemporaryGroup CreateRootGroup(IParsingTreeNode oldNode, ParserNode omitPatternRoot, Location locFrom, Location locTo, out ParserNode prevGrammarNode, out bool insideOmittedFragment)
{
insideOmittedFragment = false;
var oldGroup = oldNode as IParsingTreeGroup;
if (oldGroup == null || oldGroup.Location > locFrom)
{
throw new InvalidOperationException();
}
prevGrammarNode = null;
var newGroup = new TemporaryReparsingGroup(oldNode, (oldNode as ParsingTreeNode).GrammarNode, locFrom, locTo, null, null);
var newGroupChild = CreateItemToReparse(oldGroup, newGroup, locFrom, locTo);
int depth = 0;
while (newGroupChild != null)
{
if (newGroupChild.GrammarNode == omitPatternRoot)
{
insideOmittedFragment = true;
}
prevGrammarNode = newGroup.GrammarNode;
oldGroup = newGroupChild.OldGroup;
newGroup = newGroupChild;
newGroupChild = CreateItemToReparse(oldGroup, newGroup, locFrom, locTo);
depth++;
}
// TODO: [Portable.Parser.Impl.ParsingTreeNode.CreateRootGroup] to think about possible parsing directions when reparsing
//var lastTakenChild = newGroup.Childs.LastOrDefault();
//if (lastTakenChild != null)
// prevGrammarNode = ((ParsingTreeNode)lastTakenChild).GrammarNode;
prevGrammarNode = newGroup.Parent.GrammarNode;
return(newGroup);
}
static Location?GetFromLocation(this IParsingTreeNode node)
{
var t = FirstTerminalSearcher.FindFirstTerminal(node);
return(t == null ? null : (Location?)t.From);
}
public FinalNode(T info, FinalNode child, FinalNode nextChild)
: base(info)
{
this.Child = child;
this.NextChild = nextChild;
}
static Location?GetToLocation(this IParsingTreeNode node)
{
var t = LastTerminalSearcher.FindLastTerminal(node);
return(t == null ? null : (Location?)t.To);
}
//public static ParserTreeState ForStart(ParserNode root, ISourceTextReader reader, bool enableLog)
//{
// IndentedWriter w;
// if (enableLog)
// {
// w = new IndentedWriter(" ");
// w.Push().WriteLine("Start @{0} {1}", reader.GetPosition(), root).Push();
// }
// else
// {
// w = null;
// }
// if (root.Parent != null)
// throw new ArgumentException();
// return new ParserTreeState(
// w,
// null,
// ParsingTreeNode.CreateRootGroup(root, reader.Location),
// null,
// reader
// );
//}
public static ParserState <Result> ForStart(ParserNode grammarRoot, ParserNode omitRoot, ISourceTextReader reader, IParsingTreeNode oldRoot, Location limit, bool enableLog)
{
IndentedWriter w;
if (enableLog)
{
w = new IndentedWriter(" ");
if (oldRoot != null)
{
w.WriteLine("Incrementally");
}
w.Push().WriteLine("Start @{0} {1}", reader.GetPosition(), grammarRoot).Push();
}
else
{
w = null;
}
if (oldRoot != null)
{
ParserNode prevGrammarNode = null;
bool insideOmittedFragment;
var treeNode = ParsingTreeNode.CreateRootGroup(oldRoot, omitRoot, reader.Location, limit, out prevGrammarNode, out insideOmittedFragment);
if (!reader.MoveTo(treeNode.Location))
{
throw new NotImplementedException("");
}
if (w != null)
{
w.WriteLine("Reconstructing log indentation...");
var t = treeNode;
var path = new List <ParsingTreeNode.TemporaryGroup>();
while (t != null)
{
path.Add(t);
t = t.Parent;
}
path.Reverse();
for (int i = 0; i < path.Count - 1; i++)
{
w.Push().WriteLine("EnterNode @{2} {0} --> {1}", path[i].GrammarNode, path[i + 1].GrammarNode, path[i].Location).Push();
if (path[i].GrammarNode is ParserNode.RecursiveParserNode)
{
w.WriteLine("Enter to recursion");
}
}
w.WriteLine("...Identation reconstructed.");
}
ParserState <Result> state = new ParserTreeState(
w,
prevGrammarNode,
treeNode,
null,
reader
);
state.InsideOmittedFragment = insideOmittedFragment;
if (state.LastTerminalFailed == false)
{
state = state.ExitNode();
}
else
{
System.Diagnostics.Debug.Print(string.Empty);
}
return(state);
}
else
{
return(new ParserTreeState(
w,
null,
ParsingTreeNode.CreateRootGroup(grammarRoot, reader.Location),
null,
reader
));
}
}
public T Map <T>(IParsingTreeNode node)
{
return(_mapping.GetMap <T>(node.Rule)(node, this));
}
