public override Choice GetChoiceBlock(BlockAST blkAST, IList <CodeBlockForAlt> alts, GrammarAST labelAST)
{
int decision = ((DecisionState)blkAST.atnState).decision;
Choice c;
if (!g.tool.force_atn && AnalysisPipeline.Disjoint(g.decisionLOOK[decision]))
{
c = GetLL1ChoiceBlock(blkAST, alts);
}
else
{
c = GetComplexChoiceBlock(blkAST, alts);
}
if (labelAST != null)
{ // for x=(...), define x or x_list
string label = labelAST.Text;
Decl d = GetTokenLabelDecl(label);
c.label = d;
GetCurrentRuleFunction().AddContextDecl(labelAST.GetAltLabel(), d);
if (labelAST.Parent.Type == ANTLRParser.PLUS_ASSIGN)
{
string listLabel = GetTarget().GetListLabel(label);
TokenListDecl l = new TokenListDecl(this, listLabel);
GetCurrentRuleFunction().AddContextDecl(labelAST.GetAltLabel(), l);
}
}
return(c);
}
public override IList <SrcOp> Wildcard(GrammarAST ast, GrammarAST labelAST)
{
Wildcard wild = new Wildcard(this, ast);
// TODO: dup with tokenRef
if (labelAST != null)
{
string label = labelAST.Text;
Decl d = GetTokenLabelDecl(label);
wild.labels.Add(d);
GetCurrentRuleFunction().AddContextDecl(ast.GetAltLabel(), d);
if (labelAST.Parent.Type == ANTLRParser.PLUS_ASSIGN)
{
TokenListDecl l = GetTokenListLabelDecl(label);
GetCurrentRuleFunction().AddContextDecl(ast.GetAltLabel(), l);
}
}
if (controller.NeedsImplicitLabel(ast, wild))
{
DefineImplicitLabel(ast, wild);
}
AddToLabelList listLabelOp = GetAddToListOpIfListLabelPresent(wild, labelAST);
return(List(wild, listLabelOp));
}
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);
}
}
// support
public virtual void DefineImplicitLabel(GrammarAST ast, LabeledOp op)
{
Decl d;
if (ast.Type == ANTLRParser.SET || ast.Type == ANTLRParser.WILDCARD)
{
string implLabel =
GetTarget().GetImplicitSetLabel(ast.Token.TokenIndex.ToString());
d = GetTokenLabelDecl(implLabel);
((TokenDecl)d).isImplicit = true;
}
else if (ast.Type == ANTLRParser.RULE_REF)
{ // a rule reference?
Rule r = g.GetRule(ast.Text);
string implLabel = GetTarget().GetImplicitRuleLabel(ast.Text);
string ctxName =
GetTarget().GetRuleFunctionContextStructName(r);
d = new RuleContextDecl(this, implLabel, ctxName);
((RuleContextDecl)d).isImplicit = true;
}
else
{
string implLabel = GetTarget().GetImplicitTokenLabel(ast.Text);
d = GetTokenLabelDecl(implLabel);
((TokenDecl)d).isImplicit = true;
}
op.GetLabels().Add(d);
// all labels must be in scope struct in case we exec action out of context
GetCurrentRuleFunction().AddContextDecl(ast.GetAltLabel(), d);
}
public override IList <SrcOp> TokenRef(GrammarAST ID, GrammarAST labelAST, GrammarAST args)
{
MatchToken matchOp = new MatchToken(this, (TerminalAST)ID);
if (labelAST != null)
{
string label = labelAST.Text;
RuleFunction rf = GetCurrentRuleFunction();
if (labelAST.Parent.Type == ANTLRParser.PLUS_ASSIGN)
{
// add Token _X and List<Token> X decls
DefineImplicitLabel(ID, matchOp); // adds _X
TokenListDecl l = GetTokenListLabelDecl(label);
rf.AddContextDecl(ID.GetAltLabel(), l);
}
else
{
Decl d = GetTokenLabelDecl(label);
matchOp.labels.Add(d);
rf.AddContextDecl(ID.GetAltLabel(), d);
}
// Decl d = getTokenLabelDecl(label);
// ((MatchToken)matchOp).labels.add(d);
// getCurrentRuleFunction().addContextDecl(ID.getAltLabel(), d);
// if ( labelAST.parent.getType() == ANTLRParser.PLUS_ASSIGN ) {
// TokenListDecl l = getTokenListLabelDecl(label);
// getCurrentRuleFunction().addContextDecl(ID.getAltLabel(), l);
// }
}
if (controller.NeedsImplicitLabel(ID, matchOp))
{
DefineImplicitLabel(ID, matchOp);
}
AddToLabelList listLabelOp = GetAddToListOpIfListLabelPresent(matchOp, labelAST);
return(List(matchOp, listLabelOp));
}
public override IList <SrcOp> Set(GrammarAST setAST, GrammarAST labelAST, bool invert)
{
MatchSet matchOp;
if (invert)
{
matchOp = new MatchNotSet(this, setAST);
}
else
{
matchOp = new MatchSet(this, setAST);
}
if (labelAST != null)
{
string label = labelAST.Text;
RuleFunction rf = GetCurrentRuleFunction();
if (labelAST.Parent.Type == ANTLRParser.PLUS_ASSIGN)
{
DefineImplicitLabel(setAST, matchOp);
TokenListDecl l = GetTokenListLabelDecl(label);
rf.AddContextDecl(setAST.GetAltLabel(), l);
}
else
{
Decl d = GetTokenLabelDecl(label);
matchOp.labels.Add(d);
rf.AddContextDecl(setAST.GetAltLabel(), d);
}
}
if (controller.NeedsImplicitLabel(setAST, matchOp))
{
DefineImplicitLabel(setAST, matchOp);
}
AddToLabelList listLabelOp = GetAddToListOpIfListLabelPresent(matchOp, labelAST);
return(List(matchOp, listLabelOp));
}
