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

protected void reportNoViableAlternative(@NotNull Parser recognizer, @NotNull NoViableAltException e)
{
    TokenStream tokens = recognizer.getInputStream();
    String input;
    if (tokens instanceof TokenStream)
    {
        if (e.getStartToken().getType() == Token.EOF)
            input = "<文件尾>";
        else
            input = tokens.getText(e.getStartToken(), e.getOffendingToken());
    }
    else
    {
        input = "<未知输入>";
    }
    BeetlException exception = null;
    if(keys.contains(e.getOffendingToken().getText())){
         exception = new BeetlParserException(BeetlException.PARSER_VIABLE_ERROR,
                    "不允许"+e.getOffendingToken().getText()+"关键出现在这里"+":"+escapeWSAndQuote(input), e);
    }else{
        exception = new BeetlParserException(BeetlException.PARSER_VIABLE_ERROR,
                escapeWSAndQuote(input), e);
    }
    //      String msg = "no viable alternative at input " + escapeWSAndQuote(input);

    exception.pushToken(this.getGrammarToken(e.getOffendingToken()));

    throw exception;
}

public final PortContext port() throws RecognitionException {
    PortContext _localctx = new PortContext(_ctx, getState());
    enterRule(_localctx, 32, RULE_port);
    int _la;
    try {
        setState(811);
        switch (_input.LA(1)) {
        case T__16:
        case T__17:
        case T__18:
        case Escaped_identifier:
        case Simple_identifier:
            enterOuterAlt(_localctx, 1);
            {
            setState(801);
            _la = _input.LA(1);
            if (_la==T__18 || _la==Escaped_identifier || _la==Simple_identifier) {
                {
                setState(800);
                port_expression();
                }
            }

            }
            break;
        case T__4:
            enterOuterAlt(_localctx, 2);
            {
            setState(803);
            match(T__4);
            setState(804);
            port_identifier();
            setState(805);
            match(T__15);
            setState(807);
            _la = _input.LA(1);
            if (_la==T__18 || _la==Escaped_identifier || _la==Simple_identifier) {
                {
                setState(806);
                port_expression();
                }
            }

            setState(809);
            match(T__17);
            }
            break;
        default:
            throw new NoViableAltException(this);
        }
    }
    catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    }
    finally {
        exitRule();
    }
    return _localctx;
}

public final Port_expressionContext port_expression() throws RecognitionException {
    Port_expressionContext _localctx = new Port_expressionContext(_ctx, getState());
    enterRule(_localctx, 34, RULE_port_expression);
    int _la;
    try {
        setState(825);
        switch (_input.LA(1)) {
        case Escaped_identifier:
        case Simple_identifier:
            enterOuterAlt(_localctx, 1);
            {
            setState(813);
            port_reference();
            }
            break;
        case T__18:
            enterOuterAlt(_localctx, 2);
            {
            setState(814);
            match(T__18);
            setState(815);
            port_reference();
            setState(820);
            _errHandler.sync(this);
            _la = _input.LA(1);
            while (_la==T__16) {
                {
                {
                setState(816);
                match(T__16);
                setState(817);
                port_reference();
                }
                }
                setState(822);
                _errHandler.sync(this);
                _la = _input.LA(1);
            }
            setState(823);
            match(T__19);
            }
            break;
        default:
            throw new NoViableAltException(this);
        }
    }
    catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    }
    finally {
        exitRule();
    }
    return _localctx;
}

public final Function_item_declarationContext function_item_declaration() throws RecognitionException {
    Function_item_declarationContext _localctx = new Function_item_declarationContext(_ctx, getState());
    enterRule(_localctx, 142, RULE_function_item_declaration);
    try {
        setState(1643);
        switch (_input.LA(1)) {
        case T__15:
        case T__23:
        case T__25:
        case T__26:
        case T__27:
        case T__28:
        case T__29:
        case T__34:
        case T__35:
            enterOuterAlt(_localctx, 1);
            {
            setState(1639);
            block_item_declaration();
            }
            break;
        case T__31:
        case T__32:
        case T__33:
            enterOuterAlt(_localctx, 2);
            {
            setState(1640);
            tf_declaration();
            setState(1641);
            match(T__1);
            }
            break;
        default:
            throw new NoViableAltException(this);
        }
    }
    catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    }
    finally {
        exitRule();
    }
    return _localctx;
}

public final Range_or_typeContext range_or_type() throws RecognitionException {
    Range_or_typeContext _localctx = new Range_or_typeContext(_ctx, getState());
    enterRule(_localctx, 148, RULE_range_or_type);
    try {
        setState(1666);
        switch (_input.LA(1)) {
        case T__20:
            enterOuterAlt(_localctx, 1);
            {
            setState(1661);
            range();
            }
            break;
        case T__25:
            enterOuterAlt(_localctx, 2);
            {
            setState(1662);
            match(T__25);
            }
            break;
        case T__26:
            enterOuterAlt(_localctx, 3);
            {
            setState(1663);
            match(T__26);
            }
            break;
        case T__27:
            enterOuterAlt(_localctx, 4);
            {
            setState(1664);
            match(T__27);
            }
            break;
        case T__28:
            enterOuterAlt(_localctx, 5);
            {
            setState(1665);
            match(T__28);
            }
            break;
        default:
            throw new NoViableAltException(this);
        }
    }
    catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    }
    finally {
        exitRule();
    }
    return _localctx;
}

public final Delay_or_event_controlContext delay_or_event_control() throws RecognitionException {
    Delay_or_event_controlContext _localctx = new Delay_or_event_controlContext(_ctx, getState());
    enterRule(_localctx, 294, RULE_delay_or_event_control);
    try {
        setState(2633);
        switch (_input.LA(1)) {
        case T__14:
            enterOuterAlt(_localctx, 1);
            {
            setState(2625);
            delay_control();
            }
            break;
        case T__116:
            enterOuterAlt(_localctx, 2);
            {
            setState(2626);
            event_control();
            }
            break;
        case T__114:
            enterOuterAlt(_localctx, 3);
            {
            setState(2627);
            match(T__114);
            setState(2628);
            match(T__15);
            setState(2629);
            expression();
            setState(2630);
            match(T__17);
            setState(2631);
            event_control();
            }
            break;
        default:
            throw new NoViableAltException(this);
        }
    }
    catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    }
    finally {
        exitRule();
    }
    return _localctx;
}

public final Event_expressionContext event_expression() throws RecognitionException {
    Event_expressionContext _localctx = new Event_expressionContext(_ctx, getState());
    enterRule(_localctx, 304, RULE_event_expression);
    int _la;
    try {
        enterOuterAlt(_localctx, 1);
        {
        setState(2673);
        event_primary();
        setState(2680);
        _errHandler.sync(this);
        _la = _input.LA(1);
        while (_la==T__16 || _la==T__84) {
            {
            setState(2678);
            switch (_input.LA(1)) {
            case T__84:
                {
                setState(2674);
                match(T__84);
                setState(2675);
                event_primary();
                }
                break;
            case T__16:
                {
                setState(2676);
                match(T__16);
                setState(2677);
                event_primary();
                }
                break;
            default:
                throw new NoViableAltException(this);
            }
            }
            setState(2682);
            _errHandler.sync(this);
            _la = _input.LA(1);
        }
        }
    }
    catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    }
    finally {
        exitRule();
    }
    return _localctx;
}

public final Event_primaryContext event_primary() throws RecognitionException {
    Event_primaryContext _localctx = new Event_primaryContext(_ctx, getState());
    enterRule(_localctx, 306, RULE_event_primary);
    try {
        enterOuterAlt(_localctx, 1);
        {
        setState(2688);
        switch (_input.LA(1)) {
        case T__15:
        case T__18:
        case T__135:
        case T__136:
        case T__140:
        case T__141:
        case T__142:
        case T__143:
        case T__144:
        case T__145:
        case T__146:
        case T__147:
        case T__148:
        case Real_number:
        case Decimal_number:
        case Binary_number:
        case Octal_number:
        case Hex_number:
        case String:
        case Escaped_identifier:
        case Simple_identifier:
        case Dollar_Identifier:
            {
            setState(2683);
            expression();
            }
            break;
        case T__119:
            {
            setState(2684);
            match(T__119);
            setState(2685);
            expression();
            }
            break;
        case T__120:
            {
            setState(2686);
            match(T__120);
            setState(2687);
            expression();
            }
            break;
        default:
            throw new NoViableAltException(this);
        }
        }
    }
    catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    }
    finally {
        exitRule();
    }
    return _localctx;
}

public final Specify_itemContext specify_item() throws RecognitionException {
    Specify_itemContext _localctx = new Specify_itemContext(_ctx, getState());
    enterRule(_localctx, 338, RULE_specify_item);
    try {
        setState(2982);
        switch (_input.LA(1)) {
        case T__30:
            enterOuterAlt(_localctx, 1);
            {
            setState(2978);
            specparam_declaration();
            }
            break;
        case T__128:
        case T__129:
            enterOuterAlt(_localctx, 2);
            {
            setState(2979);
            pulsestyle_declaration();
            }
            break;
        case T__130:
        case T__131:
            enterOuterAlt(_localctx, 3);
            {
            setState(2980);
            showcancelled_declaration();
            }
            break;
        case T__15:
        case T__98:
        case T__134:
        case Escaped_identifier:
        case Simple_identifier:
            enterOuterAlt(_localctx, 4);
            {
            setState(2981);
            path_declaration();
            }
            break;
        default:
            throw new NoViableAltException(this);
        }
    }
    catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    }
    finally {
        exitRule();
    }
    return _localctx;
}

public final Pulsestyle_declarationContext pulsestyle_declaration() throws RecognitionException {
    Pulsestyle_declarationContext _localctx = new Pulsestyle_declarationContext(_ctx, getState());
    enterRule(_localctx, 340, RULE_pulsestyle_declaration);
    try {
        setState(2992);
        switch (_input.LA(1)) {
        case T__128:
            enterOuterAlt(_localctx, 1);
            {
            setState(2984);
            match(T__128);
            setState(2985);
            list_of_path_outputs();
            setState(2986);
            match(T__1);
            }
            break;
        case T__129:
            enterOuterAlt(_localctx, 2);
            {
            setState(2988);
            match(T__129);
            setState(2989);
            list_of_path_outputs();
            setState(2990);
            match(T__1);
            }
            break;
        default:
            throw new NoViableAltException(this);
        }
    }
    catch (RecognitionException re) {
        _localctx.exception = re;
        _errHandler.reportError(this, re);
        _errHandler.recover(this, re);
    }
    finally {
        exitRule();
    }
    return _localctx;
}