CurrentTemplateContextParserTask.java 文件源码

@Override
    @RuleDependency(recognizer=TemplateParser.class, rule=TemplateParser.RULE_group, version=0, dependents=Dependents.SELF)
    public void parse(ParserTaskManager taskManager, ParseContext context, DocumentSnapshot snapshot, Collection<? extends ParserDataDefinition<?>> requestedData, ParserResultHandler results)
        throws InterruptedException, ExecutionException {

        if (context.getPosition() == null) {
            return;
        }

        int caretOffset = context.getPosition().getOffset();

        Future<ParserData<List<Anchor>>> result =
            taskManager.getData(snapshot, TemplateParserDataDefinitions.DYNAMIC_ANCHOR_POINTS, EnumSet.of(ParserDataOptions.SYNCHRONOUS));

        ParserData<List<Anchor>> anchorsData = result.get();
        List<Anchor> anchors = anchorsData.getData();

        TemplateParser.GroupContext ruleContext = null;

        if (anchors != null) {
            Anchor enclosing = null;
//            int grammarType = -1;

            /*
             * parse the current template
             */
            for (Anchor anchor : anchors) {
//                if (anchor instanceof TemplateParserAnchorListener.TemplateTypeAnchor) {
//                    grammarType = ((TemplateParserAnchorListener.TemplateTypeAnchor)anchor).getGrammarType();
//                    continue;
//                }

                if (anchor.getSpan().getStartPosition(snapshot).getOffset() <= caretOffset && anchor.getSpan().getEndPosition(snapshot).getOffset() > caretOffset) {
                    enclosing = anchor;
                } else if (anchor.getSpan().getStartPosition(snapshot).getOffset() > caretOffset) {
                    break;
                }
            }

            if (enclosing != null) {
                CharStream input = new DocumentSnapshotCharStream(snapshot);
                input.seek(enclosing.getSpan().getStartPosition(snapshot).getOffset());
                TemplateLexer lexer = new TemplateLexer(input);
                CommonTokenStream tokens = new TaskTokenStream(lexer);
                TemplateParser parser = TemplateParserFactory.DEFAULT.getParser(tokens);
                try {
                    parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
                    parser.removeErrorListeners();
                    parser.setBuildParseTree(true);
                    parser.setErrorHandler(new BailErrorStrategy());
                    ruleContext = parser.group();
                } catch (ParseCancellationException ex) {
                    if (ex.getCause() instanceof RecognitionException) {
                        // retry with default error handler
                        tokens.reset();
                        parser.getInterpreter().setPredictionMode(PredictionMode.LL);
                        parser.setInputStream(tokens);
                        parser.setErrorHandler(new DefaultErrorStrategy());
                        ruleContext = parser.group();
                    } else {
                        throw ex;
                    }
                }
            }
        }

        CurrentTemplateContextData data = new CurrentTemplateContextData(snapshot, ruleContext);
        results.addResult(new BaseParserData<>(context, TemplateParserDataDefinitions.CURRENT_TEMPLATE_CONTEXT, snapshot, data));
    }