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

@Override
protected void configure() {
    bind(Importer.class).to(ImporterImpl.class);
    bind(FileDescriptorLoader.class).to(FileDescriptorLoaderImpl.class);
    bind(ANTLRErrorListener.class).to(ParseErrorLogger.class);
    bind(ANTLRErrorStrategy.class).to(BailErrorStrategy.class);
    bind(ProtoContext.class)
            .annotatedWith(Names.named(DESCRIPTOR_PROTO))
            .toProvider(DefaultDescriptorProtoProvider.class);

    Multibinder<ProtoContextPostProcessor> postProcessors = Multibinder
            .newSetBinder(binder(), ProtoContextPostProcessor.class);
    postProcessors.addBinding().to(ImportsPostProcessor.class);
    postProcessors.addBinding().to(TypeRegistratorPostProcessor.class);
    postProcessors.addBinding().to(TypeResolverPostProcessor.class);
    postProcessors.addBinding().to(ExtensionRegistratorPostProcessor.class);
    postProcessors.addBinding().to(OptionsPostProcessor.class);
    postProcessors.addBinding().to(UserTypeValidationPostProcessor.class);

    install(new FactoryModuleBuilder()
            .implement(FileReader.class, MultiPathFileReader.class)
            .build(FileReaderFactory.class));
}

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

    this.tokenElementTypes = PSIElementTypeFactory.getTokenIElementTypes(language);
    this.ruleElementTypes = PSIElementTypeFactory.getRuleIElementTypes(language);

    for (ANTLRErrorListener listener : parser.getErrorListeners()) {
        if (listener instanceof SyntaxErrorListener) {
            syntaxErrors = ((SyntaxErrorListener)listener).getSyntaxErrors();
            for (SyntaxError error : syntaxErrors) {
                // record first error per token
                int StartIndex = error.getOffendingSymbol().getStartIndex();
                if ( !tokenToErrorMap.containsKey(StartIndex) ) {
                    tokenToErrorMap.put(StartIndex, error);
                }
            }
        }
    }
}

private static HDLPackage parseStream(CharStream input, String libURI, final Set<Problem> syntaxProblems, String src) {
    final PSHDLLangLexer lexer = new PSHDLLangLexer(input);
    final CommonTokenStream tokens = new CommonTokenStream(lexer);
    final PSHDLLang parser = new PSHDLLang(tokens);
    final ANTLRErrorListener listener = new SyntaxErrorCollector(tokens, syntaxProblems);
    lexer.removeErrorListeners();
    lexer.addErrorListener(listener);
    parser.removeErrorListeners();
    parser.addErrorListener(listener);
    final PsModelContext psModel = parser.psModel();
    if (syntaxProblems.size() == 0) {
        final HDLPackage hdl = ParserToModelExtension.toHDL(tokens, psModel, libURI, src);
        return hdl;
    }
    return null;
}

private static HDLExpression parseExpressionStream(CharStream input, final Set<Problem> syntaxProblems) {
    final PSHDLLangLexer lexer = new PSHDLLangLexer(input);
    final CommonTokenStream tokens = new CommonTokenStream(lexer);
    final ANTLRErrorListener parserListener = new SyntaxErrorCollector(tokens, syntaxProblems);
    final PSHDLLang parser = new PSHDLLang(tokens);
    parser.removeErrorListeners();
    parser.addErrorListener(parserListener);
    lexer.removeErrorListeners();
    lexer.addErrorListener(parserListener);
    final PsExpressionContext psExpression = parser.psExpression();
    if (syntaxProblems.size() == 0) {
        final HDLExpression hdl = ParserToModelExtension.toHDLExpression(tokens, psExpression);
        return hdl;
    }
    return null;
}

/**
 * Sets up the Java parser.
 * @param javaFile the Java contents to parse.
 * @return the {@link JavaParser} instance.
 * @throws RecognitionException if the format is invalid.
 * @throws IOException if the source cannot be read.
 */
@SuppressWarnings("unchecked")
@NotNull
protected JavaParser setUpParser(@NotNull final File javaFile)
    throws RecognitionException,
           IOException
{
    @NotNull final JavaParser result;

    @NotNull final JavaLexer t_Lexer =
        new JavaLexer(new ANTLRFileStream(javaFile.getAbsolutePath()));

    @NotNull final ANTLRErrorListener errorListener = new PropagatingErrorListener(javaFile);

    t_Lexer.addErrorListener(errorListener);

    @NotNull final CommonTokenStream t_Tokens = new CommonTokenStream(t_Lexer);

    result = new JavaParser(t_Tokens);

    result.addErrorListener(errorListener);

    return result;
}

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 JSSDParser create(final JSSDLexer lexer, final ANTLRErrorListener errorListener) {
  if (errorListener != null) {
    lexer.removeErrorListeners();
  }
  lexer.addErrorListener(errorListener);
  final JSSDParser parser = new JSSDParser(new CommonTokenStream(lexer));
  if (errorListener != null) {
    parser.removeErrorListeners();
  }
  parser.addErrorListener(errorListener);
  return parser;
}

public static JmesPathParser createParser(String input, ANTLRErrorListener errorListener) {
  JmesPathLexer lexer = createLexer(input, errorListener);
  CommonTokenStream tokens = new CommonTokenStream(lexer);
  JmesPathParser parser = new JmesPathParser(tokens);
  parser.removeErrorListener(ConsoleErrorListener.INSTANCE);
  parser.addErrorListener(errorListener);
  parser.setBuildParseTree(true);
  return parser;
}

public List<SyntaxError> getErrors() {
    List<? extends ANTLRErrorListener> errorListeners = parser.getErrorListeners();
    for (ANTLRErrorListener errorListener : errorListeners) {
        if (errorListener instanceof EditorConfigErrorListener) {
            EditorConfigErrorListener ecErrorListener = (EditorConfigErrorListener) errorListener;
            return ecErrorListener.getErrorMessages();
        }
    }
    return Collections.emptyList();
}

public static ProgramContext parseProgram(String program, ANTLRErrorListener errorListener) throws IOException
{
    CharStream inputCharStream = new ANTLRInputStream(new StringReader(program));
    TokenSource tokenSource = new ArithmeticLexer(inputCharStream);
    TokenStream inputTokenStream = new CommonTokenStream(tokenSource);
    ArithmeticParser parser = new ArithmeticParser(inputTokenStream);
    parser.addErrorListener(errorListener);
    ProgramContext context = parser.program();
    return context;
}

private ANTLRErrorListener createANTLRErrorListener() {
    return new ANTLRErrorListener() {
        @Override
        public void syntaxError(
                Recognizer recognizer,
                Object offendingSymbol, int line, int charPositionInLine,
                String msg, RecognitionException e) {

            collectSyntaxError(new SyntaxException(msg, line, charPositionInLine + 1));
        }
    };
}

public void lexerError(int start, int stop) {
    System.err.println("ST lexerError " + start + ".." + stop);
    ANTLRErrorListener listener = getErrorListenerDispatch();
    final String text = input.getText(Interval.of(start, stop));
    final Token t = newToken(Token.INVALID_TYPE, text, start, stop, getLine(), getCharPositionInLine());
    listener.syntaxError(this, t, getLine(), getCharPositionInLine(),
                         "Bad char or token error in template: "+ text, null);
}

public List<SyntaxError> getErrors() {
  List<? extends ANTLRErrorListener> errorListeners = parser.getErrorListeners();
  for (ANTLRErrorListener errorListener : errorListeners) {
    if (errorListener instanceof EditorConfigErrorListener) {
      EditorConfigErrorListener ecErrorListener = (EditorConfigErrorListener) errorListener;
      return ecErrorListener.getErrorMessages();
    }
  }
  return Collections.emptyList();
}

/**
 * Builds a {@link SferaScriptGrammarParser} for the specified input and
 * with the specified error listener.
 * 
 * @param input
 *            the input
 * @param errorListener
 *            the error listener
 * @return the built parser
 */
private static SferaScriptGrammarParser getParser(CharStream input,
        ANTLRErrorListener errorListener) {
    SferaScriptGrammarLexer lexer = new SferaScriptGrammarLexer(input);
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    SferaScriptGrammarParser parser = new SferaScriptGrammarParser(tokens);

    lexer.removeErrorListeners();
    lexer.addErrorListener(errorListener);
    parser.removeErrorListeners();
    parser.addErrorListener(errorListener);

    return parser;
}

public List<DocItem> collect(Path file) throws IOException {
  this.file = file;
  doc = new ArrayList<>();
  CharStream input = CharStreams.fromPath(file, StandardCharsets.UTF_8);
  FuzzyDocLexer lexer = new FuzzyDocLexer(input);
  ANTLRErrorListener error = errorListener(LoggerFactory.getLogger(DocCollector.class), file);
  lexer.removeErrorListeners();
  lexer.addErrorListener(error);
  TokenStream tokens = new CommonTokenStream(lexer);
  FuzzyDocParser parser = new FuzzyDocParser(tokens);
  parser.removeErrorListeners();
  parser.addErrorListener(error);
  ParseTreeWalker.DEFAULT.walk(this, parser.source());
  return doc;
}

private static ANTLRErrorListener errorListener(final Logger log, Path file) {
  return new BaseErrorListener() {
    @Override
    public void syntaxError(final Recognizer<?, ?> recognizer, final Object offendingSymbol,
        final int line,
        final int charPositionInLine, final String msg, final RecognitionException e) {
      log.debug("{}:{}:{} {}", file, line, charPositionInLine, msg);
    }
  };
}

private static JavadocParser.DocumentationContext parseJavadoc(Path file, String doc) {
  ANTLRErrorListener error = errorListener(LoggerFactory.getLogger(DocCollector.class), file);
  CharStream stream = CharStreams.fromString(doc == null ? "" : doc);
  JavadocLexer lexer = new JavadocLexer(stream);
  lexer.removeErrorListeners();
  lexer.addErrorListener(error);
  CommonTokenStream tokens = new CommonTokenStream(lexer);
  JavadocParser parser = new JavadocParser(tokens);
  parser.removeErrorListeners();
  parser.addErrorListener(error);
  return parser.documentation();
}

public JSSDParser create(final InputStream inputStream, final String encoding, final ANTLRErrorListener errorListener)
    throws IOException {
  return create(new InputStreamReader(inputStream, encoding), errorListener);
}

public JSSDParser create(final Reader reader, final ANTLRErrorListener errorListener) throws IOException {
  return create(CharStreams.fromReader(reader), errorListener);
}

public JSSDParser create(final CharStream stream, final ANTLRErrorListener errorListener) {
  return create(new JSSDLexer(stream), errorListener);
}

private static JmesPathLexer createLexer(String input, ANTLRErrorListener errorListener) {
  JmesPathLexer lexer = new JmesPathLexer(new ANTLRInputStream(input));
  lexer.removeErrorListener(ConsoleErrorListener.INSTANCE);
  lexer.addErrorListener(errorListener);
  return lexer;
}

/**
 * Compile it to Java and save.
 * @throws IOException If fails
 */
public void compile() throws IOException {
    final String[] lines = new TextOf(this.input).asString().split("\n");
    final ANTLRErrorListener errors = new BaseErrorListener() {
        // @checkstyle ParameterNumberCheck (10 lines)
        @Override
        public void syntaxError(final Recognizer<?, ?> recognizer,
            final Object symbol, final int line,
            final int position, final String msg,
            final RecognitionException error) {
            throw new CompileException(
                String.format(
                    "[%d:%d] %s: \"%s\"",
                    line, position, msg, lines[line - 1]
                ),
                error
            );
        }
    };
    final ProgramLexer lexer = new ProgramLexer(
        CharStreams.fromStream(this.input.stream())
    );
    lexer.removeErrorListeners();
    lexer.addErrorListener(errors);
    final ProgramParser parser = new ProgramParser(
        new CommonTokenStream(lexer)
    );
    parser.removeErrorListeners();
    parser.addErrorListener(errors);
    final Tree tree = parser.program().ret;
    new IoCheckedScalar<>(
        new And(
            tree.java().entrySet(),
            path -> {
                new LengthOf(
                    new TeeInput(
                        path.getValue(),
                        this.target.apply(path.getKey())
                    )
                ).value();
            }
        )
    ).value();
}

@Inject
public FileDescriptorLoaderImpl(ANTLRErrorListener errorListener, Set<ProtoContextPostProcessor> postProcessors) {
    this.errorListener = errorListener;
    this.postProcessors = postProcessors;
}

public Lexer withErrorListener(ANTLRErrorListener listener) {
    this.lexer.removeErrorListeners();
    this.lexer.addErrorListener(listener);
    return this;
}

public Parser withErrorListener(ANTLRErrorListener listener) {
    this.parser.removeErrorListeners();
    this.parser.addErrorListener(listener);
    return this;
}

public <T> T parse(Reader reader, Class<T> targetType) throws IOException {
  logger.debug("Parsing configuration for type:{}", targetType);

  ANTLRErrorListener listener = new BaseErrorListener() {

    @Override
    public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) {
      throw new ConfigurationException(String.format("Unable to parse configuration: %s (at line:%s pos:%s)", msg, line, charPositionInLine), e);
    }

  };

  TypeDescriptor typeDescriptor = TypeMapping.ofType(targetType);

  ANTLRInputStream inputStream = new ANTLRInputStream(reader);
  ConfigurationLexer lexer = new ConfigurationLexer(inputStream);
  lexer.removeErrorListeners();
  lexer.addErrorListener(listener);

  CommonTokenStream tokenStream = new CommonTokenStream(lexer);
  com.rocana.configuration.antlr.ConfigurationParser parser = new com.rocana.configuration.antlr.ConfigurationParser(tokenStream);

  parser.removeErrorListeners();
  parser.addErrorListener(listener);

  ParseTree parseTree = parser.config();

  logger.debug("Parsed configuration:{}", parseTree.toStringTree(parser));

  Visitor<T> visitor = new Visitor<>(typeDescriptor);

  visitor.visit(parseTree);

  logger.debug("Configured object:{}", visitor.getResult());

  return visitor.getResult();
}

/**
 * Builds a {@link SferaScriptGrammarParser} for the specified reader and
 * with the specified error listener.
 * 
 * @param r
 *            the reader
 * @param errorListener
 *            the error listener
 * @return the built parser
 * @throws IOException
 *             if an I/O error occurs
 */
public static SferaScriptGrammarParser getParser(Reader r, ANTLRErrorListener errorListener)
        throws IOException {
    return getParser(new ANTLRInputStream(r), errorListener);
}