public virtual void DefinePredicateInAlt(int currentAlt, PredAST predAST)
{
actions.Add(predAST);
alt[currentAlt].actions.Add(predAST);
if (!g.sempreds.ContainsKey(predAST))
{
g.sempreds[predAST] = g.sempreds.Count;
}
}
public virtual void BuildLexerRuleActions(Lexer lexer, Rule r)
{
if (r.actions.Count == 0)
{
return;
}
CodeGenerator gen = @delegate.GetGenerator();
Grammar g = @delegate.GetGrammar();
string ctxType = @delegate.GetTarget().GetRuleFunctionContextStructName(r);
RuleActionFunction raf;
if (!lexer.actionFuncs.TryGetValue(r, out raf) || raf == null)
{
raf = new RuleActionFunction(@delegate, r, ctxType);
}
foreach (ActionAST a in r.actions)
{
if (a is PredAST)
{
PredAST p = (PredAST)a;
RuleSempredFunction rsf;
if (!lexer.sempredFuncs.TryGetValue(r, out rsf) || rsf == null)
{
rsf = new RuleSempredFunction(@delegate, r, ctxType);
lexer.sempredFuncs[r] = rsf;
}
rsf.actions[g.sempreds[p]] = new Action(@delegate, p);
}
else if (a.Type == ANTLRParser.ACTION)
{
raf.actions[g.lexerActions[a]] = new Action(@delegate, a);
}
}
if (raf.actions.Count > 0 && !lexer.actionFuncs.ContainsKey(r))
{
// only add to lexer if the function actually contains actions
lexer.actionFuncs[r] = raf;
}
}
/** Create RuleFunction per rule and update semantic predicates, actions of parser
* output object with stuff found in r.
*/
public virtual void BuildRuleFunction(Parser parser, Rule r)
{
RuleFunction function = Rule(r);
parser.funcs.Add(function);
PushCurrentRule(function);
function.FillNamedActions(@delegate, r);
if (r is LeftRecursiveRule)
{
BuildLeftRecursiveRuleFunction((LeftRecursiveRule)r,
(LeftRecursiveRuleFunction)function);
}
else
{
BuildNormalRuleFunction(r, function);
}
Grammar g = GetGrammar();
foreach (ActionAST a in r.actions)
{
if (a is PredAST)
{
PredAST p = (PredAST)a;
RuleSempredFunction rsf;
if (!parser.sempredFuncs.TryGetValue(r, out rsf) || rsf == null)
{
rsf = new RuleSempredFunction(@delegate, r, function.ctxType);
parser.sempredFuncs[r] = rsf;
}
rsf.actions[g.sempreds[p]] = new Action(@delegate, p);
}
}
PopCurrentRule();
}
public virtual Handle Sempred([NotNull] PredAST pred)
{
//System.out.println("sempred: "+ pred);
ATNState left = NewState(pred);
ATNState right = NewState(pred);
AbstractPredicateTransition p;
if (pred.GetOptionString(LeftRecursiveRuleTransformer.PRECEDENCE_OPTION_NAME) != null)
{
int precedence = int.Parse(pred.GetOptionString(LeftRecursiveRuleTransformer.PRECEDENCE_OPTION_NAME));
p = new PrecedencePredicateTransition(right, precedence);
}
else
{
bool isCtxDependent = UseDefAnalyzer.ActionIsContextDependent(pred);
p = new PredicateTransition(right, currentRule.index, g.sempreds[pred], isCtxDependent);
}
left.AddTransition(p);
pred.atnState = left;
return(new Handle(left, right));
}
public override void SempredInAlt(PredAST pred)
{
currentRule.DefinePredicateInAlt(currentOuterAltNumber, pred);
pred.resolver = currentRule.alt[currentOuterAltNumber];
}