|
public static GrammarWarning ( int msgID, |
||
| msgID | int | |
| g | ||
| token | Antlr.Runtime.IToken | |
| return | void | |
/** 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);
}
/** If ref to undefined rule, give error at first occurrence.
*
* Give error if you cannot find the scope override on a rule reference.
*
* If you ref ID in a combined grammar and don't define ID as a lexer rule
* it is an error.
*/
protected virtual void LookForReferencesToUndefinedSymbols()
{
// for each rule ref, ask if there is a rule definition
foreach (GrammarAST refAST in grammar.ruleRefs)
{
IToken tok = refAST.Token;
string ruleName = tok.Text;
Rule localRule = grammar.GetLocallyDefinedRule(ruleName);
Rule rule = grammar.GetRule(ruleName);
if (localRule == null && rule != null)
{ // imported rule?
grammar.delegatedRuleReferences.Add(rule);
rule.Imported = true;
}
if (rule == null && grammar.GetTokenType(ruleName) != Label.EOF)
{
ErrorManager.GrammarError(ErrorManager.MSG_UNDEFINED_RULE_REF,
grammar,
tok,
ruleName);
}
}
if (grammar.type == GrammarType.Combined)
{
// if we're a combined grammar, we know which token IDs have no
// associated lexer rule.
foreach (IToken tok in grammar.tokenIDRefs)
{
string tokenID = tok.Text;
if (!grammar.composite.LexerRules.Contains(tokenID) &&
grammar.GetTokenType(tokenID) != Label.EOF)
{
ErrorManager.GrammarWarning(ErrorManager.MSG_NO_TOKEN_DEFINITION,
grammar,
tok,
tokenID);
}
}
}
// check scopes and scoped rule refs
foreach (GrammarAST scopeAST in grammar.scopedRuleRefs)
{
// ^(DOT ID atom)
Grammar scopeG = grammar.composite.GetGrammar(scopeAST.Text);
GrammarAST refAST = (GrammarAST)scopeAST.GetChild(1);
string ruleName = refAST.Text;
if (scopeG == null)
{
ErrorManager.GrammarError(ErrorManager.MSG_NO_SUCH_GRAMMAR_SCOPE,
grammar,
scopeAST.Token,
scopeAST.Text,
ruleName);
}
else
{
Rule rule = grammar.GetRule(scopeG.name, ruleName);
if (rule == null)
{
ErrorManager.GrammarError(ErrorManager.MSG_NO_SUCH_RULE_IN_SCOPE,
grammar,
scopeAST.Token,
scopeAST.Text,
ruleName);
}
}
}
}
