|
public static GrammarError ( int msgID, |
||
| msgID | int | |
| g | ||
| token | Antlr.Runtime.IToken | |
| return | void | |
public virtual string SetOption(IDictionary <string, object> options, HashSet <string> legalOptions, Grammar grammar, string key, object value)
{
if (!legalOptions.Contains(key))
{
ErrorManager.GrammarError(ErrorManager.MSG_ILLEGAL_OPTION,
grammar,
Token,
key);
return(null);
}
if (value is string)
{
string vs = (string)value;
if (vs[0] == '"')
{
value = vs.Substring(1, vs.Length - 2); // strip quotes
}
}
if (key.Equals("k"))
{
grammar.numberOfManualLookaheadOptions++;
}
if (key == "backtrack" && value.ToString() == "true")
{
grammar.composite.RootGrammar.atLeastOneBacktrackOption = true;
}
options[key] = value;
return(key);
}
/** Save the option key/value pair and process it; return the key
* or null if invalid option.
*/
public virtual string SetOption(string key, object value, IToken optionsStartToken)
{
if (!legalOptions.Contains(key))
{
ErrorManager.GrammarError(ErrorManager.MSG_ILLEGAL_OPTION,
Grammar,
optionsStartToken,
key);
return(null);
}
if (Options == null)
{
Options = new Dictionary <object, object>();
}
if (key.Equals("memoize") && value.ToString().Equals("true"))
{
Grammar.composite.RootGrammar.atLeastOneRuleMemoizes = true;
}
if (key == "backtrack" && value.ToString() == "true")
{
Grammar.composite.RootGrammar.atLeastOneBacktrackOption = true;
}
if (key.Equals("k"))
{
Grammar.numberOfManualLookaheadOptions++;
}
Options[key] = value;
return(key);
}
/** Make sure a label doesn't conflict with another symbol.
* Labels must not conflict with: rules, tokens, scope names,
* return values, parameters, and rule-scope dynamic attributes
* defined in surrounding rule.
*/
protected virtual void CheckForLabelConflict(Rule r, IToken label)
{
int msgID = 0;
object arg2 = null;
if (grammar.GetGlobalScope(label.Text) != null)
{
msgID = ErrorManager.MSG_SYMBOL_CONFLICTS_WITH_GLOBAL_SCOPE;
}
else if (grammar.GetRule(label.Text) != null)
{
msgID = ErrorManager.MSG_LABEL_CONFLICTS_WITH_RULE;
}
else if (grammar.GetTokenType(label.Text) != Label.INVALID)
{
msgID = ErrorManager.MSG_LABEL_CONFLICTS_WITH_TOKEN;
}
else if (r.RuleScope != null && r.RuleScope.GetAttribute(label.Text) != null)
{
msgID = ErrorManager.MSG_LABEL_CONFLICTS_WITH_RULE_SCOPE_ATTRIBUTE;
arg2 = r.Name;
}
else if ((r.ReturnScope != null && r.ReturnScope.GetAttribute(label.Text) != null) ||
(r.ParameterScope != null && r.ParameterScope.GetAttribute(label.Text) != null))
{
msgID = ErrorManager.MSG_LABEL_CONFLICTS_WITH_RULE_ARG_RETVAL;
arg2 = r.Name;
}
if (msgID != 0)
{
ErrorManager.GrammarError(msgID, grammar, label, label.Text, arg2);
}
}
protected virtual void CheckForRuleDefinitionProblems(Rule r)
{
string ruleName = r.Name;
IToken ruleToken = r.Tree.Token;
int msgID = 0;
if ((grammar.type == GrammarType.Parser || grammar.type == GrammarType.TreeParser) &&
Rule.GetRuleType(ruleName) == RuleType.Lexer)
{
msgID = ErrorManager.MSG_LEXER_RULES_NOT_ALLOWED;
}
else if (grammar.type == GrammarType.Lexer &&
Rule.GetRuleType(ruleName) == RuleType.Parser &&
!r.IsSynPred)
{
msgID = ErrorManager.MSG_PARSER_RULES_NOT_ALLOWED;
}
else if (grammar.GetGlobalScope(ruleName) != null)
{
msgID = ErrorManager.MSG_SYMBOL_CONFLICTS_WITH_GLOBAL_SCOPE;
}
if (msgID != 0)
{
ErrorManager.GrammarError(msgID, grammar, ruleToken, ruleName);
}
}
protected virtual void CheckForGlobalScopeTokenConflict(AttributeScope scope)
{
if (grammar.GetTokenType(scope.Name) != Label.INVALID)
{
ErrorManager.GrammarError(ErrorManager.MSG_SYMBOL_CONFLICTS_WITH_GLOBAL_SCOPE,
grammar, null, scope.Name);
}
}
protected override void Alias(GrammarAST t, GrammarAST s)
{
string tokenID = t.Text;
string literal = s.Text;
string prevAliasLiteralID;
_aliasesReverseIndex.TryGetValue(literal, out prevAliasLiteralID);
if (prevAliasLiteralID != null)
{ // we've seen this literal before
if (tokenID.Equals(prevAliasLiteralID))
{
// duplicate but identical alias; might be tokens {A='a'} and
// lexer rule A : 'a' ; Is ok, just return
return;
}
// give error unless both are rules (ok if one is in tokens section)
if (!(tokenRuleDefs.Contains(tokenID) && tokenRuleDefs.Contains(prevAliasLiteralID)))
{
// don't allow alias if A='a' in tokens section and B : 'a'; is rule.
// Allow if both are rules. Will get DFA nondeterminism error later.
ErrorManager.GrammarError(ErrorManager.MSG_TOKEN_ALIAS_CONFLICT,
grammar,
t.Token,
tokenID + "=" + literal,
prevAliasLiteralID);
}
return; // don't do the alias
}
int existingLiteralType = grammar.GetTokenType(literal);
if (existingLiteralType != Label.INVALID)
{
// we've seen this before from a tokenVocab most likely
// don't assign a new token type; use existingLiteralType.
_tokens[tokenID] = existingLiteralType;
}
string prevAliasTokenID;
_aliases.TryGetValue(tokenID, out prevAliasTokenID);
if (prevAliasTokenID != null)
{
ErrorManager.GrammarError(ErrorManager.MSG_TOKEN_ALIAS_REASSIGNMENT,
grammar,
t.Token,
tokenID + "=" + literal,
prevAliasTokenID);
return; // don't do the alias
}
_aliases[tokenID] = literal;
_aliasesReverseIndex[literal] = tokenID;
}
/** Given @scope::name {action} define it for this attribute scope. Later,
* the code generator will ask for the actions table.
*/
public void DefineNamedAction(GrammarAST nameAST, GrammarAST actionAST)
{
string actionName = nameAST.Text;
GrammarAST a;
if (Actions.TryGetValue(actionName, out a) && a != null)
{
ErrorManager.GrammarError(
ErrorManager.MSG_ACTION_REDEFINITION, grammar,
nameAST.Token, nameAST.Text);
}
else
{
Actions[actionName] = actionAST;
}
}
/** Given @scope::name {action} define it for this grammar. Later,
* the code generator will ask for the actions table.
*/
public virtual void DefineNamedAction(GrammarAST ampersandAST,
GrammarAST nameAST,
GrammarAST actionAST)
{
//[email protected]("rule @"+nameAST.getText()+"{"+actionAST.getText()+"}");
string actionName = nameAST.Text;
GrammarAST a = (GrammarAST)actions.get(actionName);
if (a != null)
{
ErrorManager.GrammarError(
ErrorManager.MSG_ACTION_REDEFINITION, grammar,
nameAST.Token, nameAST.Text);
}
else
{
actions[actionName] = actionAST;
}
}
protected virtual void CheckForRuleArgumentAndReturnValueConflicts(Rule r)
{
if (r.ReturnScope != null)
{
HashSet <object> conflictingKeys = r.ReturnScope.Intersection(r.ParameterScope);
if (conflictingKeys != null)
{
foreach (string key in conflictingKeys)
{
ErrorManager.GrammarError(
ErrorManager.MSG_ARG_RETVAL_CONFLICT,
grammar,
r.Tree.Token,
key,
r.Name);
}
}
}
}
/** Check for collision of a rule-scope dynamic attribute with:
* arg, return value, rule name itself. Labels are checked elsewhere.
*/
public virtual void CheckForRuleScopeAttributeConflict(Rule r, Attribute attribute)
{
int msgID = 0;
object arg2 = null;
string attrName = attribute.Name;
if (r.Name.Equals(attrName))
{
msgID = ErrorManager.MSG_ATTRIBUTE_CONFLICTS_WITH_RULE;
arg2 = r.Name;
}
else if ((r.ReturnScope != null && r.ReturnScope.GetAttribute(attrName) != null) ||
(r.ParameterScope != null && r.ParameterScope.GetAttribute(attrName) != null))
{
msgID = ErrorManager.MSG_ATTRIBUTE_CONFLICTS_WITH_RULE_ARG_RETVAL;
arg2 = r.Name;
}
if (msgID != 0)
{
ErrorManager.GrammarError(msgID, grammar, r.Tree.Token, attrName, arg2);
}
}
/** If type of previous label differs from new label's type, that's an error.
*/
public virtual bool CheckForLabelTypeMismatch(Rule r, IToken label, LabelType type)
{
Grammar.LabelElementPair prevLabelPair;
r.LabelNameSpace.TryGetValue(label.Text, out prevLabelPair);
if (prevLabelPair != null)
{
// label already defined; if same type, no problem
if (prevLabelPair.type != type)
{
string typeMismatchExpr =
Grammar.LabelTypeToString[(int)type] + "!=" +
Grammar.LabelTypeToString[(int)prevLabelPair.type];
ErrorManager.GrammarError(
ErrorManager.MSG_LABEL_TYPE_CONFLICT,
grammar,
label,
label.Text,
typeMismatchExpr);
return(true);
}
}
return(false);
}
/** Track string literals (could be in tokens{} section) */
protected override void TrackString(GrammarAST t)
{
// if lexer, don't allow aliasing in tokens section
if (currentRuleName == null && grammar.type == GrammarType.Lexer)
{
ErrorManager.GrammarError(ErrorManager.MSG_CANNOT_ALIAS_TOKENS_IN_LEXER,
grammar,
t.token,
t.Text);
return;
}
// in a plain parser grammar rule, cannot reference literals
// (unless defined previously via tokenVocab option)
// don't warn until we hit root grammar as may be defined there.
if (grammar.IsRoot &&
grammar.type == GrammarType.Parser &&
grammar.GetTokenType(t.Text) == Label.INVALID)
{
ErrorManager.GrammarError(ErrorManager.MSG_LITERAL_NOT_ASSOCIATED_WITH_LEXER_RULE,
grammar,
t.token,
t.Text);
}
// Don't record literals for lexers, they are things to match not tokens
if (grammar.type == GrammarType.Lexer)
{
return;
}
// otherwise add literal to token types if referenced from parser rule
// or in the tokens{} section
if ((currentRuleName == null ||
Rule.GetRuleType(currentRuleName) == RuleType.Parser) &&
grammar.GetTokenType(t.Text) == Label.INVALID)
{
stringLiterals[t.Text] = UnassignedInParserRule;
}
}
/** From a chunk of text holding the definitions of the attributes,
* pull them apart and create an Attribute for each one. Add to
* the list of attributes for this scope. Pass in the character
* that terminates a definition such as ',' or ';'. For example,
*
* scope symbols {
* int n;
* List names;
* }
*
* would pass in definitions equal to the text in between {...} and
* separator=';'. It results in two Attribute objects.
*/
public virtual void AddAttributes(string definitions, int separator)
{
IList <string> attrs = new List <string>();
CodeGenerator.GetListOfArgumentsFromAction(definitions, 0, -1, separator, attrs);
foreach (string a in attrs)
{
Attribute attr = new Attribute(a);
if (!isReturnScope && attr.InitValue != null)
{
ErrorManager.GrammarError(ErrorManager.MSG_ARG_INIT_VALUES_ILLEGAL,
grammar,
derivedFromToken,
attr.Name);
attr.InitValue = null; // wipe it out
}
for (int i = 0; i <= attributes.Count; i++)
{
if (i < attributes.Count)
{
if (attributes[i].Name == attr.Name)
{
attributes[i] = attr;
break;
}
}
else
{
attributes.Add(attr);
// *must* break since the count changed
break;
//attributes.put( attr.Name, attr );
}
}
}
}
public virtual void CheckRuleReference(GrammarAST scopeAST,
GrammarAST refAST,
GrammarAST argsAST,
string currentRuleName)
{
Rule r = grammar.GetRule(refAST.Text);
if (refAST.Type == ANTLRParser.RULE_REF)
{
if (argsAST != null)
{
// rule[args]; ref has args
if (r != null && r.ArgActionAST == null)
{
// but rule def has no args
ErrorManager.GrammarError(
ErrorManager.MSG_RULE_HAS_NO_ARGS,
grammar,
argsAST.Token,
r.Name);
}
}
else
{
// rule ref has no args
if (r != null && r.ArgActionAST != null)
{
// but rule def has args
ErrorManager.GrammarError(
ErrorManager.MSG_MISSING_RULE_ARGS,
grammar,
refAST.Token,
r.Name);
}
}
}
else if (refAST.Type == ANTLRParser.TOKEN_REF)
{
if (grammar.type != GrammarType.Lexer)
{
if (argsAST != null)
{
// args on a token ref not in a lexer rule
ErrorManager.GrammarError(
ErrorManager.MSG_ARGS_ON_TOKEN_REF,
grammar,
refAST.Token,
refAST.Text);
}
return; // ignore token refs in nonlexers
}
if (argsAST != null)
{
// tokenRef[args]; ref has args
if (r != null && r.ArgActionAST == null)
{
// but token rule def has no args
ErrorManager.GrammarError(
ErrorManager.MSG_RULE_HAS_NO_ARGS,
grammar,
argsAST.Token,
r.Name);
}
}
else
{
// token ref has no args
if (r != null && r.ArgActionAST != null)
{
// but token rule def has args
ErrorManager.GrammarError(
ErrorManager.MSG_MISSING_RULE_ARGS,
grammar,
refAST.Token,
r.Name);
}
}
}
}
/** 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);
}
}
}
}
