How to use

AtomTransition

in

org.antlr.v4.runtime.atn

/**
 * If {@code codePoint} is <= U+FFFF, returns a new {@link AtomTransition}.
 * Otherwise, returns a new {@link SetTransition}.
 */
public static Transition createWithCodePoint(ATNState target, int codePoint) {
  if (Character.isSupplementaryCodePoint(codePoint)) {
    return new SetTransition(target, IntervalSet.of(codePoint));
  }
  else {
    return new AtomTransition(target, codePoint);
  }
}

case Transition.ATOM :
  if (arg3 != 0) {
    return new AtomTransition(target, Token.EOF);
    return new AtomTransition(target, arg1);

matchState.addTransition(new AtomTransition(bypassStop, atn.ruleToTokenType[i]));
bypassStart.addTransition(new EpsilonTransition(matchState));

/**
 * If {@code codePoint} is <= U+FFFF, returns a new {@link AtomTransition}.
 * Otherwise, returns a new {@link SetTransition}.
 */
public static Transition createWithCodePoint(ATNState target, int codePoint) {
  if (Character.isSupplementaryCodePoint(codePoint)) {
    return new SetTransition(target, IntervalSet.of(codePoint));
  }
  else {
    return new AtomTransition(target, codePoint);
  }
}

/**
 * If {@code codePoint} is <= U+FFFF, returns a new {@link AtomTransition}.
 * Otherwise, returns a new {@link SetTransition}.
 */
public static Transition createWithCodePoint(ATNState target, int codePoint) {
  if (Character.isSupplementaryCodePoint(codePoint)) {
    return new SetTransition(target, IntervalSet.of(codePoint));
  }
  else {
    return new AtomTransition(target, codePoint);
  }
}

@Override
public Handle tokenRef(TerminalAST node) {
  // Ref to EOF in lexer yields char transition on -1
  if (node.getText().equals("EOF") ) {
    ATNState left = newState(node);
    ATNState right = newState(node);
    left.addTransition(new AtomTransition(right, IntStream.EOF));
    return new Handle(left, right);
  }
  return _ruleRef(node);
}

@Override
public Handle tokenRef(TerminalAST node) {
  // Ref to EOF in lexer yields char transition on -1
  if ( node.getText().equals("EOF") ) {
    ATNState left = newState(node);
    ATNState right = newState(node);
    left.addTransition(new AtomTransition(right, IntStream.EOF));
    return new Handle(left, right);
  }
  return _ruleRef(node);
}

@Override
public Handle tokenRef(TerminalAST node) {
  // Ref to EOF in lexer yields char transition on -1
  if (node.getText().equals("EOF") ) {
    ATNState left = newState(node);
    ATNState right = newState(node);
    left.addTransition(new AtomTransition(right, IntStream.EOF));
    return new Handle(left, right);
  }
  return _ruleRef(node);
}

@Override
public Handle tokenRef(TerminalAST node) {
  // Ref to EOF in lexer yields char transition on -1
  if ( node.getText().equals("EOF") ) {
    ATNState left = newState(node);
    ATNState right = newState(node);
    left.addTransition(new AtomTransition(right, IntStream.EOF));
    return new Handle(left, right);
  }
  return _ruleRef(node);
}

@Override
public Handle tokenRef(TerminalAST node) {
  // Ref to EOF in lexer yields char transition on -1
  if ( node.getText().equals("EOF") ) {
    ATNState left = newState(node);
    ATNState right = newState(node);
    left.addTransition(new AtomTransition(right, IntStream.EOF));
    return new Handle(left, right);
  }
  return _ruleRef(node);
}

/** For a lexer, a string is a sequence of char to match.  That is,
 *  "fog" is treated as 'f' 'o' 'g' not as a single transition in
 *  the DFA.  Machine== o-'f'->o-'o'->o-'g'->o and has n+1 states
 *  for n characters.
 */
@Override
public Handle stringLiteral(TerminalAST stringLiteralAST) {
  String chars = stringLiteralAST.getText();
  chars = CharSupport.getStringFromGrammarStringLiteral(chars);
  int n = chars.length();
  ATNState left = newState(stringLiteralAST);
  ATNState prev = left;
  ATNState right = null;
  for (int i=0; i<n; i++) {
    right = newState(stringLiteralAST);
    prev.addTransition(new AtomTransition(right, chars.charAt(i)));
    prev = right;
  }
  stringLiteralAST.atnState = left;
  return new Handle(left, right);
}

/** For a lexer, a string is a sequence of char to match.  That is,
 *  "fog" is treated as 'f' 'o' 'g' not as a single transition in
 *  the DFA.  Machine== o-'f'->o-'o'->o-'g'->o and has n+1 states
 *  for n characters.
 */
@Override
public Handle stringLiteral(TerminalAST stringLiteralAST) {
  String chars = stringLiteralAST.getText();
  chars = CharSupport.getStringFromGrammarStringLiteral(chars);
  int n = chars.length();
  ATNState left = newState(stringLiteralAST);
  ATNState prev = left;
  ATNState right = null;
  for (int i=0; i<n; i++) {
    right = newState(stringLiteralAST);
    prev.addTransition(new AtomTransition(right, chars.charAt(i)));
    prev = right;
  }
  stringLiteralAST.atnState = left;
  return new Handle(left, right);
}

case Transition.ATOM :
  if (arg3 != 0) {
    return new AtomTransition(target, Token.EOF);
    return new AtomTransition(target, arg1);

case Transition.ATOM :
  if (arg3 != 0) {
    return new AtomTransition(target, Token.EOF);
    return new AtomTransition(target, arg1);

case Transition.ATOM :
  if (arg3 != 0) {
    return new AtomTransition(target, Token.EOF);
    return new AtomTransition(target, arg1);

/** Add an EOF transition to any rule end ATNState that points to nothing
 *  (i.e., for all those rules not invoked by another rule).  These
 *  are start symbols then.
 *
 *  Return the number of grammar entry points; i.e., how many rules are
 *  not invoked by another rule (they can only be invoked from outside).
 *  These are the start rules.
 */
public int addEOFTransitionToStartRules() {
  int n = 0;
  ATNState eofTarget = newState(null); // one unique EOF target for all rules
  for (Rule r : g.rules.values()) {
    ATNState stop = atn.ruleToStopState[r.index];
    if ( stop.getNumberOfTransitions()>0 ) continue;
    n++;
    Transition t = new AtomTransition(eofTarget, Token.EOF);
    stop.addTransition(t);
  }
  return n;
}

/** Add an EOF transition to any rule end ATNState that points to nothing
 *  (i.e., for all those rules not invoked by another rule).  These
 *  are start symbols then.
 *
 *  Return the number of grammar entry points; i.e., how many rules are
 *  not invoked by another rule (they can only be invoked from outside).
 *  These are the start rules.
 */
public int addEOFTransitionToStartRules() {
  int n = 0;
  ATNState eofTarget = newState(null); // one unique EOF target for all rules
  for (Rule r : g.rules.values()) {
    ATNState stop = atn.ruleToStopState[r.index];
    if ( stop.getNumberOfTransitions()>0 ) continue;
    n++;
    Transition t = new AtomTransition(eofTarget, Token.EOF);
    stop.addTransition(t);
  }
  return n;
}

/** Add an EOF transition to any rule end ATNState that points to nothing
 *  (i.e., for all those rules not invoked by another rule).  These
 *  are start symbols then.
 *
 *  Return the number of grammar entry points; i.e., how many rules are
 *  not invoked by another rule (they can only be invoked from outside).
 *  These are the start rules.
 */
public int addEOFTransitionToStartRules() {
  int n = 0;
  ATNState eofTarget = newState(null); // one unique EOF target for all rules
  for (Rule r : g.rules.values()) {
    ATNState stop = atn.ruleToStopState[r.index];
    if ( stop.getNumberOfTransitions()>0 ) continue;
    n++;
    Transition t = new AtomTransition(eofTarget, Token.EOF);
    stop.addTransition(t);
  }
  return n;
}

/** Add an EOF transition to any rule end ATNState that points to nothing
 *  (i.e., for all those rules not invoked by another rule).  These
 *  are start symbols then.
 *
 *  Return the number of grammar entry points; i.e., how many rules are
 *  not invoked by another rule (they can only be invoked from outside).
 *  These are the start rules.
 */
public int addEOFTransitionToStartRules() {
  int n = 0;
  ATNState eofTarget = newState(null); // one unique EOF target for all rules
  for (Rule r : g.rules.values()) {
    ATNState stop = atn.ruleToStopState[r.index];
    if ( stop.getNumberOfTransitions()>0 ) continue;
    n++;
    Transition t = new AtomTransition(eofTarget, Token.EOF);
    stop.addTransition(t);
  }
  return n;
}

/** Add an EOF transition to any rule end ATNState that points to nothing
 *  (i.e., for all those rules not invoked by another rule).  These
 *  are start symbols then.
 *
 *  Return the number of grammar entry points; i.e., how many rules are
 *  not invoked by another rule (they can only be invoked from outside).
 *  These are the start rules.
 */
public int addEOFTransitionToStartRules() {
  int n = 0;
  ATNState eofTarget = newState(null); // one unique EOF target for all rules
  for (Rule r : g.rules.values()) {
    ATNState stop = atn.ruleToStopState[r.index];
    if ( stop.getNumberOfTransitions()>0 ) continue;
    n++;
    Transition t = new AtomTransition(eofTarget, Token.EOF);
    stop.addTransition(t);
  }
  return n;
}