org.antlr.v4.runtime.atn.ATNState java code examples

CallerContext caller = current.caller;
if (state.getStateType() == BLOCK_START || state.getStateType() == RULE_START) {
  int rule = state.ruleIndex;
for (int i = 0; i < state.getNumberOfTransitions(); i++) {
  Transition transition = state.transition(i);

public void addTransition(Transition e) {
  addTransition(transitions.size(), e);
}

if ( !p.onlyHasEpsilonTransitions() ) {
  configs.add(config, mergeCache);
for (int i=0; i<p.getNumberOfTransitions(); i++) {
  if ( i==0 && canDropLoopEntryEdgeInLeftRecursiveRule(config) ) continue;
  Transition t = p.transition(i);
  boolean continueCollecting =
    !(t instanceof ActionTransition) && collectPredicates;

/**
 * Analyze the {@link StarLoopEntryState} states in the specified ATN to set
 * the {@link StarLoopEntryState#isPrecedenceDecision} field to the
 * correct value.
 *
 * @param atn The ATN.
 */
protected void markPrecedenceDecisions(ATN atn) {
  for (ATNState state : atn.states) {
    if (!(state instanceof StarLoopEntryState)) {
      continue;
    }
    /* We analyze the ATN to determine if this ATN decision state is the
     * decision for the closure block that determines whether a
     * precedence rule should continue or complete.
     */
    if (atn.ruleToStartState[state.ruleIndex].isLeftRecursiveRule) {
      ATNState maybeLoopEndState = state.transition(state.getNumberOfTransitions() - 1).target;
      if (maybeLoopEndState instanceof LoopEndState) {
        if (maybeLoopEndState.epsilonOnlyTransitions && maybeLoopEndState.transition(0).target instanceof RuleStopState) {
          ((StarLoopEntryState)state).isPrecedenceDecision = true;
        }
      }
    }
  }
}

srcState.addTransition(trans);
p += 6;
for (int i = 0; i < state.getNumberOfTransitions(); i++) {
  Transition t = state.transition(i);
  if (!(t instanceof RuleTransition)) {
    continue;
    for (int i = 0; i < state.getNumberOfTransitions(); i++) {
      Transition transition = state.transition(i);
      if (!(transition instanceof ActionTransition)) {
        continue;
      int actionIndex = ((ActionTransition)transition).actionIndex;
      LexerCustomAction lexerAction = new LexerCustomAction(ruleIndex, actionIndex);
      state.setTransition(i, new ActionTransition(transition.target, ruleIndex, legacyLexerActions.size(), false));
      legacyLexerActions.add(lexerAction);
      ATNState maybeLoopEndState = state.transition(state.getNumberOfTransitions() - 1).target;
      if (!(maybeLoopEndState instanceof LoopEndState)) {
        continue;
      if (maybeLoopEndState.epsilonOnlyTransitions && maybeLoopEndState.transition(0).target instanceof RuleStopState) {
        endState = state;
        break;
  matchState.addTransition(new AtomTransition(bypassStop, atn.ruleToTokenType[i]));
  bypassStart.addTransition(new EpsilonTransition(matchState));

for (int i = 0; i < s.getNumberOfTransitions(); i++) {
  Transition edge = s.transition(i);
  if ( edge instanceof RuleTransition ) {
    RuleTransition rr = ((RuleTransition)edge);
    boolean loopback = false;
    if (edge.target instanceof PlusBlockStartState) {
      loopback = s.equals(((PlusBlockStartState)edge.target).loopBackState);
      loopback = s.equals(((StarLoopEntryState)edge.target).loopBackState);
  edgeST.add("target", "s"+edge.target.stateNumber);
  edgeST.add("arrowhead", arrowhead);
  if (s.getNumberOfTransitions() > 1) {
    edgeST.add("transitionIndex", i);
st.add("name", "s"+s.stateNumber);
st.add("label", getStateLabel(s));
st.add("transitions", s.getTransitions());
dot.add("states", st);

if (epsTransition.target.getNumberOfTransitions() != 1) {
  continue;
Transition transition = epsTransition.target.transition(0);
if (!(transition.target instanceof BlockEndState)) {
  continue;
ATNState blockEndState = decision.transition(interval.a).target.transition(0).target;
IntervalSet matchSet = new IntervalSet();
for (int j = interval.a; j <= interval.b; j++) {
  Transition matchTransition = decision.transition(j).target.transition(0);
  if (matchTransition instanceof NotSetTransition) {
    throw new UnsupportedOperationException("Not yet implemented.");
decision.transition(interval.a).target.setTransition(0, newTransition);
for (int j = interval.a + 1; j <= interval.b; j++) {
  Transition removed = decision.removeTransition(interval.a + 1);

Transition transition = p.transition(predictedAlt - 1);
switch (transition.getSerializationType()) {
  case Transition.EPSILON:
    if ( p.getStateType()==ATNState.STAR_LOOP_ENTRY &&
       ((StarLoopEntryState)p).isPrecedenceDecision &&
       !(transition.target instanceof LoopEndState))

protected void epsilon(ATNState a, @NotNull ATNState b, boolean prepend) {
  for (Transition t : a.getTransitions()) {
    if (t.getSerializationType() != Transition.EPSILON) {
      continue;
    }
    if (t.target == b && ((EpsilonTransition)t).outermostPrecedenceReturn() == -1) {
      // This transition was already added
      return;
    }
  }
  if ( a!=null ) {
    int index = prepend ? 0 : a.getNumberOfTransitions();
    a.addTransition(index, new EpsilonTransition(b));
  }
}

  private CallerContext makeCallStack(RuleContext context)
  {
    if (context == null || context.invokingState == -1) {
      return null;
    }
    CallerContext parent = makeCallStack(context.parent);
    ATNState followState = ((RuleTransition) atn.states.get(context.invokingState).transition(0)).followState;
    return new CallerContext(parent, followState);
  }
}

RuleStartState startState = atn.ruleToStartState[i];
ATNState middleState = startState;
while (middleState.onlyHasEpsilonTransitions()
  && middleState.getNumberOfOptimizedTransitions() == 1
  && middleState.getOptimizedTransition(0).getSerializationType() == Transition.EPSILON)
  middleState = middleState.getOptimizedTransition(0).target;
if (middleState.getNumberOfOptimizedTransitions() != 1) {
  continue;
Transition matchTransition = middleState.getOptimizedTransition(0);
ATNState matchTarget = matchTransition.target;
if (matchTransition.isEpsilon()
  || !matchTarget.onlyHasEpsilonTransitions()
  || matchTarget.getNumberOfOptimizedTransitions() != 1
  || !(matchTarget.getOptimizedTransition(0).target instanceof RuleStopState))
for (int i = 0; i < state.getNumberOfOptimizedTransitions(); i++) {
  Transition transition = state.getOptimizedTransition(i);
  if (!(transition instanceof RuleTransition)) {
    if (optimizedTransitions != null) {
    optimizedTransitions = new ArrayList<Transition>();
    for (int j = 0; j < i; j++) {
      optimizedTransitions.add(state.getOptimizedTransition(i));
  ATNState target = ruleTransition.followState;
  ATNState intermediateState = new BasicState();

if (!state.onlyHasEpsilonTransitions() || state instanceof RuleStopState) {
  continue;
for (int i = 0; i < state.getNumberOfOptimizedTransitions(); i++) {
  Transition transition = state.getOptimizedTransition(i);
  ATNState intermediate = transition.target;
  if (transition.getSerializationType() != Transition.EPSILON
    || ((EpsilonTransition)transition).outermostPrecedenceReturn() != -1
    || intermediate.getStateType() != ATNState.BASIC
    || !intermediate.onlyHasEpsilonTransitions())
  for (int j = 0; j < intermediate.getNumberOfOptimizedTransitions(); j++) {
    if (intermediate.getOptimizedTransition(j).getSerializationType() != Transition.EPSILON
      || ((EpsilonTransition)intermediate.getOptimizedTransition(j)).outermostPrecedenceReturn() != -1)
    optimizedTransitions = new ArrayList<Transition>();
    for (int j = 0; j < i; j++) {
      optimizedTransitions.add(state.getOptimizedTransition(j));
  for (int j = 0; j < intermediate.getNumberOfOptimizedTransitions(); j++) {
    ATNState target = intermediate.getOptimizedTransition(j).target;
    optimizedTransitions.add(new EpsilonTransition(target));
  if (state.isOptimized()) {
    while (state.getNumberOfOptimizedTransitions() > 0) {
      state.removeOptimizedTransition(state.getNumberOfOptimizedTransitions() - 1);
    state.addOptimizedTransition(transition);

protected void epsilon(ATNState a, ATNState b, boolean prepend) {
  if ( a!=null ) {
    int index = prepend ? 0 : a.getNumberOfTransitions();
    a.addTransition(index, new EpsilonTransition(b));
  }
}

public <T extends ATNState> T newState(Class<T> nodeType, GrammarAST node) {
  Exception cause;
  try {
    Constructor<T> ctor = nodeType.getConstructor();
    T s = ctor.newInstance();
    if ( currentRule==null ) s.setRuleIndex(-1);
    else s.setRuleIndex(currentRule.index);
    atn.addState(s);
    return s;
  } catch (InstantiationException ex) {
    cause = ex;
  } catch (IllegalAccessException ex) {
    cause = ex;
  } catch (IllegalArgumentException ex) {
    cause = ex;
  } catch (InvocationTargetException ex) {
    cause = ex;
  } catch (NoSuchMethodException ex) {
    cause = ex;
  } catch (SecurityException ex) {
    cause = ex;
  }
  String message = String.format("Could not create %s of type %s.", ATNState.class.getName(), nodeType.getName());
  throw new UnsupportedOperationException(message, cause);
}

switch ( p.getStateType() ) {
case ATNState.RULE_STOP :

  if (epsTransition.target.getNumberOfOptimizedTransitions() != 1) {
    continue;
  Transition transition = epsTransition.target.getOptimizedTransition(0);
  if (!(transition.target instanceof BlockEndState)) {
    continue;
ATNState blockEndState = decision.getOptimizedTransition(setTransitions.getMinElement()).target.getOptimizedTransition(0).target;
IntervalSet matchSet = new IntervalSet();
for (int i = 0; i < setTransitions.getIntervals().size(); i++) {
  Interval interval = setTransitions.getIntervals().get(i);
  for (int j = interval.a; j <= interval.b; j++) {
    Transition matchTransition = decision.getOptimizedTransition(j).target.getOptimizedTransition(0);
    if (matchTransition instanceof NotSetTransition) {
      throw new UnsupportedOperationException("Not yet implemented.");
setOptimizedState.setRuleIndex(decision.ruleIndex);
atn.addState(setOptimizedState);
setOptimizedState.addTransition(newTransition);
optimizedTransitions.add(new EpsilonTransition(setOptimizedState));

if (lookToEndOfRule && config.state.onlyHasEpsilonTransitions()) {
  IntervalSet nextTokens = atn.nextTokens(config.state);
  if (nextTokens.contains(Token.EPSILON)) {

private RuleRelations extractRuleRelations(TypeMirror recognizer) {
  String serializedATN = getSerializedATN(recognizer);
  if (serializedATN == null) {
    return null;
  }
  ATN atn = new ATNDeserializer().deserialize(serializedATN.toCharArray());
  RuleRelations relations = new RuleRelations(atn.ruleToStartState.length);
  for (ATNState state : atn.states) {
    if (!state.epsilonOnlyTransitions) {
      continue;
    }
    for (Transition transition : state.getTransitions()) {
      if (transition.getSerializationType() != Transition.RULE) {
        continue;
      }
      RuleTransition ruleTransition = (RuleTransition)transition;
      relations.addRuleInvocation(state.ruleIndex, ruleTransition.target.ruleIndex);
    }
  }
  return relations;
}

srcState.addTransition(trans);
p += 6;
for (int i = 0; i < state.getNumberOfTransitions(); i++) {
  Transition t = state.transition(i);
  if (!(t instanceof RuleTransition)) {
    continue;
    for (int i = 0; i < state.getNumberOfTransitions(); i++) {
      Transition transition = state.transition(i);
      if (!(transition instanceof ActionTransition)) {
        continue;
      int actionIndex = ((ActionTransition)transition).actionIndex;
      LexerCustomAction lexerAction = new LexerCustomAction(ruleIndex, actionIndex);
      state.setTransition(i, new ActionTransition(transition.target, ruleIndex, legacyLexerActions.size(), false));
      legacyLexerActions.add(lexerAction);
      ATNState maybeLoopEndState = state.transition(state.getNumberOfTransitions() - 1).target;
      if (!(maybeLoopEndState instanceof LoopEndState)) {
        continue;
      if (maybeLoopEndState.epsilonOnlyTransitions && maybeLoopEndState.transition(0).target instanceof RuleStopState) {
        endState = state;
        break;
  matchState.addTransition(new AtomTransition(bypassStop, atn.ruleToTokenType[i]));
  bypassStart.addTransition(new EpsilonTransition(matchState));

for (int i = 0; i < s.getNumberOfTransitions(); i++) {
  Transition edge = s.transition(i);
  if ( edge instanceof RuleTransition ) {
    RuleTransition rr = ((RuleTransition)edge);
    boolean loopback = false;
    if (edge.target instanceof PlusBlockStartState) {
      loopback = s.equals(((PlusBlockStartState)edge.target).loopBackState);
      loopback = s.equals(((StarLoopEntryState)edge.target).loopBackState);
  edgeST.add("target", "s"+edge.target.stateNumber);
  edgeST.add("arrowhead", arrowhead);
  if (s.getNumberOfTransitions() > 1) {
    edgeST.add("transitionIndex", i);
st.add("name", "s"+s.stateNumber);
st.add("label", getStateLabel(s));
st.add("transitions", s.getTransitions());
dot.add("states", st);

Javadoc

The following images show the relation of states and ATNState#transitions for various grammar constructs.

Solid edges marked with an ε indicate a required EpsilonTransition.
Dashed edges indicate locations where any transition derived from Transition might appear.
Dashed nodes are place holders for either a sequence of linked BasicState states or the inclusion of a block representing a nested construct in one of the forms below.
Nodes showing multiple outgoing alternatives with a ... support any number of alternatives (one or more). Nodes without the ... only support the exact number of alternatives shown in the diagram.

Basic Blocks

Rule

Block of 1 or more alternatives

Greedy Loops

Greedy Closure: (...)*

Greedy Positive Closure: (...)+

Greedy Optional: (...)?

Non-Greedy Loops

Non-Greedy Closure: (...)*?

Non-Greedy Positive Closure: (...)+?

Non-Greedy Optional: (...)??

Most used methods

getStateType
getNumberOfTransitions
transition
addTransition
setTransition
getTransitions
setRuleIndex
equals
onlyHasEpsilonTransitions
addOptimizedTransition
getNonStopStateNumber
For all states except RuleStopState, this returns the state number. Returns -1 for stop states.
getNumberOfOptimizedTransitions

Popular in Java

Reading from database using SQL prepared statement
scheduleAtFixedRate (Timer)
compareTo (BigDecimal)
getSystemService (Context)
BufferedReader (java.io)
Wraps an existing Reader and buffers the input. Expensive interaction with the underlying reader is
Vector (java.util)
Vector is an implementation of List, backed by an array and synchronized. All optional operations in
CountDownLatch (java.util.concurrent)
A synchronization aid that allows one or more threads to wait until a set of operations being perfor
JOptionPane (javax.swing)
FileUtils (org.apache.commons.io)
General file manipulation utilities. Facilities are provided in the following areas: * writing to a
DateTimeFormat (org.joda.time.format)
Factory that creates instances of DateTimeFormatter from patterns and styles. Datetime formatting i
Best IntelliJ plugins

How to useATNState in org.antlr.v4.runtime.atn

Best Java code snippets using org.antlr.v4.runtime.atn.ATNState (Showing top 20 results out of 315)

How to use
ATNState
in
org.antlr.v4.runtime.atn