java类org.antlr.v4.runtime.atn.ATN的实例源码

public final Inclusive_or_expressionContext inclusive_or_expression() throws RecognitionException {
    Inclusive_or_expressionContext _localctx = new Inclusive_or_expressionContext(_ctx, getState());
    enterRule(_localctx, 264, RULE_inclusive_or_expression);
    try {
        int _alt;
        enterOuterAlt(_localctx, 1);
        {
            setState(1384);
            exclusive_or_expression();
            setState(1389);
            _errHandler.sync(this);
            _alt = getInterpreter().adaptivePredict(_input, 156, _ctx);
            while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
                if (_alt == 1) {
                    {
                        {
                            setState(1385);
                            match(BITOR);
                            setState(1386);
                            exclusive_or_expression();
                        }
                    }
                }
                setState(1391);
                _errHandler.sync(this);
                _alt = getInterpreter().adaptivePredict(_input, 156, _ctx);
            }
        }
    } catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    } finally {
        exitRule();
    }
    return _localctx;
}

public final Exclusive_or_expressionContext exclusive_or_expression() throws RecognitionException {
    Exclusive_or_expressionContext _localctx = new Exclusive_or_expressionContext(_ctx, getState());
    enterRule(_localctx, 266, RULE_exclusive_or_expression);
    try {
        int _alt;
        enterOuterAlt(_localctx, 1);
        {
            setState(1392);
            and_expression();
            setState(1397);
            _errHandler.sync(this);
            _alt = getInterpreter().adaptivePredict(_input, 157, _ctx);
            while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
                if (_alt == 1) {
                    {
                        {
                            setState(1393);
                            match(CARET);
                            setState(1394);
                            and_expression();
                        }
                    }
                }
                setState(1399);
                _errHandler.sync(this);
                _alt = getInterpreter().adaptivePredict(_input, 157, _ctx);
            }
        }
    } catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    } finally {
        exitRule();
    }
    return _localctx;
}

public final And_expressionContext and_expression() throws RecognitionException {
    And_expressionContext _localctx = new And_expressionContext(_ctx, getState());
    enterRule(_localctx, 268, RULE_and_expression);
    try {
        int _alt;
        enterOuterAlt(_localctx, 1);
        {
            setState(1400);
            equality_expression();
            setState(1405);
            _errHandler.sync(this);
            _alt = getInterpreter().adaptivePredict(_input, 158, _ctx);
            while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
                if (_alt == 1) {
                    {
                        {
                            setState(1401);
                            match(BITAND);
                            setState(1402);
                            equality_expression();
                        }
                    }
                }
                setState(1407);
                _errHandler.sync(this);
                _alt = getInterpreter().adaptivePredict(_input, 158, _ctx);
            }
        }
    } catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    } finally {
        exitRule();
    }
    return _localctx;
}

public final Equality_expressionContext equality_expression() throws RecognitionException {
    Equality_expressionContext _localctx = new Equality_expressionContext(_ctx, getState());
    enterRule(_localctx, 270, RULE_equality_expression);
    try {
        int _alt;
        enterOuterAlt(_localctx, 1);
        {
            setState(1408);
            relational_expression();
            setState(1414);
            _errHandler.sync(this);
            _alt = getInterpreter().adaptivePredict(_input, 159, _ctx);
            while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
                if (_alt == 1) {
                    {
                        {
                            setState(1409);
                            equality_op();
                            setState(1410);
                            relational_expression();
                        }
                    }
                }
                setState(1416);
                _errHandler.sync(this);
                _alt = getInterpreter().adaptivePredict(_input, 159, _ctx);
            }
        }
    } catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    } finally {
        exitRule();
    }
    return _localctx;
}

public final Relational_expressionContext relational_expression() throws RecognitionException {
    Relational_expressionContext _localctx = new Relational_expressionContext(_ctx, getState());
    enterRule(_localctx, 274, RULE_relational_expression);
    try {
        int _alt;
        enterOuterAlt(_localctx, 1);
        {
            setState(1419);
            shift_expression();
            setState(1425);
            _errHandler.sync(this);
            _alt = getInterpreter().adaptivePredict(_input, 160, _ctx);
            while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
                if (_alt == 1) {
                    {
                        {
                            setState(1420);
                            relational_op();
                            setState(1421);
                            shift_expression();
                        }
                    }
                }
                setState(1427);
                _errHandler.sync(this);
                _alt = getInterpreter().adaptivePredict(_input, 160, _ctx);
            }
        }
    } catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    } finally {
        exitRule();
    }
    return _localctx;
}

public final Shift_expressionContext shift_expression() throws RecognitionException {
    Shift_expressionContext _localctx = new Shift_expressionContext(_ctx, getState());
    enterRule(_localctx, 278, RULE_shift_expression);
    try {
        int _alt;
        enterOuterAlt(_localctx, 1);
        {
            setState(1430);
            additive_expression();
            setState(1436);
            _errHandler.sync(this);
            _alt = getInterpreter().adaptivePredict(_input, 161, _ctx);
            while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
                if (_alt == 1) {
                    {
                        {
                            setState(1431);
                            shift_op();
                            setState(1432);
                            additive_expression();
                        }
                    }
                }
                setState(1438);
                _errHandler.sync(this);
                _alt = getInterpreter().adaptivePredict(_input, 161, _ctx);
            }
        }
    } catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    } finally {
        exitRule();
    }
    return _localctx;
}

public final Additive_expressionContext additive_expression() throws RecognitionException {
    Additive_expressionContext _localctx = new Additive_expressionContext(_ctx, getState());
    enterRule(_localctx, 282, RULE_additive_expression);
    try {
        int _alt;
        enterOuterAlt(_localctx, 1);
        {
            setState(1441);
            multiplicative_expression();
            setState(1447);
            _errHandler.sync(this);
            _alt = getInterpreter().adaptivePredict(_input, 162, _ctx);
            while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
                if (_alt == 1) {
                    {
                        {
                            setState(1442);
                            add_op();
                            setState(1443);
                            multiplicative_expression();
                        }
                    }
                }
                setState(1449);
                _errHandler.sync(this);
                _alt = getInterpreter().adaptivePredict(_input, 162, _ctx);
            }
        }
    } catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    } finally {
        exitRule();
    }
    return _localctx;
}

public final Multiplicative_expressionContext multiplicative_expression() throws RecognitionException {
    Multiplicative_expressionContext _localctx = new Multiplicative_expressionContext(_ctx, getState());
    enterRule(_localctx, 286, RULE_multiplicative_expression);
    try {
        int _alt;
        enterOuterAlt(_localctx, 1);
        {
            setState(1452);
            cast_expression();
            setState(1458);
            _errHandler.sync(this);
            _alt = getInterpreter().adaptivePredict(_input, 163, _ctx);
            while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
                if (_alt == 1) {
                    {
                        {
                            setState(1453);
                            multiply_op();
                            setState(1454);
                            cast_expression();
                        }
                    }
                }
                setState(1460);
                _errHandler.sync(this);
                _alt = getInterpreter().adaptivePredict(_input, 163, _ctx);
            }
        }
    } catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    } finally {
        exitRule();
    }
    return _localctx;
}

public final Postfix_expressionContext postfix_expression() throws RecognitionException {
    Postfix_expressionContext _localctx = new Postfix_expressionContext(_ctx, getState());
    enterRule(_localctx, 296, RULE_postfix_expression);
    try {
        int _alt;
        enterOuterAlt(_localctx, 1);
        {
            setState(1491);
            primary_expression();
            setState(1495);
            _errHandler.sync(this);
            _alt = getInterpreter().adaptivePredict(_input, 167, _ctx);
            while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
                if (_alt == 1) {
                    {
                        {
                            setState(1492);
                            postfix_expression_complete();
                        }
                    }
                }
                setState(1497);
                _errHandler.sync(this);
                _alt = getInterpreter().adaptivePredict(_input, 167, _ctx);
            }
        }
    } catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    } finally {
        exitRule();
    }
    return _localctx;
}

public ATN checkAndClear() {
    if (0 != counter.incrementAndGet() % DFA_CACHE_THRESHOLD) {
        return atn;
    }

    RRWL.writeLock().lock();
    try {
        atn.clearDFA();
    } finally {
        RRWL.writeLock().unlock();
    }

    return atn;
}