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

public static List<TerminalNode> getAllRuleRefNodes(Parser parser, ParseTree tree, String ruleName) {
    List<TerminalNode> nodes = new ArrayList<TerminalNode>();
    Collection<ParseTree> ruleRefs;
    if ( Grammar.isTokenName(ruleName) ) {
        ruleRefs = XPath.findAll(tree, "//lexerRuleBlock//TOKEN_REF", parser);
    }
    else {
        ruleRefs = XPath.findAll(tree, "//ruleBlock//RULE_REF", parser);
    }
    for (ParseTree node : ruleRefs) {
        TerminalNode terminal = (TerminalNode)node;
        Token rrefToken = terminal.getSymbol();
        String r = rrefToken.getText();
        if ( r.equals(ruleName) ) {
            nodes.add(terminal);
        }
    }
    if ( nodes.size()==0 ) return null;
    return nodes;
}

public AstBuilderListener(Language language, Parser parser, PsiBuilder builder) {
    this.language = language;
    this.builder = builder;

    this.tokenElementTypes = PSIElementTypeFactory.getTokenIElementTypes(language, Arrays.asList(parser.getTokenNames()));
    this.ruleElementTypes = PSIElementTypeFactory.getRuleIElementTypes(language, Arrays.asList(parser.getRuleNames()));

    for (ANTLRErrorListener listener : parser.getErrorListeners()) {
        if (listener instanceof SyntaxErrorListener) {
            syntaxErrors.addAll(((SyntaxErrorListener)listener).getSyntaxErrors());
        }
    }

    Collections.sort(syntaxErrors, new Comparator<SyntaxError>() {

        @Override
        public int compare(SyntaxError o1, SyntaxError o2) {
            return Integer.valueOf(getStart(o1)).compareTo(getStart(o2));
        }
    });
}

public StatisticsParserATNSimulator(Parser parser, ATN atn) {
    super(parser, atn);
    decisionInvocations = new long[atn.decisionToState.size()];
    decisionCost = new long[atn.decisionToState.size()];
    decisionLlCost = new long[atn.decisionToState.size()];
    fullContextFallback = new long[atn.decisionToState.size()];
    nonSll = new long[atn.decisionToState.size()];
    ambiguousResult = new long[atn.decisionToState.size()];
    totalTransitions = new long[atn.decisionToState.size()];
    computedTransitions = new long[atn.decisionToState.size()];
    fullContextTransitions = new long[atn.decisionToState.size()];
    totalLookaheadSll = new long[atn.decisionToState.size()];
    totalLookaheadLl = new long[atn.decisionToState.size()];
    minLookaheadSll = new long[atn.decisionToState.size()];
    maxLookaheadSll = new long[atn.decisionToState.size()];
    minLookaheadLl = new long[atn.decisionToState.size()];
    maxLookaheadLl = new long[atn.decisionToState.size()];
    for (int i = 0; i < minLookaheadSll.length; i++) {
        minLookaheadSll[i] = Long.MAX_VALUE;
        minLookaheadLl[i] = Long.MAX_VALUE;
        maxLookaheadSll[i] = Long.MIN_VALUE;
        maxLookaheadLl[i] = Long.MIN_VALUE;
    }
}

@Override
public Map<RuleContext, CaretReachedException> getParseTrees(TParser parser) {
    List<MultipleDecisionData> potentialAlternatives = new ArrayList<>();
    IntegerList currentPath = new IntegerList();
    Map<RuleContext, CaretReachedException> results = new IdentityHashMap<>();
    // make sure the token stream is initialized before getting the index
    parser.getInputStream().LA(1);
    int initialToken = parser.getInputStream().index();
    while (true) {
        parser.getInputStream().seek(initialToken);
        tryParse(parser, potentialAlternatives, currentPath, results);
        if (!incrementCurrentPath(potentialAlternatives, currentPath)) {
            break;
        }
    }

    LOGGER.log(Level.FINE, "Forest parser constructed {0} parse trees.", results.size());

    if (LOGGER.isLoggable(Level.FINEST)) {
        for (Map.Entry<RuleContext, CaretReachedException> entry : results.entrySet()) {
            LOGGER.log(Level.FINEST, entry.getKey().toStringTree(parser instanceof Parser ? (Parser)parser : null));
        }
    }

    return results;
}

@Override
    public void recover(Parser recognizer, RecognitionException e) {
        if (recognizer instanceof CodeCompletionParser
            && ((CodeCompletionParser)recognizer).getInterpreter().getCaretTransitions() != null) {

//                    int stateNumber = recognizer.getContext().s;
//                    ATNState state = recognizer.getATN().states.get(stateNumber);
//                    if (state instanceof DecisionState && recognizer.getInputStream() instanceof ObjectStream) {
//                        int decision = ((DecisionState)state).decision;
//                        ParserATNSimulator simulator = recognizer.getInterpreter();
//                        int prediction = simulator.adaptivePredict((ObjectStream)recognizer.getInputStream(), decision, recognizer.getContext());
//                    }

            CodeCompletionParser parser = (CodeCompletionParser)recognizer;
            CaretToken token = parser.getInterpreter().getCaretToken();
            AbstractCompletionParserATNSimulator interpreter = parser.getInterpreter();

            throw new CaretReachedException(parser.getContext(), token, interpreter.getCaretTransitions(), e);
        }

        // TODO: incorporate error recovery as a fallback option if no trees match correctly
        throw e;
        //super.recover(recognizer, e);
    }

/** Make sure we don't attempt to recover inline; if the parser
    * successfully recovers, it won't throw an exception.
    */
    @Override
    public Token recoverInline(Parser recognizer) throws RecognitionException
    {
        // SINGLE TOKEN DELETION
        Token matchedSymbol = singleTokenDeletion(recognizer);
        if (matchedSymbol != null)
        {
            // we have deleted the extra token.
            // now, move past ttype token as if all were ok
            recognizer.consume();
            return matchedSymbol;
        }

        // SINGLE TOKEN INSERTION
        if (singleTokenInsertion(recognizer))
        {
            return getMissingSymbol(recognizer);
        }

//      BeetlException exception = new BeetlParserException(BeetlException.PARSER_MISS_ERROR);
//      exception.pushToken(this.getGrammarToken(recognizer.getCurrentToken()));
//      throw exception;
        throw new InputMismatchException(recognizer);
    }

protected void reportUnwantedToken(@NotNull Parser recognizer)
{
    if (inErrorRecoveryMode(recognizer))
    {
        return;
    }

    beginErrorCondition(recognizer);

    Token t = recognizer.getCurrentToken();
    String tokenName = getTokenErrorDisplay(t);
    IntervalSet expecting = getExpectedTokens(recognizer);
    String msg = "多余输入 " + tokenName + " 期望 " + expecting.toString(recognizer.getTokenNames());
    BeetlException exception = new BeetlParserException(BeetlException.PARSER_MISS_ERROR, msg);
    //      exception.token = this.getGrammarToken(t);
    exception.pushToken(this.getGrammarToken(t));
    throw exception;
}

@Override
protected void reportUnwantedToken(Parser recognizer) {
    // change error message from default implementation
    if (inErrorRecoveryMode(recognizer)) {
        return;
    }

    beginErrorCondition(recognizer);

    Token t = recognizer.getCurrentToken();
    String tokenName = getTokenErrorDisplay(t);
    String msg = "extraneous input " + tokenName + " expecting operator";
    recognizer.notifyErrorListeners(t, msg, null);
}

@Override
public Token recoverInline(final Parser recognizer) throws RecognitionException {
    final Token token = recognizer.getCurrentToken();
    final String message = "unexpected token [" + getTokenErrorDisplay(token) + "]" +
        " was expecting one of [" + recognizer.getExpectedTokens().toString(recognizer.getVocabulary()) + "].";

    Location location = new Location(sourceName, token.getStartIndex());
    throw location.createError(new IllegalArgumentException(message));
}

@Override
public void reportAmbiguity(@NotNull Parser recognizer,
                            @NotNull DFA dfa,
                            int startIndex,
                            int stopIndex,
                            boolean exact,
                            @Nullable BitSet ambigAlts,
                            @NotNull ATNConfigSet configs)
{
}