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