public InvokeRule(ParserFactory factory, GrammarAST ast, GrammarAST labelAST)
: base(factory, ast)
{
if (ast.atnState != null)
{
RuleTransition ruleTrans = (RuleTransition)ast.atnState.Transition(0);
stateNumber = ast.atnState.stateNumber;
}
this.name = ast.Text;
Rule r = factory.GetGrammar().GetRule(name);
ctxName = factory.GetTarget().GetRuleFunctionContextStructName(r);
// TODO: move to factory
RuleFunction rf = factory.GetCurrentRuleFunction();
if (labelAST != null)
{
// for x=r, define <rule-context-type> x and list_x
string label = labelAST.Text;
if (labelAST.Parent.Type == ANTLRParser.PLUS_ASSIGN)
{
factory.DefineImplicitLabel(ast, this);
string listLabel = factory.GetTarget().GetListLabel(label);
RuleContextListDecl l = new RuleContextListDecl(factory, listLabel, ctxName);
rf.AddContextDecl(ast.GetAltLabel(), l);
}
else
{
RuleContextDecl d = new RuleContextDecl(factory, label, ctxName);
labels.Add(d);
rf.AddContextDecl(ast.GetAltLabel(), d);
}
}
ActionAST arg = (ActionAST)ast.GetFirstChildWithType(ANTLRParser.ARG_ACTION);
if (arg != null)
{
argExprsChunks = ActionTranslator.TranslateAction(factory, rf, arg.Token, arg);
}
// If action refs rule as rulename not label, we need to define implicit label
if (factory.GetCurrentOuterMostAlt().ruleRefsInActions.ContainsKey(ast.Text))
{
string label = factory.GetTarget().GetImplicitRuleLabel(ast.Text);
RuleContextDecl d = new RuleContextDecl(factory, label, ctxName);
labels.Add(d);
rf.AddContextDecl(ast.GetAltLabel(), d);
}
}
/**
* Match (RULE RULE_REF (BLOCK (ALT .*) (ALT RULE_REF[self] .*) (ALT .*)))
* Match (RULE RULE_REF (BLOCK (ALT .*) (ALT (ASSIGN ID RULE_REF[self]) .*) (ALT .*)))
*/
public static bool HasImmediateRecursiveRuleRefs(GrammarAST t, string ruleName)
{
if (t == null)
{
return(false);
}
GrammarAST blk = (GrammarAST)t.GetFirstChildWithType(BLOCK);
if (blk == null)
{
return(false);
}
int n = blk.Children.Count;
for (int i = 0; i < n; i++)
{
GrammarAST alt = (GrammarAST)blk.Children[i];
ITree first = alt.GetChild(0);
if (first == null)
{
continue;
}
if (first.Type == ELEMENT_OPTIONS)
{
first = alt.GetChild(1);
if (first == null)
{
continue;
}
}
if (first.Type == RULE_REF && first.Text.Equals(ruleName))
{
return(true);
}
ITree rref = first.GetChild(1);
if (rref != null && rref.Type == RULE_REF && rref.Text.Equals(ruleName))
{
return(true);
}
}
return(false);
}
/** Merge all the rules, token definitions, and named actions from
* imported grammars into the root grammar tree. Perform:
*
* (tokens { X (= Y 'y')) + (tokens { Z ) -> (tokens { X (= Y 'y') Z)
*
* (@ members {foo}) + (@ members {bar}) -> (@ members {foobar})
*
* (RULES (RULE x y)) + (RULES (RULE z)) -> (RULES (RULE x y z))
*
* Rules in root prevent same rule from being appended to RULES node.
*
* The goal is a complete combined grammar so we can ignore subordinate
* grammars.
*/
public virtual void IntegrateImportedGrammars(Grammar rootGrammar)
{
IList <Grammar> imports = rootGrammar.GetAllImportedGrammars();
if (imports == null)
{
return;
}
GrammarAST root = rootGrammar.ast;
GrammarAST id = (GrammarAST)root.GetChild(0);
GrammarASTAdaptor adaptor = new GrammarASTAdaptor(id.Token.InputStream);
GrammarAST tokensRoot = (GrammarAST)root.GetFirstChildWithType(ANTLRParser.TOKENS_SPEC);
IList <GrammarAST> actionRoots = root.GetNodesWithType(ANTLRParser.AT);
// Compute list of rules in root grammar and ensure we have a RULES node
GrammarAST RULES = (GrammarAST)root.GetFirstChildWithType(ANTLRParser.RULES);
ISet <string> rootRuleNames = new HashSet <string>();
// make list of rules we have in root grammar
IList <GrammarAST> rootRules = RULES.GetNodesWithType(ANTLRParser.RULE);
foreach (GrammarAST r in rootRules)
{
rootRuleNames.Add(r.GetChild(0).Text);
}
foreach (Grammar imp in imports)
{
// COPY TOKENS
GrammarAST imp_tokensRoot = (GrammarAST)imp.ast.GetFirstChildWithType(ANTLRParser.TOKENS_SPEC);
if (imp_tokensRoot != null)
{
rootGrammar.tool.Log("grammar", "imported tokens: " + imp_tokensRoot.Children);
if (tokensRoot == null)
{
tokensRoot = (GrammarAST)adaptor.Create(ANTLRParser.TOKENS_SPEC, "TOKENS");
tokensRoot.g = rootGrammar;
root.InsertChild(1, tokensRoot); // ^(GRAMMAR ID TOKENS...)
}
tokensRoot.AddChildren(imp_tokensRoot.Children);
}
IList <GrammarAST> all_actionRoots = new List <GrammarAST>();
IList <GrammarAST> imp_actionRoots = imp.ast.GetAllChildrenWithType(ANTLRParser.AT);
if (actionRoots != null)
{
foreach (var actionRoot in actionRoots)
{
all_actionRoots.Add(actionRoot);
}
}
foreach (var actionRoot in imp_actionRoots)
{
all_actionRoots.Add(actionRoot);
}
// COPY ACTIONS
if (imp_actionRoots != null)
{
IDictionary <System.Tuple <string, string>, GrammarAST> namedActions =
new Dictionary <System.Tuple <string, string>, GrammarAST>();
rootGrammar.tool.Log("grammar", "imported actions: " + imp_actionRoots);
foreach (GrammarAST at in all_actionRoots)
{
string scopeName = rootGrammar.GetDefaultActionScope();
GrammarAST scope, name, action;
if (at.ChildCount > 2)
{ // must have a scope
scope = (GrammarAST)at.GetChild(0);
scopeName = scope.Text;
name = (GrammarAST)at.GetChild(1);
action = (GrammarAST)at.GetChild(2);
}
else
{
name = (GrammarAST)at.GetChild(0);
action = (GrammarAST)at.GetChild(1);
}
GrammarAST prevAction;
if (!namedActions.TryGetValue(Tuple.Create(scopeName, name.Text), out prevAction) || prevAction == null)
{
namedActions[Tuple.Create(scopeName, name.Text)] = action;
}
else
{
if (prevAction.g == at.g)
{
rootGrammar.tool.errMgr.GrammarError(ErrorType.ACTION_REDEFINITION,
at.g.fileName, name.Token, name.Text);
}
else
{
string s1 = prevAction.Text;
s1 = s1.Substring(1, s1.Length - 2);
string s2 = action.Text;
s2 = s2.Substring(1, s2.Length - 2);
string combinedAction = "{" + s1 + '\n' + s2 + "}";
prevAction.Token.Text = combinedAction;
}
}
}
// at this point, we have complete list of combined actions,
// some of which are already living in root grammar.
// Merge in any actions not in root grammar into root's tree.
foreach (string scopeName in namedActions.Keys.Select(i => i.Item1).Distinct())
{
foreach (string name in namedActions.Keys.Where(i => i.Item1 == scopeName).Select(i => i.Item2))
{
GrammarAST action = namedActions[Tuple.Create(scopeName, name)];
rootGrammar.tool.Log("grammar", action.g.name + " " + scopeName + ":" + name + "=" + action.Text);
if (action.g != rootGrammar)
{
root.InsertChild(1, action.Parent);
}
}
}
}
// COPY RULES
IList <GrammarAST> rules = imp.ast.GetNodesWithType(ANTLRParser.RULE);
if (rules != null)
{
foreach (GrammarAST r in rules)
{
rootGrammar.tool.Log("grammar", "imported rule: " + r.ToStringTree());
string name = r.GetChild(0).Text;
bool rootAlreadyHasRule = rootRuleNames.Contains(name);
if (!rootAlreadyHasRule)
{
RULES.AddChild(r); // merge in if not overridden
rootRuleNames.Add(name);
}
}
}
GrammarAST optionsRoot = (GrammarAST)imp.ast.GetFirstChildWithType(ANTLRParser.OPTIONS);
if (optionsRoot != null)
{
// suppress the warning if the options match the options specified
// in the root grammar
// https://github.com/antlr/antlr4/issues/707
bool hasNewOption = false;
foreach (KeyValuePair <string, GrammarAST> option in imp.ast.GetOptions())
{
string importOption = imp.ast.GetOptionString(option.Key);
if (importOption == null)
{
continue;
}
string rootOption = rootGrammar.ast.GetOptionString(option.Key);
if (!importOption.Equals(rootOption))
{
hasNewOption = true;
break;
}
}
if (hasNewOption)
{
rootGrammar.tool.errMgr.GrammarError(ErrorType.OPTIONS_IN_DELEGATE,
optionsRoot.g.fileName, optionsRoot.Token, imp.name);
}
}
}
rootGrammar.tool.Log("grammar", "Grammar: " + rootGrammar.ast.ToStringTree());
}
