public string DecorateTree(ail.net.parser.AstNode xi_ast_node)
{
ail.net.framework.Assert.NonNullReference(xi_ast_node, "xi_ast_node");
StringBuilder result = DecorateTreeVisitor(0, xi_ast_node);
return(result.ToString());
}
public override ail.net.parser.AstNode HandleNonTerminalBefore(ail.net.parser.AstNode xi_node, object xi_item)
{
ail.net.parser.AstNode result = null;
return(result);
}
// S -> b A
// A -> a A B
// A -> e(psilon)
// B -> e(psilon)
// ..............
// baa
public static void Test()
{
// fsa
// ail.net.test.GlrAlwaysBrokenLexAnalyzer.GenerateCode(@"c:\tmp\GlrAlwaysBroken.fsa.txt");
// grammar
ail.net.test.GlrAlwaysBrokenGrammar grammar = new ail.net.test.GlrAlwaysBrokenGrammar();
grammar.Populate();
Console.WriteLine(grammar.Decorate());
// parser
ArrayList errors = new ArrayList();
ail.net.test.GlrAlwaysBrokenLexAnalyzer lexer = new ail.net.test.GlrAlwaysBrokenLexAnalyzer(new ail.net.test.GlrAlwaysBrokenToken(), errors);
lexer.Load("baa", ail.net.parser.Context.ELoadMedia.eMediaString);
ail.net.test.GlrAlwaysBrokenEarleyParser parser = new ail.net.test.GlrAlwaysBrokenEarleyParser(lexer, grammar, errors);
parser.Semantics = new ail.net.test.GlrAlwaysBrokenSemantics(lexer, errors);
ail.net.parser.AstNode ast = parser.Parse();
if (ast != (object)null)
{
Console.WriteLine(parser.DecorateTree(ast));
}
}
private ail.net.parser.AstNode BuildAst()
{
ail.net.framework.Assert.Condition(Charts.Count > 0, "ail.net.parser.EareyParser.BuildAst: Charts.Count > 0");
ail.net.parser.AstNode result = null;
foreach (ail.net.parser.EarleyParser.Item start_item in ((ail.net.parser.EarleyParser.Chart)Charts[Charts.Count - 1]).Items.Values)
{
if (IsRecognizedItem(start_item))
{
result = Semantics.Start(start_item);
if (result != (object)null)
{
start_item.Flags |= (uint)ail.net.parser.EarleyParser.EFlags.eMarked;
BuildAstLevel(start_item, result);
start_item.Flags &= ~(uint)ail.net.parser.EarleyParser.EFlags.eMarked;
break;
}
}
}
ail.net.framework.Assert.NonNullReference(result, "result");
Status = ail.net.parser.Parser.EStatus.eParsed;
return(result);
}
public StringBuilder DecorateTreeVisitor(int xi_level, ail.net.parser.AstNode xi_ast_node)
{
ail.net.framework.Assert.NonNullReference(xi_ast_node, "xi_ast_node");
StringBuilder result = new StringBuilder();
for (ail.net.parser.AstNode node = xi_ast_node; node != (object)null; node = node.Brother)
{
ail.net.parser.GrammarSymbol symbol = (ail.net.parser.GrammarSymbol)GrammarPool.Instance.Pool[(int)node.Token.Type];
if (symbol != (object)null)
{
for (int i = 0; i < xi_level; i++)
{
result.Append(" ");
}
result.Append(symbol.Name);
result.Append(Environment.NewLine);
}
if (node.Child != (object)null)
{
result.Append(DecorateTreeVisitor(xi_level + 1, node.Child));
}
}
return(result);
}
private ail.net.parser.AstNode LastChildAttr; // last child
#endregion // data members
#region ctor/dtor/finalizer
public AstNode(int xi_type)
{
TypeAttr = xi_type;
TokenAttr = null;
ParentAttr = null;
BrotherAttr = null;
ChildAttr = null;
LastChild = null;
}
public override void HandleTerminal(ail.net.parser.AstNode xi_node, ail.net.parser.Token xi_token)
{
if (xi_token.Type == (int)ail.net.test.SssToken.EType.eN)
{
xi_node.Type = (int)ail.net.test.SssAstNode.EType.eSn;
xi_node.Token = xi_token;
}
else if (xi_token.Type == (int)ail.net.test.SssToken.EType.ePlus)
{
xi_node.Type = (int)ail.net.test.SssAstNode.EType.eSp;
xi_node.Token = xi_token;
}
}
public ail.net.parser.AstNode Parse()
{
ail.net.framework.Assert.NonNullReference(Semantics, "Semantics");
ail.net.parser.AstNode result = null;
if (BuildChartList())
{
if (ParserMode == ail.net.parser.EarleyParser.EParserMode.eParser)
{
result = BuildAst();
}
}
return(result);
}
public override ail.net.parser.AstNode Start(object xi_item)
{
ail.net.parser.AstNode result = null;
if (((ail.net.parser.EarleyParser.Item)xi_item).CoreItem.Rule.Id == (int)ail.net.test.SssGrammar.EGrammar.eSSS)
{
result = new ail.net.test.SssAstNode((int)ail.net.test.SssAstNode.EType.eSSpS);
result.Token = (ail.net.test.SssToken)((ail.net.parser.EarleyParser.Item)xi_item).MasterChart.Token.Clone();
}
else if (((ail.net.parser.EarleyParser.Item)xi_item).CoreItem.Rule.Id == (int)ail.net.test.SssGrammar.EGrammar.eSS)
{
//?? result = new ail.net.test.SssAstNode((int)ail.net.test.SssAstNode.EType.eSS);
}
return(result);
}
public void AddNode(ail.net.parser.AstNode xi_new_node)
{
// add new node to the level as child
ail.net.framework.Assert.NonNullReference(xi_new_node, "xi_new_node");
if (LastChild != (object)null)
{
LastChild.Brother = xi_new_node;
}
else
{
Child = xi_new_node;
}
LastChild = xi_new_node;
xi_new_node.Parent = this;
}
public override ail.net.parser.AstNode HandleNonTerminalBefore(ail.net.parser.AstNode xi_node, object xi_item)
{
ail.net.parser.AstNode result = null;
if (((ail.net.parser.EarleyParser.Item)xi_item).CoreItem.Rule.Id == (int)ail.net.test.SssGrammar.EGrammar.eSSS)
{
result = new ail.net.test.SssAstNode((int)ail.net.test.SssAstNode.EType.eSn);
xi_node.AddNode(result);
}
else if (((ail.net.parser.EarleyParser.Item)xi_item).CoreItem.Rule.Id == (int)ail.net.test.SssGrammar.EGrammar.eSS)
{
result = xi_node;
}
else if (((ail.net.parser.EarleyParser.Item)xi_item).CoreItem.Rule.Id == (int)ail.net.test.SssGrammar.EGrammar.eSn)
{
result = new ail.net.test.SssAstNode((int)ail.net.test.SssAstNode.EType.eSn);
xi_node.AddNode(result);
}
return(result);
}
public override ail.net.parser.AstNode HandleNonTerminalAfter(ail.net.parser.AstNode xi_node, object xi_item)
{
return(null);
}
public override void HandleTerminal(ail.net.parser.AstNode xi_node, ail.net.parser.Token xi_token)
{
}
public override ail.net.parser.AstNode Start(object xi_item)
{
ail.net.parser.AstNode result = null;
return(result);
}
private void BuildAstLevel(ail.net.parser.EarleyParser.Item xi_item, ail.net.parser.AstNode xi_root_node)
{
ail.net.framework.Assert.NonNullReference(xi_item, "xi_item");
ail.net.framework.Assert.NonNullReference(xi_root_node, "xi_root_node");
// populate a rhs stack with items of the current level
Stack rhs_stack = new Stack();
PopulateRhsStack(rhs_stack, xi_item);
// processing all nodes(items) of the level
while (rhs_stack.Count > 0)
{
ail.net.parser.EarleyParser.Item curr_item = (ail.net.parser.EarleyParser.Item)rhs_stack.Pop();
ail.net.parser.GrammarSymbol symbol = (ail.net.parser.GrammarSymbol)curr_item.CoreItem.Rule.Rhs[curr_item.CoreItem.Dot - 1]; // 'dot-1', because we pushed items with 'dot' > 0
if (symbol.IsTerminal())
{
// handle terminal
Semantics.HandleTerminal(xi_root_node, curr_item.MasterChart.Token);
}
else if (symbol.IsNonTerminal())
{
// handle non-terminal
if (curr_item.Rptrs.Count <= 1)
{
// r-ptr has exactly one element
ail.net.framework.Assert.Condition(curr_item.Rptrs.Count == 1,
"ail.net.parser.EarleyParser.BuildAstLevel: curr_item.Rptrs.Count == 1");
ail.net.parser.EarleyParser.Item r_ptr_item = (ail.net.parser.EarleyParser.Item)curr_item.Rptrs[0];
ail.net.parser.AstNode new_node = Semantics.HandleNonTerminalBefore(xi_root_node, r_ptr_item);
if (new_node != (object)null)
{
r_ptr_item.Flags |= (uint)ail.net.parser.EarleyParser.EFlags.eMarked;
BuildAstLevel(r_ptr_item, new_node);
r_ptr_item.Flags &= ~(uint)ail.net.parser.EarleyParser.EFlags.eMarked;
}
Semantics.HandleNonTerminalAfter(xi_root_node, r_ptr_item);
}
else
{
// r-ptr has more than one elements, ambiguity
foreach (ail.net.parser.EarleyParser.Item r_ptr_item in curr_item.Rptrs.Values)
{
if ((r_ptr_item.Flags & (uint)ail.net.parser.EarleyParser.EFlags.eMarked) == 0)
{
ail.net.parser.AstNode new_node = Semantics.HandleNonTerminalBefore(xi_root_node, r_ptr_item);
if (new_node != (object)null)
{
r_ptr_item.Flags |= (uint)ail.net.parser.EarleyParser.EFlags.eMarked;
BuildAstLevel(r_ptr_item, new_node);
r_ptr_item.Flags &= ~(uint)ail.net.parser.EarleyParser.EFlags.eMarked;
Semantics.HandleNonTerminalAfter(xi_root_node, r_ptr_item);
break;
}
}
}
}
}
}
}
// terminal action public abstract void HandleTerminal(ail.net.parser.AstNode xi_node, ail.net.parser.Token xi_token);
public abstract ail.net.parser.AstNode HandleNonTerminalAfter(ail.net.parser.AstNode xi_node, object xi_item);
