public LexerATNConfig(LexerATNConfig c, ATNState state,
PredictionContext context)
: base(c, state, context, c.semanticContext)
{
this.lexerActionExecutor = c.lexerActionExecutor;
this.passedThroughNonGreedyDecision = checkNonGreedyDecision(c, state);
}
public LexerATNConfig(ATNState state,
int alt,
PredictionContext context)
: base(state, alt, context /*, SemanticContext.NONE*/) // TODO
{
this.passedThroughNonGreedyDecision = false;
this.lexerActionExecutor = null;
}
public LexerATNConfig(ATNState state,
int alt,
PredictionContext context,
LexerActionExecutor lexerActionExecutor)
: base(state, alt, context, SemanticContext.NONE)
{
this.lexerActionExecutor = lexerActionExecutor;
this.passedThroughNonGreedyDecision = false;
}
public override bool Equals(object obj)
{
if (obj == this)
{
return(true);
}
else
{
if (!(obj is erl.Oracle.TnsNames.Antlr4.Runtime.Atn.LexerActionExecutor))
{
return(false);
}
}
erl.Oracle.TnsNames.Antlr4.Runtime.Atn.LexerActionExecutor other = (erl.Oracle.TnsNames.Antlr4.Runtime.Atn.LexerActionExecutor)obj;
return(hashCode == other.hashCode && Arrays.Equals(lexerActions, other.lexerActions));
}
protected void Accept(ICharStream input, LexerActionExecutor lexerActionExecutor,
int startIndex, int index, int line, int charPos)
{
if (debug)
{
ConsoleWriteLine("ACTION " + lexerActionExecutor);
}
// seek to after last char in token
input.Seek(index);
this.thisLine = line;
this.charPositionInLine = charPos;
if (lexerActionExecutor != null && recog != null)
{
lexerActionExecutor.Execute(recog, input, startIndex);
}
}
/** Given a starting configuration set, figure out all ATN configurations
* we can reach upon input {@code t}. Parameter {@code reach} is a return
* parameter.
*/
protected void GetReachableConfigSet(ICharStream input, ATNConfigSet closure, ATNConfigSet reach, int t)
{
// this is used to skip processing for configs which have a lower priority
// than a config that already reached an accept state for the same rule
int skipAlt = ATN.INVALID_ALT_NUMBER;
foreach (ATNConfig c in closure.configs)
{
bool currentAltReachedAcceptState = c.alt == skipAlt;
if (currentAltReachedAcceptState && ((LexerATNConfig)c).hasPassedThroughNonGreedyDecision())
{
continue;
}
if (debug)
{
ConsoleWriteLine("testing " + GetTokenName(t) + " at " + c.ToString(recog, true));
}
int n = c.state.NumberOfTransitions;
for (int ti = 0; ti < n; ti++)
{ // for each transition
Transition trans = c.state.Transition(ti);
ATNState target = GetReachableTarget(trans, t);
if (target != null)
{
LexerActionExecutor lexerActionExecutor = ((LexerATNConfig)c).getLexerActionExecutor();
if (lexerActionExecutor != null)
{
lexerActionExecutor = lexerActionExecutor.FixOffsetBeforeMatch(input.Index - startIndex);
}
bool treatEofAsEpsilon = t == IntStreamConstants.EOF;
if (Closure(input, new LexerATNConfig((LexerATNConfig)c, target, lexerActionExecutor), reach, currentAltReachedAcceptState, true, treatEofAsEpsilon))
{
// any remaining configs for this alt have a lower priority than
// the one that just reached an accept state.
skipAlt = c.alt;
break;
}
}
}
}
}
protected int FailOrAccept(SimState prevAccept, ICharStream input,
ATNConfigSet reach, int t)
{
if (prevAccept.dfaState != null)
{
LexerActionExecutor lexerActionExecutor = prevAccept.dfaState.lexerActionExecutor;
Accept(input, lexerActionExecutor, startIndex,
prevAccept.index, prevAccept.line, prevAccept.charPos);
return(prevAccept.dfaState.prediction);
}
else
{
// if no accept and EOF is first char, return EOF
if (t == IntStreamConstants.EOF && input.Index == startIndex)
{
return(TokenConstants.EOF);
}
throw new LexerNoViableAltException(recog, input, startIndex, reach);
}
}
public static erl.Oracle.TnsNames.Antlr4.Runtime.Atn.LexerActionExecutor Append(erl.Oracle.TnsNames.Antlr4.Runtime.Atn.LexerActionExecutor lexerActionExecutor, ILexerAction lexerAction)
{
if (lexerActionExecutor == null)
{
return(new erl.Oracle.TnsNames.Antlr4.Runtime.Atn.LexerActionExecutor(new ILexerAction[] { lexerAction }));
}
ILexerAction[] lexerActions = Arrays.CopyOf(lexerActionExecutor.lexerActions, lexerActionExecutor.lexerActions.Length + 1);
lexerActions[lexerActions.Length - 1] = lexerAction;
return(new erl.Oracle.TnsNames.Antlr4.Runtime.Atn.LexerActionExecutor(lexerActions));
}
// side-effect: can alter configs.hasSemanticContext
protected LexerATNConfig GetEpsilonTarget(ICharStream input,
LexerATNConfig config,
Transition t,
ATNConfigSet configs,
bool speculative,
bool treatEofAsEpsilon)
{
LexerATNConfig c = null;
switch (t.TransitionType)
{
case TransitionType.RULE:
RuleTransition ruleTransition = (RuleTransition)t;
PredictionContext newContext = new SingletonPredictionContext(config.context, ruleTransition.followState.stateNumber);
c = new LexerATNConfig(config, t.target, newContext);
break;
case TransitionType.PRECEDENCE:
throw new Exception("Precedence predicates are not supported in lexers.");
case TransitionType.PREDICATE:
/* Track traversing semantic predicates. If we traverse,
* we cannot add a DFA state for this "reach" computation
* because the DFA would not test the predicate again in the
* future. Rather than creating collections of semantic predicates
* like v3 and testing them on prediction, v4 will test them on the
* fly all the time using the ATN not the DFA. This is slower but
* semantically it's not used that often. One of the key elements to
* this predicate mechanism is not adding DFA states that see
* predicates immediately afterwards in the ATN. For example,
*
* a : ID {p1}? | ID {p2}? ;
*
* should create the start state for rule 'a' (to save start state
* competition), but should not create target of ID state. The
* collection of ATN states the following ID references includes
* states reached by traversing predicates. Since this is when we
* test them, we cannot cash the DFA state target of ID.
*/
PredicateTransition pt = (PredicateTransition)t;
if (debug)
{
ConsoleWriteLine("EVAL rule " + pt.ruleIndex + ":" + pt.predIndex);
}
configs.hasSemanticContext = true;
if (EvaluatePredicate(input, pt.ruleIndex, pt.predIndex, speculative))
{
c = new LexerATNConfig(config, t.target);
}
break;
case TransitionType.ACTION:
if (config.context == null || config.context.HasEmptyPath)
{
// execute actions anywhere in the start rule for a token.
//
// TODO: if the entry rule is invoked recursively, some
// actions may be executed during the recursive call. The
// problem can appear when hasEmptyPath() is true but
// isEmpty() is false. In this case, the config needs to be
// split into two contexts - one with just the empty path
// and another with everything but the empty path.
// Unfortunately, the current algorithm does not allow
// getEpsilonTarget to return two configurations, so
// additional modifications are needed before we can support
// the split operation.
LexerActionExecutor lexerActionExecutor = LexerActionExecutor.Append(config.getLexerActionExecutor(), atn.lexerActions[((ActionTransition)t).actionIndex]);
c = new LexerATNConfig(config, t.target, lexerActionExecutor);
break;
}
else
{
// ignore actions in referenced rules
c = new LexerATNConfig(config, t.target);
break;
}
case TransitionType.EPSILON:
c = new LexerATNConfig(config, t.target);
break;
case TransitionType.ATOM:
case TransitionType.RANGE:
case TransitionType.SET:
if (treatEofAsEpsilon)
{
if (t.Matches(IntStreamConstants.EOF, Lexer.MinCharValue, Lexer.MaxCharValue))
{
c = new LexerATNConfig(config, t.target);
break;
}
}
break;
}
return(c);
}
