How to use

Transition

in

org.antlr.v4.runtime.atn

  activeStates.add(new ParsingState(transition.target, tokenIndex, new CallerContext(caller, ((RuleTransition) transition).followState)));
else if (transition.isEpsilon()) {
  activeStates.add(new ParsingState(transition.target, tokenIndex, caller));
  IntervalSet labels = transition.label();

               boolean treatEofAsEpsilon)
switch (t.getSerializationType()) {
case Transition.RULE:
  return ruleTransition(config, (RuleTransition)t);
    if (t.matches(Token.EOF, 0, 1)) {
      return new ATNConfig(config, t.target);

if (!t.isEpsilon() && !closureBusy.add(c)) {

while (middleState.onlyHasEpsilonTransitions()
  && middleState.getNumberOfOptimizedTransitions() == 1
  && middleState.getOptimizedTransition(0).getSerializationType() == Transition.EPSILON)
if (matchTransition.isEpsilon()
  || !matchTarget.onlyHasEpsilonTransitions()
  || matchTarget.getNumberOfOptimizedTransitions() != 1
switch (matchTransition.getSerializationType()) {
case Transition.ATOM:
case Transition.RANGE:
  optimizedTransitions.add(new EpsilonTransition(intermediateState));
  switch (effective.getSerializationType()) {
  case Transition.ATOM:
    intermediateState.addTransition(new AtomTransition(target, ((AtomTransition)effective).label));
    intermediateState.addTransition(new SetTransition(target, effective.label()));
    break;

  throw new UnsupportedOperationException("Not yet implemented.");
} else {
  matchSet.addAll(matchTransition.label());

protected ATNState getReachableTarget(Transition trans, int ttype) {
  if (trans.matches(ttype, 0, atn.maxTokenType)) {
    return trans.target;
  }
  return null;
}

if (t.getSerializationType() != Transition.EPSILON) {
  return false;

!returnState.transition(0).isEpsilon() )
returnStateTarget.transition(0).isEpsilon() &&
returnStateTarget.transition(0).target == p )

  throw new UnsupportedOperationException("Not yet implemented.");
IntervalSet set =  matchTransition.label();
List<Interval> intervals = set.getIntervals();
int n = intervals.size();

protected ATNState getReachableTarget(Transition trans, int t) {
  if (trans.matches(t, Lexer.MIN_CHAR_VALUE, Lexer.MAX_CHAR_VALUE)) {
    return trans.target;
  }
  return null;
}

if (transition.getSerializationType() != Transition.EPSILON) {
  continue;

  public void addTransition(int index, Transition e) {
    if (transitions.isEmpty()) {
      epsilonOnlyTransitions = e.isEpsilon();
    }
    else if (epsilonOnlyTransitions != e.isEpsilon()) {
      System.err.format(Locale.getDefault(), "ATN state %d has both epsilon and non-epsilon transitions.\n", stateNumber);
      epsilonOnlyTransitions = false;
    }

    boolean alreadyPresent = false;
    for (Transition t : transitions) {
      if ( t.target.stateNumber == e.target.stateNumber ) {
        if ( t.label()!=null && e.label()!=null && t.label().equals(e.label()) ) {
//                    System.err.println("Repeated transition upon "+e.label()+" from "+stateNumber+"->"+t.target.stateNumber);
          alreadyPresent = true;
          break;
        }
        else if ( t.isEpsilon() && e.isEpsilon() ) {
//                    System.err.println("Repeated epsilon transition from "+stateNumber+"->"+t.target.stateNumber);
          alreadyPresent = true;
          break;
        }
      }
    }
    if ( !alreadyPresent ) {
      transitions.add(index, e);
    }
  }

public void addTransition(int index, Transition e) {
  if (transitions.isEmpty()) {
    epsilonOnlyTransitions = e.isEpsilon();
  }
  else if (epsilonOnlyTransitions != e.isEpsilon()) {
    System.err.format(Locale.getDefault(), "ATN state %d has both epsilon and non-epsilon transitions.\n", stateNumber);
    epsilonOnlyTransitions = false;
  }
  transitions.add(index, e);
}

switch (t.getSerializationType()) {
  case Transition.RULE:
    RuleTransition ruleTransition = (RuleTransition)t;
  case Transition.SET:
    if (treatEofAsEpsilon) {
      if (t.matches(CharStream.EOF, Lexer.MIN_CHAR_VALUE, Lexer.MAX_CHAR_VALUE)) {
        c = new LexerATNConfig(config, t.target);
        break;

  throw new UnsupportedOperationException("Not yet implemented.");
IntervalSet set =  matchTransition.label();
List<Interval> intervals = set.getIntervals();
int n = intervals.size();

protected ATNState getReachableTarget(Transition trans, int t) {
  if (trans.matches(t, Character.MIN_VALUE, Character.MAX_VALUE)) {
    return trans.target;
  }
  return null;
}

protected final ParserRuleContext skipTailCalls(ParserRuleContext context) {
  if (!optimize_tail_calls) {
    return context;
  }
  while (!context.isEmpty()) {
    ATNState state = atn.states.get(context.invokingState);
    assert state.getNumberOfTransitions() == 1 && state.transition(0).getSerializationType() == Transition.RULE;
    RuleTransition transition = (RuleTransition)state.transition(0);
    if (!transition.tailCall) {
      break;
    }
    context = context.getParent();
  }
  return context;
}

else if ( t.isEpsilon() ) {
  _LOOK(t.target, stopState, ctx, look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
  IntervalSet set = t.label();
  if (set != null) {
    if (t instanceof NotSetTransition) {

public void addTransition(int index, Transition e) {
  if (transitions.isEmpty()) {
    epsilonOnlyTransitions = e.isEpsilon();
  }
  else if (epsilonOnlyTransitions != e.isEpsilon()) {
    System.err.format(Locale.getDefault(), "ATN state %d has both epsilon and non-epsilon transitions.\n", stateNumber);
    epsilonOnlyTransitions = false;
  }
  transitions.add(index, e);
}

switch (transition.getSerializationType()) {
  case Transition.EPSILON:
    if ( p.getStateType()==ATNState.STAR_LOOP_ENTRY &&
  case Transition.SET:
  case Transition.NOT_SET:
    if (!transition.matches(_input.LA(1), Token.MIN_USER_TOKEN_TYPE, 65535)) {
      recoverInline();