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

@NonNull
public CodeCompletionGoParser getParser(@NonNull TokenStream input) {
    CodeCompletionGoParser parser = createParser(input);

    parser.removeErrorListeners();
    parser.setBuildParseTree(false);
    parser.setErrorHandler(new DefaultErrorStrategy());
    parser.getInterpreter().setPredictionMode(PredictionMode.LL);
    parser.getInterpreter().force_global_context = false;
    parser.getInterpreter().always_try_local_context = true;

    parser.setCheckPackageNames(false);
    parser.setPackageNames(Collections.<String>emptyList());

    return parser;
}

@Override
public int adaptivePredict(TokenStream input, int decision, ParserRuleContext outerContext) {
    if (decision == QID_DECISION && QID_DECISION >= 0) {
        if (input.LA(1) == GoParser.IDENTIFIER) {
            if (input.LA(2) == GoParser.Dot) {
                if (input.LA(3) == GoParser.IDENTIFIER) {
                    return qidPredicate.eval(parser, outerContext) ? 1 : 2;
                } else if (input.LA(3) != CaretToken.CARET_TOKEN_TYPE) {
                    return 2;
                }
            } else if (input.LA(2) != CaretToken.CARET_TOKEN_TYPE) {
                return 2;
            }
        }
    }

    return super.adaptivePredict(input, decision, outerContext);
}

public T getParser(TokenStream input) {
    T parser = null;
    synchronized (parsers) {
        while (parser == null && !parsers.isEmpty()) {
            parser = parsers.poll().get();
        }
    }

    if (parser != null) {
        parser.setInputStream(input);
    } else {
        parser = createParser(input);
    }

    return parser;
}

@Override
public final void syntaxError(final Recognizer<?, ?> recognizer,
    final Object offendingSymbol, final int line,
    final int charPositionInLine, final String msg,
    final RecognitionException e) {
  String input;
  if (recognizer instanceof Lexer) {
    final CharStream cs = ((Lexer) recognizer).getInputStream();
    input = cs.getText(new Interval(0, cs.size()));
  } else if (recognizer instanceof Parser) {
    final TokenStream tokens = ((Parser) recognizer).getInputStream();
    if (tokens != null) {
      input = tokens.getText();
    } else {
      input = "<unknown input>";
    }
  } else {
    input = "<unknown input>";
  }
  throw new AntlrParseException(input, line, charPositionInLine, msg);
}

@Override
public TransformExpressionTree compileToExpressionTree(String expression) {
  CharStream charStream = new ANTLRInputStream(expression);
  PQL2Lexer lexer = new PQL2Lexer(charStream);
  lexer.setTokenFactory(new CommonTokenFactory(true));
  TokenStream tokenStream = new UnbufferedTokenStream<CommonToken>(lexer);
  PQL2Parser parser = new PQL2Parser(tokenStream);
  parser.setErrorHandler(new BailErrorStrategy());

  // Parse
  ParseTree parseTree = parser.expression();

  ParseTreeWalker walker = new ParseTreeWalker();
  Pql2AstListener listener = new Pql2AstListener(expression, _splitInClause);
  walker.walk(listener, parseTree);

  final AstNode rootNode = listener.getRootNode();
  return TransformExpressionTree.buildTree(rootNode);
}

public static <P extends Parser> P getParser(Class<? extends Lexer> lexerClass, Class<P> parserClass, String source) {
  Lexer lexer = getLexer(lexerClass, source);
  TokenStream tokens = new CommonTokenStream(lexer);

  P parser;
  try {
    parser = parserClass.getConstructor(TokenStream.class).newInstance(tokens);
  } catch (Exception e) {
    throw new IllegalArgumentException("couldn't invoke parser constructor", e);
  }
  parser.getInterpreter().setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);
  parser.removeErrorListeners(); // don't spit to stderr
  parser.addErrorListener(new DiagnosticErrorListener());
  parser.addErrorListener(new AntlrFailureListener());

  return parser;
}

public static boolean isClassName(TokenStream _input) {
  try {
    int i=1;
    Token token = _input.LT(i);
    while (token!=null && i < _input.size() && _input.LT(i+1).getType() == GroovyParser.DOT) {
      i = i + 2;
      token = _input.LT(i);
    }
    if(token==null)
      return false;
    // TODO here
    return Character.isUpperCase(Character.codePointAt(token.getText(), 0));
  } catch(Exception e) {
    e.printStackTrace();
  }

  return false;
}

public Token addDecisionEventHighlighter(PreviewState previewState, MarkupModel markupModel,
                                         DecisionEventInfo info, Color errorStripeColor,
                                         EffectType effectType) {
    TokenStream tokens = previewState.parsingResult.parser.getInputStream();
    Token startToken = tokens.get(info.startIndex);
    Token stopToken = tokens.get(info.stopIndex);
    TextAttributes textAttributes =
        new TextAttributes(JBColor.BLACK, JBColor.WHITE, errorStripeColor,
                           effectType, Font.PLAIN);
    textAttributes.setErrorStripeColor(errorStripeColor);
    final RangeHighlighter rangeHighlighter =
        markupModel.addRangeHighlighter(
            startToken.getStartIndex(), stopToken.getStopIndex()+1,
            HighlighterLayer.ADDITIONAL_SYNTAX, textAttributes,
            HighlighterTargetArea.EXACT_RANGE);
    rangeHighlighter.putUserData(DECISION_EVENT_INFO_KEY, info);
    rangeHighlighter.setErrorStripeMarkColor(errorStripeColor);
    return startToken;
}

public T getParser(TokenStream input) {
    T parser = null;
    synchronized (parsers) {
        while (parser == null && !parsers.isEmpty()) {
            parser = parsers.poll().get();
        }
    }

    if (parser != null) {
        parser.setInputStream(input);
    } else {
        parser = createParser(input);
    }

    return parser;
}

/**
 * Parse.
 * @param text Text to parse
 * @return Map of tags
 * @throws BibSyntaxException If fails
 */
private static Map<String, String> parse(final String text)
    throws BibSyntaxException {
    final BibLexer lexer = new BibLexer(new ANTLRInputStream(text));
    final TokenStream tokens = new CommonTokenStream(lexer);
    final BibParser parser = new BibParser(tokens);
    final Errors errors = new Errors();
    lexer.addErrorListener(errors);
    parser.addErrorListener(errors);
    final Map<String, String> map;
    try {
        map = parser.tags().map;
    } catch (final RecognitionException ex) {
        throw new BibSyntaxException(ex);
    }
    if (!Iterables.isEmpty(errors)) {
        throw new BibSyntaxException(
            Joiner.on("; ").join(errors)
        );
    }
    return map;
}