public LeftRecursiveRuleTransformer(GrammarRootAST ast, ICollection<Rule> rules, Grammar g)
{
this.ast = ast;
this.rules = rules;
this.g = g;
this.tool = g.tool;
}
public LabelElementPair(Grammar g, GrammarAST label, GrammarAST element, int labelOp)
{
this.label = label;
this.element = element;
// compute general case for label type
if (element.GetFirstDescendantWithType(tokenTypeForTokens) != null)
{
if (labelOp == ANTLRParser.ASSIGN)
type = LabelType.TOKEN_LABEL;
else
type = LabelType.TOKEN_LIST_LABEL;
}
else if (element.GetFirstDescendantWithType(ANTLRParser.RULE_REF) != null)
{
if (labelOp == ANTLRParser.ASSIGN)
type = LabelType.RULE_LABEL;
else
type = LabelType.RULE_LIST_LABEL;
}
// now reset if lexer and string
if (g.IsLexer())
{
if (element.GetFirstDescendantWithType(ANTLRParser.STRING_LITERAL) != null)
{
if (labelOp == ANTLRParser.ASSIGN)
type = LabelType.LEXER_STRING_LABEL;
}
}
}
public BuildDependencyGenerator(AntlrTool tool, Grammar g)
{
this.tool = tool;
this.g = g;
string language = g.GetOptionString("language");
generator = new CodeGenerator(tool, g, language);
}
public LeftFactoringRuleTransformer([NotNull] GrammarRootAST ast, [NotNull] IDictionary<string, Rule> rules, [NotNull] Grammar g)
{
this._ast = ast;
this._rules = rules;
this._g = g;
this._tool = g.tool;
}
public LeftRecursiveRule(Grammar g, string name, RuleAST ast)
: base(g, name, ast, 1)
{
originalAST = ast;
alt = new Alternative[numberOfAlts + 1]; // always just one
for (int i = 1; i <= numberOfAlts; i++)
alt[i] = new Alternative(this, i);
}
public ElementFrequenciesVisitor(Grammar grammar, ITreeNodeStream input)
: base(input)
{
this.grammar = grammar;
frequencies = new Stack<FrequencySet<string>>();
frequencies.Push(new FrequencySet<string>());
minFrequencies = new Stack<FrequencySet<string>>();
minFrequencies.Push(SENTINEL);
}
public ActionSniffer(Grammar g, Rule r, Alternative alt, ActionAST node, IToken actionToken)
{
this.g = g;
this.r = r;
this.alt = alt;
this.node = node;
this.actionToken = actionToken;
this.errMgr = g.tool.errMgr;
}
public GrammarParserInterpreter(Grammar g, ATN atn, ITokenStream input)
: base(g.fileName, g.GetVocabulary(),
g.GetRuleNames(),
atn, // must run ATN through serializer to set some state flags
input)
{
this.g = g;
decisionStatesThatSetOuterAltNumInContext = FindOuterMostDecisionStates();
stateToAltsMap = new int[g.atn.states.Count][];
}
public GrammarParserInterpreter(Grammar g,
string grammarFileName,
IVocabulary vocabulary,
ICollection<string> ruleNames,
ATN atn,
ITokenStream input)
: base(grammarFileName, vocabulary, ruleNames, atn, input)
{
this.g = g;
}
protected DefaultOutputModelFactory([NotNull] CodeGenerator gen)
{
this.gen = gen;
this.g = gen.g;
if (gen.GetTarget() == null)
{
throw new NotSupportedException("Cannot build an output model without a target.");
}
}
public virtual IDictionary<string, Action> BuildNamedActions(Grammar g)
{
IDictionary<string, Action> namedActions = new Dictionary<string, Action>();
foreach (string name in g.namedActions.Keys)
{
ActionAST ast = g.namedActions[name];
namedActions[name] = new Action(factory, ast);
}
return namedActions;
}
/** Get a meaningful name for a token type useful during code generation.
* Literals without associated names are converted to the string equivalent
* of their integer values. Used to generate x==ID and x==34 type comparisons
* etc... Essentially we are looking for the most obvious way to refer
* to a token type in the generated code.
*/
public virtual string GetTokenTypeAsTargetLabel(Grammar g, int ttype)
{
string name = g.GetTokenName(ttype);
// If name is not valid, return the token type instead
if (Grammar.INVALID_TOKEN_NAME.Equals(name))
{
return ttype.ToString();
}
return name;
}
public static AttributeDict Parse([Nullable] ActionAST action, string s, char separator, Grammar g)
{
AttributeDict dict = new AttributeDict();
IList<System.Tuple<string, int>> decls = SplitDecls(s, separator);
foreach (System.Tuple<string, int> decl in decls)
{
if (decl.Item1.Trim().Length > 0)
{
Attribute a = ParseAttributeDef(action, decl, g);
dict.Add(a);
}
}
return dict;
}
// side-effect: updates Alternative with refs in actions
public static void TrackTokenRuleRefsInActions(Grammar g)
{
foreach (Rule r in g.rules.Values)
{
for (int i = 1; i <= r.numberOfAlts; i++)
{
Alternative alt = r.alt[i];
foreach (ActionAST a in alt.actions)
{
ActionSniffer sniffer = new ActionSniffer(g, r, alt, a, a.Token);
sniffer.ExamineAction();
}
}
}
}
/** Utility visitor that sets grammar ptr in each node */
public static void SetGrammarPtr(Grammar g, GrammarAST tree)
{
if (tree == null)
return;
// ensure each node has pointer to surrounding grammar
Antlr.Runtime.Misc.Func<object, object> preAction =
t =>
{
((GrammarAST)t).g = g;
return t;
};
Antlr.Runtime.Misc.Func<object, object> postAction = t => t;
TreeVisitor v = new TreeVisitor(new GrammarASTAdaptor());
v.Visit(tree, new TreeVisitorAction(preAction, postAction));
}
public SymbolChecks(Grammar g, SymbolCollector collector)
{
this.g = g;
this.collector = collector;
this.errMgr = g.tool.errMgr;
foreach (GrammarAST tokenId in collector.tokenIDRefs)
{
tokenIDs.Add(tokenId.Text);
}
//System.Console.WriteLine("rules="+collector.rules);
//System.Console.WriteLine("rulerefs="+collector.rulerefs);
//System.Console.WriteLine("tokenIDRefs="+collector.tokenIDRefs);
//System.Console.WriteLine("terminals="+collector.terminals);
//System.Console.WriteLine("strings="+collector.strings);
//System.Console.WriteLine("tokensDef="+collector.tokensDefs);
//System.Console.WriteLine("actions="+collector.actions);
//System.Console.WriteLine("scopes="+collector.scopes);
}
public static IDictionary<Rule, ISet<Rule>> GetRuleDependencies(Grammar g, ICollection<Rule> rules)
{
IDictionary<Rule, ISet<Rule>> dependencies = new Dictionary<Rule, ISet<Rule>>();
foreach (Rule r in rules)
{
IList<GrammarAST> tokenRefs = r.ast.GetNodesWithType(ANTLRParser.TOKEN_REF);
foreach (GrammarAST tref in tokenRefs)
{
ISet<Rule> calls;
if (!dependencies.TryGetValue(r, out calls) || calls == null)
{
calls = new HashSet<Rule>();
dependencies[r] = calls;
}
calls.Add(g.GetRule(tref.Text));
}
}
return dependencies;
}
public static void CheckAllAttributeExpressions(Grammar g)
{
foreach (ActionAST act in g.namedActions.Values)
{
AttributeChecks checker = new AttributeChecks(g, null, null, act, act.Token);
checker.ExamineAction();
}
foreach (Rule r in g.rules.Values)
{
foreach (ActionAST a in r.namedActions.Values)
{
AttributeChecks checker = new AttributeChecks(g, r, null, a, a.Token);
checker.ExamineAction();
}
for (int i = 1; i <= r.numberOfAlts; i++)
{
Alternative alt = r.alt[i];
foreach (ActionAST a in alt.actions)
{
AttributeChecks checker =
new AttributeChecks(g, r, alt, a, a.Token);
checker.ExamineAction();
}
}
foreach (GrammarAST e in r.exceptions)
{
ActionAST a = (ActionAST)e.GetChild(1);
AttributeChecks checker = new AttributeChecks(g, r, null, a, a.Token);
checker.ExamineAction();
}
if (r.finallyAction != null)
{
AttributeChecks checker =
new AttributeChecks(g, r, null, r.finallyAction, r.finallyAction.Token);
checker.ExamineAction();
}
}
}
public static string GetLabelName(Grammar g, GrammarAST t)
{
string labelName = t.Text;
Rule referencedRule;
if (g.rules.TryGetValue(labelName, out referencedRule) && referencedRule != null)
{
labelName = referencedRule.GetBaseContext();
}
return labelName;
}
public virtual string[] GetTokenTypesAsTargetLabels(Grammar g, int[] ttypes)
{
string[] labels = new string[ttypes.Length];
for (int i = 0; i < ttypes.Length; i++)
{
labels[i] = GetTokenTypeAsTargetLabel(g, ttypes[i]);
}
return labels;
}
public TokenVocabParser(Grammar g) {
this.g = g;
}
protected internal virtual void GenFile(Grammar g, Template outputFileST, string fileName)
{
GetCodeGenerator().Write(outputFileST, fileName);
}
internal virtual void AssignLexerTokenTypes(Grammar g, IList<GrammarAST> tokensDefs)
{
Grammar G = g.GetOutermostGrammar(); // put in root, even if imported
foreach (GrammarAST def in tokensDefs)
{
// tokens { id (',' id)* } so must check IDs not TOKEN_REF
if (Grammar.IsTokenName(def.Text))
{
G.DefineTokenName(def.Text);
}
}
/* Define token types for nonfragment rules which do not include a 'type(...)'
* or 'more' lexer command.
*/
foreach (Rule r in g.rules.Values)
{
if (!r.IsFragment() && !HasTypeOrMoreCommand(r))
{
G.DefineTokenName(r.name);
}
}
// FOR ALL X : 'xxx'; RULES, DEFINE 'xxx' AS TYPE X
IList<System.Tuple<GrammarAST, GrammarAST>> litAliases = Grammar.GetStringLiteralAliasesFromLexerRules(g.ast);
ISet<string> conflictingLiterals = new HashSet<string>();
if (litAliases != null)
{
foreach (System.Tuple<GrammarAST, GrammarAST> pair in litAliases)
{
GrammarAST nameAST = pair.Item1;
GrammarAST litAST = pair.Item2;
if (!G.stringLiteralToTypeMap.ContainsKey(litAST.Text))
{
G.DefineTokenAlias(nameAST.Text, litAST.Text);
}
else
{
// oops two literal defs in two rules (within or across modes).
conflictingLiterals.Add(litAST.Text);
}
}
foreach (string lit in conflictingLiterals)
{
// Remove literal if repeated across rules so it's not
// found by parser grammar.
int value;
if (G.stringLiteralToTypeMap.TryGetValue(lit, out value))
{
G.stringLiteralToTypeMap.Remove(lit);
if (value > 0 && value < G.typeToStringLiteralList.Count && lit.Equals(G.typeToStringLiteralList[value]))
{
G.typeToStringLiteralList[value] = null;
}
}
}
}
}
public int actionIndex = -1; // if lexer; 0..n-1 for n actions in a rule
public Rule(Grammar g, string name, RuleAST ast, int numberOfAlts)
{
this.g = g;
this.name = name;
this.ast = ast;
this.numberOfAlts = numberOfAlts;
alt = new Alternative[numberOfAlts + 1]; // 1..n
for (int i = 1; i <= numberOfAlts; i++)
alt[i] = new Alternative(this, i);
}
public BasicSemanticChecks(Grammar g, RuleCollector ruleCollector)
{
this.g = g;
this.ruleCollector = ruleCollector;
this.errMgr = g.tool.errMgr;
}
public SemanticPipeline(Grammar g)
{
this.g = g;
}
/**
* Assign constant values to custom channels defined in a grammar.
*
* @param g The grammar.
* @param channelDefs A collection of AST nodes defining individual channels
* within a {@code channels{}} block in the grammar.
*/
internal virtual void AssignChannelTypes(Grammar g, IList<GrammarAST> channelDefs)
{
Grammar outermost = g.GetOutermostGrammar();
foreach (GrammarAST channel in channelDefs)
{
string channelName = channel.Text;
// Channel names can't alias tokens or modes, because constant
// values are also assigned to them and the ->channel(NAME) lexer
// command does not distinguish between the various ways a constant
// can be declared. This method does not verify that channels do not
// alias rules, because rule names are not associated with constant
// values in ANTLR grammar semantics.
if (g.GetTokenType(channelName) != TokenConstants.InvalidType)
{
g.tool.errMgr.GrammarError(ErrorType.CHANNEL_CONFLICTS_WITH_TOKEN, g.fileName, channel.Token, channelName);
}
if (LexerATNFactory.COMMON_CONSTANTS.ContainsKey(channelName))
{
g.tool.errMgr.GrammarError(ErrorType.CHANNEL_CONFLICTS_WITH_COMMON_CONSTANTS, g.fileName, channel.Token, channelName);
}
if (outermost is LexerGrammar)
{
LexerGrammar lexerGrammar = (LexerGrammar)outermost;
if (lexerGrammar.modes.ContainsKey(channelName))
{
g.tool.errMgr.GrammarError(ErrorType.CHANNEL_CONFLICTS_WITH_MODE, g.fileName, channel.Token, channelName);
}
}
outermost.DefineChannelName(channel.Text);
}
}
internal virtual void AssignTokenTypes(Grammar g, IList<GrammarAST> tokensDefs,
IList<GrammarAST> tokenIDs, IList<GrammarAST> terminals)
{
//Grammar G = g.getOutermostGrammar(); // put in root, even if imported
// create token types for tokens { A, B, C } ALIASES
foreach (GrammarAST alias in tokensDefs)
{
if (g.GetTokenType(alias.Text) != TokenConstants.InvalidType)
{
g.tool.errMgr.GrammarError(ErrorType.TOKEN_NAME_REASSIGNMENT, g.fileName, alias.Token, alias.Text);
}
g.DefineTokenName(alias.Text);
}
// DEFINE TOKEN TYPES FOR TOKEN REFS LIKE ID, INT
foreach (GrammarAST idAST in tokenIDs)
{
if (g.GetTokenType(idAST.Text) == TokenConstants.InvalidType)
{
g.tool.errMgr.GrammarError(ErrorType.IMPLICIT_TOKEN_DEFINITION, g.fileName, idAST.Token, idAST.Text);
}
g.DefineTokenName(idAST.Text);
}
// VERIFY TOKEN TYPES FOR STRING LITERAL REFS LIKE 'while', ';'
foreach (GrammarAST termAST in terminals)
{
if (termAST.Type != ANTLRParser.STRING_LITERAL)
{
continue;
}
if (g.GetTokenType(termAST.Text) == TokenConstants.InvalidType)
{
g.tool.errMgr.GrammarError(ErrorType.IMPLICIT_STRING_DEFINITION, g.fileName, termAST.Token, termAST.Text);
}
}
g.tool.Log("semantics", "tokens=" + g.tokenNameToTypeMap);
g.tool.Log("semantics", "strings=" + g.stringLiteralToTypeMap);
}
public SymbolCollector(Grammar g)
{
this.g = g;
this.errMgr = g.tool.errMgr;
}
public GrammarToken(Grammar g, IToken oldToken)
{
this.g = g;
_token = new CommonToken(oldToken);
}