public void StripLeftRecursion(GrammarAST altAST)
{
GrammarAST rref = (GrammarAST)altAST.GetChild(0);
if (rref.Type == ANTLRParser.RULE_REF && rref.Text.Equals(ruleName))
{
// remove rule ref
altAST.DeleteChild(0);
// reset index so it prints properly
GrammarAST newFirstChild = (GrammarAST)altAST.GetChild(0);
altAST.TokenStartIndex = newFirstChild.TokenStartIndex;
}
}
private static IEnumerable <GrammarAST> GetChildrenForDupTree(GrammarAST t)
{
bool isAlt = t.Type == ANTLRParser.ALT;
int count = 0;
for (int i = 0; i < t.ChildCount; i++)
{
GrammarAST child = (GrammarAST)t.GetChild(i);
int ttype = child.Type;
if (ttype == ANTLRParser.REWRITES || ttype == ANTLRParser.ACTION)
{
continue;
}
else if (ttype == ANTLRParser.BANG || ttype == ANTLRParser.ROOT)
{
foreach (GrammarAST subchild in GetChildrenForDupTree(child))
{
count++;
yield return(subchild);
}
}
else
{
if (isAlt && child.Type == ANTLRParser.EOA && count == 0)
{
yield return(new GrammarAST(ANTLRParser.EPSILON, "epsilon"));
}
count++;
yield return(child);
}
}
}
public void StripSynPred(GrammarAST altAST)
{
GrammarAST t = (GrammarAST)altAST.GetChild(0);
if (t.Type == ANTLRParser.BACKTRACK_SEMPRED ||
t.Type == ANTLRParser.SYNPRED ||
t.Type == ANTLRParser.SYN_SEMPRED)
{
altAST.DeleteChild(0);
}
}
public int CountAltsForBlock(GrammarAST t)
{
int n = 0;
for ( int i = 0; i < t.ChildCount; i++ )
{
if ( t.GetChild( i ).Type == ALT )
n++;
}
return n;
}
protected override void TrackTokenRule(GrammarAST t,
GrammarAST modifier,
GrammarAST block)
{
// imported token names might exist, only add if new
if (grammar.type == GrammarType.Lexer || grammar.type == GrammarType.Combined)
{
if (Rule.GetRuleType(t.Text) == RuleType.Parser)
{
return;
}
if (t.Text.Equals(Grammar.ArtificialTokensRuleName))
{
// don't add Tokens rule
return;
}
// track all lexer rules so we can look for token refs w/o
// associated lexer rules.
grammar.composite.lexerRules.Add(t.Text);
int existing = grammar.GetTokenType(t.Text);
if (existing == Label.INVALID)
{
tokens[t.Text] = Unassigned;
}
// look for "<TOKEN> : <literal> ;" pattern
// (can have optional action last)
if (block.HasSameTreeStructure(charAlias) ||
block.HasSameTreeStructure(stringAlias) ||
block.HasSameTreeStructure(charAlias2) ||
block.HasSameTreeStructure(stringAlias2))
{
tokenRuleDefs.Add(t.Text);
/*
* Grammar parent = grammar.composite.getDelegator(grammar);
* boolean importedByParserOrCombined =
* parent!=null &&
* (parent.type==GrammarType.Lexer||parent.type==GrammarType.Parser);
*/
if (grammar.type == GrammarType.Combined || grammar.type == GrammarType.Lexer)
{
// only call this rule an alias if combined or lexer
Alias(t, (GrammarAST)block.GetChild(0).GetChild(0));
}
}
}
// else error
}
/** Track which rules have rewrite rules. Pass in the ALT node
* for the alt so we can check for problems when output=template,
* rewrite=true, and grammar type is tree parser.
*/
public virtual void TrackAltsWithRewrites(GrammarAST altAST, int outerAltNum)
{
if (grammar.type == GrammarType.TreeParser &&
grammar.BuildTemplate &&
grammar.GetOption("rewrite") != null &&
grammar.GetOption("rewrite").Equals("true")
)
{
GrammarAST firstElementAST = (GrammarAST)altAST.GetChild(0);
grammar.sanity.EnsureAltIsSimpleNodeOrTree(altAST,
firstElementAST,
outerAltNum);
}
altsWithRewrites[outerAltNum] = true;
}
public static GrammarAST DupTree(GrammarAST t)
{
if (t == null)
{
return(null);
}
// make copy of root
GrammarAST root = Dup(t);
// copy all children of root.
for (int i = 0; i < t.ChildCount; i++)
{
GrammarAST child = (GrammarAST)t.GetChild(i);
root.AddChild(DupTree(child));
}
return(root);
}
/** Rules in tree grammar that use -> rewrites and are spitting out
* templates via output=template and then use rewrite=true must only
* use -> on alts that are simple nodes or trees or single rule refs
* that match either nodes or trees. The altAST is the ALT node
* for an ALT. Verify that its first child is simple. Must be either
* ( ALT ^( A B ) <end-of-alt> ) or ( ALT A <end-of-alt> ) or
* other element.
*
* Ignore predicates in front and labels.
*/
public virtual void EnsureAltIsSimpleNodeOrTree(GrammarAST altAST,
GrammarAST elementAST,
int outerAltNum)
{
if (IsValidSimpleElementNode(elementAST))
{
GrammarAST next = (GrammarAST)elementAST.Parent.GetChild(elementAST.ChildIndex + 1);
if (!IsNextNonActionElementEOA(next))
{
ErrorManager.GrammarWarning(ErrorManager.MSG_REWRITE_FOR_MULTI_ELEMENT_ALT,
grammar,
next.Token,
outerAltNum);
}
return;
}
switch (elementAST.Type)
{
case ANTLRParser.ASSIGN: // labels ok on non-rule refs
case ANTLRParser.PLUS_ASSIGN:
if (IsValidSimpleElementNode((GrammarAST)elementAST.GetChild(1)))
{
return;
}
break;
case ANTLRParser.ACTION: // skip past actions
case ANTLRParser.SEMPRED:
case ANTLRParser.SYN_SEMPRED:
case ANTLRParser.BACKTRACK_SEMPRED:
case ANTLRParser.GATED_SEMPRED:
EnsureAltIsSimpleNodeOrTree(altAST,
(GrammarAST)elementAST.Parent.GetChild(elementAST.ChildIndex + 1),
outerAltNum);
return;
}
ErrorManager.GrammarWarning(ErrorManager.MSG_REWRITE_FOR_MULTI_ELEMENT_ALT,
grammar,
elementAST.Token,
outerAltNum);
}
static IEnumerable <GrammarAST> GetChildrenForDupTree(GrammarAST t)
{
for (int i = 0; i < t.ChildCount; i++)
{
GrammarAST child = (GrammarAST)t.GetChild(i);
int ttype = child.Type;
if (ttype == ANTLRParser.REWRITE)
{
continue;
}
else if (ttype == ANTLRParser.BANG || ttype == ANTLRParser.ROOT)
{
foreach (GrammarAST subchild in GetChildrenForDupTree(child))
{
yield return(subchild);
}
}
else
{
yield return(child);
}
}
}
public void StripLeftRecursion(GrammarAST altAST)
{
GrammarAST rref = (GrammarAST)altAST.GetChild(0);
if (rref.Type == ANTLRParser.RULE_REF && rref.Text.Equals(ruleName))
{
// remove rule ref
altAST.DeleteChild(0);
// reset index so it prints properly
GrammarAST newFirstChild = (GrammarAST)altAST.GetChild(0);
altAST.TokenStartIndex = newFirstChild.TokenStartIndex;
}
}
public void StripSynPred(GrammarAST altAST)
{
GrammarAST t = (GrammarAST)altAST.GetChild(0);
if (t.Type == ANTLRParser.BACKTRACK_SEMPRED ||
t.Type == ANTLRParser.SYNPRED ||
t.Type == ANTLRParser.SYN_SEMPRED)
{
altAST.DeleteChild(0);
}
}
/** Rules in tree grammar that use -> rewrites and are spitting out
* templates via output=template and then use rewrite=true must only
* use -> on alts that are simple nodes or trees or single rule refs
* that match either nodes or trees. The altAST is the ALT node
* for an ALT. Verify that its first child is simple. Must be either
* ( ALT ^( A B ) <end-of-alt> ) or ( ALT A <end-of-alt> ) or
* other element.
*
* Ignore predicates in front and labels.
*/
public virtual void EnsureAltIsSimpleNodeOrTree( GrammarAST altAST,
GrammarAST elementAST,
int outerAltNum )
{
if ( IsValidSimpleElementNode( elementAST ) )
{
GrammarAST next = (GrammarAST)elementAST.getNextSibling();
if ( !IsNextNonActionElementEOA( next ) )
{
ErrorManager.GrammarWarning( ErrorManager.MSG_REWRITE_FOR_MULTI_ELEMENT_ALT,
grammar,
next.Token,
outerAltNum );
}
return;
}
switch ( elementAST.Type )
{
case ANTLRParser.ASSIGN: // labels ok on non-rule refs
case ANTLRParser.PLUS_ASSIGN:
if ( IsValidSimpleElementNode( (GrammarAST)elementAST.GetChild( 1 ) ) )
{
return;
}
break;
case ANTLRParser.ACTION: // skip past actions
case ANTLRParser.SEMPRED:
case ANTLRParser.SYN_SEMPRED:
case ANTLRParser.BACKTRACK_SEMPRED:
case ANTLRParser.GATED_SEMPRED:
EnsureAltIsSimpleNodeOrTree( altAST,
(GrammarAST)elementAST.getNextSibling(),
outerAltNum );
return;
}
ErrorManager.GrammarWarning( ErrorManager.MSG_REWRITE_FOR_MULTI_ELEMENT_ALT,
grammar,
elementAST.Token,
outerAltNum );
}
protected override void TrackTokenRule( GrammarAST t,
GrammarAST modifier,
GrammarAST block )
{
// imported token names might exist, only add if new
if ( grammar.type == GrammarType.Lexer || grammar.type == GrammarType.Combined )
{
if (Rule.GetRuleType(t.Text) == RuleType.Parser)
{
return;
}
if ( t.Text.Equals( Grammar.ArtificialTokensRuleName ) )
{
// don't add Tokens rule
return;
}
// track all lexer rules so we can look for token refs w/o
// associated lexer rules.
grammar.composite.LexerRules.Add( t.Text );
int existing = grammar.GetTokenType( t.Text );
if ( existing == Label.INVALID )
{
_tokens[t.Text] = Unassigned;
}
// look for "<TOKEN> : <literal> ;" pattern
// (can have optional action last)
if ( block.HasSameTreeStructure( charAlias ) ||
block.HasSameTreeStructure( stringAlias ) ||
block.HasSameTreeStructure( charAlias2 ) ||
block.HasSameTreeStructure( stringAlias2 ) )
{
tokenRuleDefs.Add( t.Text );
/*
Grammar parent = grammar.composite.getDelegator(grammar);
boolean importedByParserOrCombined =
parent!=null &&
(parent.type==GrammarType.Lexer||parent.type==GrammarType.Parser);
*/
if ( grammar.type == GrammarType.Combined || grammar.type == GrammarType.Lexer )
{
// only call this rule an alias if combined or lexer
Alias( t, (GrammarAST)block.GetChild( 0 ).GetChild( 0 ) );
}
}
}
// else error
}
private void HandleDotLoop(GrammarAST start)
{
GrammarAST block = (GrammarAST)start.GetChild(0);
IDictionary<string, object> opts = new Dictionary<string, object>();
opts["greedy"] = "false";
if (grammar.type != GrammarType.Lexer)
{
// parser grammars assume k=1 for .* loops otherwise they (analysis?) look til EOF!
opts["k"] = 1;
}
block.SetOptions(grammar, opts);
}
private void HandleElementPlusAssign(GrammarAST id, GrammarAST elementStart)
{
if (elementStart.Type == ANTLRParser.ROOT || elementStart.Type == ANTLRParser.BANG)
{
elementStart = (GrammarAST)elementStart.GetChild(0);
}
if (elementStart.Type == RULE_REF)
{
grammar.DefineRuleListLabel(currentRuleName, id.Token, elementStart);
}
else if (elementStart.Type == WILDCARD && grammar.type == GrammarType.TreeParser)
{
grammar.DefineWildcardTreeListLabel(currentRuleName, id.Token, elementStart);
}
else
{
grammar.DefineTokenListLabel(currentRuleName, id.Token, elementStart);
}
}
public void AddRule(GrammarAST grammarTree, GrammarAST t)
{
GrammarAST p = null;
for (int i = 0; i < grammarTree.ChildCount; i++)
{
p = (GrammarAST)grammarTree.GetChild(i);
if (p == null || p.Type == ANTLRParser.RULE || p.Type == ANTLRParser.PREC_RULE)
break;
}
if (p != null)
grammarTree.AddChild(t);
}
/** Track which rules have rewrite rules. Pass in the ALT node
* for the alt so we can check for problems when output=template,
* rewrite=true, and grammar type is tree parser.
*/
public virtual void TrackAltsWithRewrites( GrammarAST altAST, int outerAltNum )
{
if ( grammar.type == GrammarType.TreeParser &&
grammar.BuildTemplate &&
grammar.GetOption( "rewrite" ) != null &&
grammar.GetOption( "rewrite" ).Equals( "true" )
)
{
GrammarAST firstElementAST = (GrammarAST)altAST.GetChild( 0 );
grammar.sanity.EnsureAltIsSimpleNodeOrTree( altAST,
firstElementAST,
outerAltNum );
}
altsWithRewrites[outerAltNum] = true;
}
static IEnumerable<GrammarAST> GetChildrenForDupTree( GrammarAST t )
{
for ( int i = 0; i < t.ChildCount; i++ )
{
GrammarAST child = (GrammarAST)t.GetChild( i );
int ttype = child.Type;
if ( ttype == ANTLRParser.REWRITE )
{
continue;
}
else if ( ttype == ANTLRParser.BANG || ttype == ANTLRParser.ROOT )
{
foreach ( GrammarAST subchild in GetChildrenForDupTree( child ) )
yield return subchild;
}
else
{
yield return child;
}
}
}
