How to use

reset

method

in

org.antlr.v4.runtime.CommonTokenStream

private static ParserRuleContext parseTypeCalculation(String calculation)
{
  TypeCalculationLexer lexer = new TypeCalculationLexer(new CaseInsensitiveStream(new ANTLRInputStream(calculation)));
  CommonTokenStream tokenStream = new CommonTokenStream(lexer);
  TypeCalculationParser parser = new TypeCalculationParser(tokenStream);
  lexer.removeErrorListeners();
  lexer.addErrorListener(ERROR_LISTENER);
  parser.removeErrorListeners();
  parser.addErrorListener(ERROR_LISTENER);
  ParserRuleContext tree;
  try {
    // first, try parsing with potentially faster SLL mode
    parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
    tree = parser.typeCalculation();
  }
  catch (ParseCancellationException ex) {
    // if we fail, parse with LL mode
    tokenStream.reset(); // rewind input stream
    parser.reset();
    parser.getInterpreter().setPredictionMode(PredictionMode.LL);
    tree = parser.typeCalculation();
  }
  return tree;
}

tokenStream.reset(); // rewind input stream
parser.reset();

private static ParserRuleContext parseTypeCalculation(String calculation)
{
  TypeCalculationLexer lexer = new TypeCalculationLexer(new CaseInsensitiveStream(new ANTLRInputStream(calculation)));
  CommonTokenStream tokenStream = new CommonTokenStream(lexer);
  TypeCalculationParser parser = new TypeCalculationParser(tokenStream);
  lexer.removeErrorListeners();
  lexer.addErrorListener(ERROR_LISTENER);
  parser.removeErrorListeners();
  parser.addErrorListener(ERROR_LISTENER);
  ParserRuleContext tree;
  try {
    // first, try parsing with potentially faster SLL mode
    parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
    tree = parser.typeCalculation();
  }
  catch (ParseCancellationException ex) {
    // if we fail, parse with LL mode
    tokenStream.reset(); // rewind input stream
    parser.reset();
    parser.getInterpreter().setPredictionMode(PredictionMode.LL);
    tree = parser.typeCalculation();
  }
  return tree;
}

private Node invokeParser(String name, String bql, Function<BQLBaseParser, ParserRuleContext> parseFunction, ParsingOptions parsingOptions)
    throws ParsingException, IllegalArgumentException, UnsupportedOperationException, NullPointerException, AssertionError {
  try {
    BQLBaseLexer lexer = new BQLBaseLexer(new CaseInsensitiveStream(new ANTLRInputStream(bql)));
    CommonTokenStream tokenStream = new CommonTokenStream(lexer);
    BQLBaseParser parser = new BQLBaseParser(tokenStream);
    parser.addParseListener(new PostProcessor(asList(parser.getRuleNames())));
    lexer.removeErrorListeners();
    lexer.addErrorListener(ERROR_LISTENER);
    parser.removeErrorListeners();
    parser.addErrorListener(ERROR_LISTENER);
    ParserRuleContext tree;
    try {
      // First, try parsing with potentially faster SLL mode.
      parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
      tree = parseFunction.apply(parser);
    } catch (ParseCancellationException ex) {
      // If we fail, parse with LL mode.
      tokenStream.reset(); // rewind input stream.
      parser.reset();
      parser.getInterpreter().setPredictionMode(PredictionMode.LL);
      tree = parseFunction.apply(parser);
    }
    return new ASTBuilder(parsingOptions).visit(tree);
  } catch (StackOverflowError e) {
    throw new ParsingException(name + " is too large (stack overflow while parsing)");
  }
}

private static ParserRuleContext parseTypeCalculation(String calculation)
{
  TypeCalculationLexer lexer = new TypeCalculationLexer(new CaseInsensitiveStream(new ANTLRInputStream(calculation)));
  CommonTokenStream tokenStream = new CommonTokenStream(lexer);
  TypeCalculationParser parser = new TypeCalculationParser(tokenStream);
  lexer.removeErrorListeners();
  lexer.addErrorListener(ERROR_LISTENER);
  parser.removeErrorListeners();
  parser.addErrorListener(ERROR_LISTENER);
  ParserRuleContext tree;
  try {
    // first, try parsing with potentially faster SLL mode
    parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
    tree = parser.typeCalculation();
  }
  catch (ParseCancellationException ex) {
    // if we fail, parse with LL mode
    tokenStream.reset(); // rewind input stream
    parser.reset();
    parser.getInterpreter().setPredictionMode(PredictionMode.LL);
    tree = parser.typeCalculation();
  }
  return tree;
}

private static ParserRuleContext parseTypeCalculation(String calculation)
{
  TypeCalculationLexer lexer = new TypeCalculationLexer(new CaseInsensitiveStream(new ANTLRInputStream(calculation)));
  CommonTokenStream tokenStream = new CommonTokenStream(lexer);
  TypeCalculationParser parser = new TypeCalculationParser(tokenStream);
  lexer.removeErrorListeners();
  lexer.addErrorListener(ERROR_LISTENER);
  parser.removeErrorListeners();
  parser.addErrorListener(ERROR_LISTENER);
  ParserRuleContext tree;
  try {
    // first, try parsing with potentially faster SLL mode
    parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
    tree = parser.typeCalculation();
  }
  catch (ParseCancellationException ex) {
    // if we fail, parse with LL mode
    tokenStream.reset(); // rewind input stream
    parser.reset();
    parser.getInterpreter().setPredictionMode(PredictionMode.LL);
    tree = parser.typeCalculation();
  }
  return tree;
}

private static ParserRuleContext parseTypeCalculation(String calculation)
{
  TypeCalculationLexer lexer = new TypeCalculationLexer(new CaseInsensitiveStream(new ANTLRInputStream(calculation)));
  CommonTokenStream tokenStream = new CommonTokenStream(lexer);
  TypeCalculationParser parser = new TypeCalculationParser(tokenStream);
  lexer.removeErrorListeners();
  lexer.addErrorListener(ERROR_LISTENER);
  parser.removeErrorListeners();
  parser.addErrorListener(ERROR_LISTENER);
  ParserRuleContext tree;
  try {
    // first, try parsing with potentially faster SLL mode
    parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
    tree = parser.typeCalculation();
  }
  catch (ParseCancellationException ex) {
    // if we fail, parse with LL mode
    tokenStream.reset(); // rewind input stream
    parser.reset();
    parser.getInterpreter().setPredictionMode(PredictionMode.LL);
    tree = parser.typeCalculation();
  }
  return tree;
}

private Node invokeParser(String name, String sql, Function<SqlBaseParser, ParserRuleContext> parseFunction)
{
  try {
    SqlBaseLexer lexer = new SqlBaseLexer(new CaseInsensitiveStream(new ANTLRInputStream(sql)));
    CommonTokenStream tokenStream = new CommonTokenStream(lexer);
    SqlBaseParser parser = new SqlBaseParser(tokenStream);
    parser.addParseListener(new PostProcessor());
    lexer.removeErrorListeners();
    lexer.addErrorListener(ERROR_LISTENER);
    parser.removeErrorListeners();
    parser.addErrorListener(ERROR_LISTENER);
    ParserRuleContext tree;
    try {
      // first, try parsing with potentially faster SLL mode
      parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
      tree = parseFunction.apply(parser);
    }
    catch (ParseCancellationException ex) {
      // if we fail, parse with LL mode
      tokenStream.reset(); // rewind input stream
      parser.reset();
      parser.getInterpreter().setPredictionMode(PredictionMode.LL);
      tree = parseFunction.apply(parser);
    }
    return new AstBuilder(caseSensitive).visit(tree);
  }
  catch (StackOverflowError e) {
    throw new ParsingException(name + " is too large (stack overflow while parsing)");
  }
}

tokenStream.reset(); // rewind input stream
parser.reset();

tokenStream.reset(); // rewind input stream
parser.reset();

tokenStream.reset(); // rewind input stream
parser.reset();

tokens.reset(); // rewind input stream
parser.reset();
parser.getInterpreter().setPredictionMode(PredictionMode.LL);

tokens.reset(); // rewind input stream
parser.reset();
parser.getInterpreter().setPredictionMode(PredictionMode.LL);

tokens.reset(); // rewind input stream
parser.reset();
parser.addErrorListener(errorReporter);

 rootContext = getRootContext(parser);
} catch (Throwable th) {
 tokens.reset();
 parser.reset();
 parser.setErrorHandler(new DefaultErrorStrategy());