Java 类org.antlr.v4.runtime.atn.LexerATNSimulator 实例源码

public LexerInterpreter(String grammarFileName, Collection<String> tokenNames, Collection<String> ruleNames, Collection<String> modeNames, ATN atn, CharStream input) {
    super(input);

    if (atn.grammarType != ATNType.LEXER) {
        throw new IllegalArgumentException("The ATN must be a lexer ATN.");
    }

    this.grammarFileName = grammarFileName;
    this.atn = atn;
    this.tokenNames = tokenNames.toArray(new String[tokenNames.size()]);
    this.ruleNames = ruleNames.toArray(new String[ruleNames.size()]);
    this.modeNames = modeNames.toArray(new String[modeNames.size()]);

    this._decisionToDFA = new DFA[atn.getNumberOfDecisions()];
    for (int i = 0; i < _decisionToDFA.length; i++) {
        _decisionToDFA[i] = new DFA(atn.getDecisionState(i), i);
    }
    this._interp = new LexerATNSimulator(this,atn,_decisionToDFA,_sharedContextCache);
}

public FunctionExpressionLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}

public CLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public FWPolicyLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA,
            _sharedContextCache);
}

public SqlGrammarLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}

public FWPolicyLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA,
            _sharedContextCache);
}

public CypherLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public ExpressionEditorLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public Verilog2001Lexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public ObjCLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}

public HelloLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}

public AccountingLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public FunctionExpressionLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}

public FWPolicyLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA,
            _sharedContextCache);
}

/**
 * Instantiates a new expression constraint lexer.
 *
 * @param input the input
 */
public ExpressionConstraintLexer(CharStream input) {
  super(input);
  _interp =
      new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}

public EditorConfigLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}

public SkinnyLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public tlvLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public ByteRegexLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public CliLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public QuestionnaireLexer( CharStream input )
{
    super( input );
    _interp = new LexerATNSimulator( this, _ATN, _decisionToDFA, _sharedContextCache );
}

public QLLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}

public MemoryModelLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}

public PSHDLLangLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}

public void pushMode(int m) {
    if ( LexerATNSimulator.debug ) System.out.println("pushMode "+m);
    _modeStack.push(_mode);
    mode(m);
}

public int popMode() {
    if ( _modeStack.isEmpty() ) throw new EmptyStackException();
    if ( LexerATNSimulator.debug ) System.out.println("popMode back to "+ _modeStack.peek());
    mode( _modeStack.pop() );
    return _mode;
}

public Sql92ParserLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public CommonLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public DateLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public Java8Lexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}

public CLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}

public EditorConfigLexer(CharStream input) {
  super(input);
  _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache);
}

/**
 * Implements Lexer's next token with extra token passing from
 * recovery function
 */
public Token nextToken() {

    if(lexer._input == null) {
        throw new IllegalStateException("nextToken requires a non-null input stream.");
    } else {
        int tokenStartMarker = lexer._input.mark();

        try {
            Token ttype1;
            label110:
            while(!lexer._hitEOF) {
                lexer._token = null;
                lexer._channel = Token.DEFAULT_CHANNEL;
                lexer._tokenStartCharIndex = lexer._input.index();
                lexer._tokenStartCharPositionInLine = ((LexerATNSimulator)lexer.getInterpreter()).getCharPositionInLine();
                lexer._tokenStartLine = ((LexerATNSimulator)lexer.getInterpreter()).getLine();
                lexer._text = null;


                do {
                    lexer._type = 0;

                    int ttype;
                    try {
                        ttype = ((LexerATNSimulator)lexer.getInterpreter()).match(lexer._input, lexer._mode);
                    } catch (LexerNoViableAltException var7) {
                        lexer.notifyListeners(var7);
                        lexer.recover(var7);
                        ttype = -3;
                    }

                    if(lexer._input.LA(1) == -1) {
                        lexer._hitEOF = true;
                    }

                    if(lexer._type == 0) {
                        lexer._type = ttype;
                    }

                    if(lexer._type == -3) {
                        continue label110;
                    }
                } while(lexer._type == -2);

                if(lexer._token == null) {
                    lexer.emit();
                }

                ttype1 = lexer._token;
                //log.trace("return token: >" + ttype1.getText()+"< " + ttype1.getType());
                return ttype1;
            }
            // recover from unexpected EOF
            eof = true;
            if (!ls.isBalanced()) {
                return generateEOFRecover();
            }
            log.trace("lexer state is balanced - emitEOF");
            lexer.emitEOF();
            ttype1 = lexer._token;
            return ttype1;
        } finally {
            lexer._input.release(tokenStartMarker);
        }
    }
}

public WindowLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public SELECTLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public JKVCLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}

public JavaLexer(CharStream input) {
    super(input);
    _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}