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

@Override
public void exitDelete_stmt(BQLParser.Delete_stmtContext ctx) {
  deleteRequest = new LindenDeleteRequest();
  if (ctx.dw != null) {
    LindenFilter filter = filterProperty.get(ctx.dw);
    if (filter == null) {
      throw new ParseCancellationException(new SemanticException(ctx, "Filter parse failed"));
    }
    LindenQuery query = LindenQueryBuilder.buildMatchAllQuery();
    query = LindenQueryBuilder.buildFilteredQuery(query, filter);
    deleteRequest.setQuery(query);
  } else {
    deleteRequest.setQuery(LindenQueryBuilder.buildMatchAllQuery());
  }
  if (ctx.route_param != null) {
    deleteRequest.setRouteParam((SearchRouteParam) valProperty.get(ctx.route_param));
  }
  if (ctx.indexes != null) {
    deleteRequest.setIndexNames((List<String>) valProperty.get(ctx.indexes));
  }
}

@Override
public void exitType(BQLParser.TypeContext ctx) {
  String type;
  if (ctx.primitive_type() != null) {
    type = ctx.primitive_type().getText();
  } else if (ctx.boxed_type() != null) {
    type = ctx.boxed_type().getText();
  } else if (ctx.limited_type() != null) {
    type = ctx.limited_type().getText();
  } else if (ctx.map_type() != null) {
    return;
  } else {
    throw new UnsupportedOperationException("Not implemented yet.");
  }
  try {
    if (type.equalsIgnoreCase("int")) {
      valProperty.put(ctx, LindenType.INTEGER);
    } else {
      valProperty.put(ctx, LindenType.valueOf(type.toUpperCase()));
    }
  } catch (Exception e) {
    throw new ParseCancellationException(new SemanticException(ctx, "Type " + type + " not support."));
  }
}

@Override
public void exitSnippet_clause(BQLParser.Snippet_clauseContext ctx) {
  if (ctx.selection_list() != null) {
    List<String> selections = (List<String>) valProperty.get(ctx.selection_list());
    if (selections != null && !selections.isEmpty()) {
      SnippetParam snippet = new SnippetParam();
      for (String selection : selections) {
        Map.Entry<String, LindenType> fieldNameAndType = getFieldNameAndType(selection);
        LindenType type = fieldNameAndType.getValue();
        String col = fieldNameAndType.getKey();
        if (type == LindenType.STRING) {
          snippet.addToFields(new SnippetField(col));
        } else {
          throw new ParseCancellationException("Snippet doesn't support this type " + type);
        }
      }
      valProperty.put(ctx, snippet);
    }
  }
}

@Override
public void exitPython_style_list(BQLParser.Python_style_listContext ctx) {
  List<String> values = new ArrayList<>();
  for (BQLParser.Python_style_valueContext subCtx : ctx.python_style_value()) {
    if (subCtx.value() != null) {
      values.add(subCtx.value().getText());
    } else if (subCtx.python_style_list() != null) {
      throw new ParseCancellationException(
          new SemanticException(subCtx.python_style_list(), "Nested list is not supported"));
    } else if (subCtx.python_style_dict() != null) {
      throw new ParseCancellationException(
          new SemanticException(subCtx.python_style_dict(), "Dict list is not supported"));
    }
  }
  valProperty.put(ctx, values);
}

@Override
public void exitAggregation_spec(BQLParser.Aggregation_specContext ctx) {
  String col = unescapeColumnName(ctx.column_name());
  Map.Entry<String, LindenType> fieldNameAndType = getFieldNameAndType(col);
  LindenType type = fieldNameAndType.getValue();
  if (type != LindenType.INTEGER && type != LindenType.LONG && type != LindenType.DOUBLE) {
    throw new ParseCancellationException(new SemanticException(ctx.column_name(),
                                                               "Aggregation doesn't support the type of the field \""
                                                               + col + "\"."));
  }
  col = fieldNameAndType.getKey();

  Aggregation aggregation = new Aggregation();
  aggregation.setField(col);
  aggregation.setType(type);
  for (BQLParser.Bucket_specContext specContext : ctx.bucket_spec()) {
    Bucket bucket = (Bucket) valProperty.get(specContext);
    if (bucket != null) {
      aggregation.addToBuckets(bucket);
    }
  }
  facetRequest.addToAggregations(aggregation);
}

public String getErrorMessage(ParseCancellationException error) {
  if (error.getCause() != null) {
    String message = error.getCause().getMessage();
    if (error.getCause() instanceof SemanticException) {
      SemanticException semanticException = (SemanticException) error.getCause();
      if (semanticException.getNode() != null) {
        TerminalNode startNode = getStartNode(semanticException.getNode());
        if (startNode != null) {
          String prefix = String.format("[line:%d, col:%d] ", startNode.getSymbol().getLine(),
              startNode.getSymbol().getCharPositionInLine());
          message = prefix + message;
        }
      }
      return message;
    } else if (error.getCause() instanceof RecognitionException) {
      return getErrorMessage((RecognitionException) error.getCause());
    } else {
      return error.getCause().getMessage();
    }
  }

  return error.getMessage();
}

private Object readMatrix(List<Object> parameters) {
  String rationalString = in.nextLine();

  MatrixLexer matrixLexer = new MatrixLexer(new ANTLRInputStream(rationalString));

  MatrixParser matrixParser = new MatrixParser(new CommonTokenStream(matrixLexer));

  matrixParser.setErrorHandler(new BailErrorStrategy());

  try {
    MatrixParser.MatrixContext matrixContext = matrixParser.matrix();

    return Matrix.fromMatrixContext(matrixContext, Scope.NULL_SCOPE);
  } catch (ParseCancellationException e) {
    throw new InvalidReadRuntimeError("Invalid input read from stdin! Expected matrix format!");
  }
}

/**
 * Parse the {@link GraqlParser} into a Java object, where errors are reported to the given
 * {@link GraqlErrorListener}.
 */
final T parse(GraqlParser parser, GraqlErrorListener errorListener) {
    S tree;

    try {
        tree = parseTree(parser);
    } catch (ParseCancellationException e) {
        // If we're using the BailErrorStrategy, we will throw here
        // This strategy is designed for parsing very large files and cannot provide useful error information
        throw GraqlSyntaxException.parsingError("syntax error");
    }

    if (errorListener.hasErrors()) {
        throw GraqlSyntaxException.parsingError(errorListener.toString());
    }

    return visit(getQueryVisitor(), tree);
}

/**
 * Quand un terme sauvegardé dans la liste des termes sauvegardés est séléectionné il est possible
 * de voir son AST via le menu, ou le raccourci Ctrl+I / Cmd+I
 *
 * @param evt L'event qui a trigger l'action.
 */
private void menuViewASTActionPerformed(java.awt.event.ActionEvent evt) {
    if (!termSavedList.isSelectionEmpty()) {
        int index = termSavedList.getSelectedIndex();
        String term = saveTermModel.getElementAt(index);
        try {
            ANTLRInputStream inputStream = new ANTLRInputStream(term);
            LambdaLexer lexer = new LambdaLexer(inputStream);
            CommonTokenStream tokens = new CommonTokenStream(lexer);
            LambdaParser parser = new LambdaParser(tokens);
            ParseTree tree = parse(term);
            TreeViewer viewer = new TreeViewer(Arrays.asList(parser.getRuleNames()), tree);
            viewer.open();
        } catch (ParseCancellationException e) {
            workSpace.append("Don't try to watch AST of illformed term please");
        }
    }
}

public static Program parse(String source) {
    RankPLLexer lexer = new RankPLLexer(new ANTLRInputStream(source));
    TokenStream tokens = new CommonTokenStream(lexer);
    RankPLParser parser = new RankPLParser(tokens);
    parser.setErrorHandler(new BailErrorStrategy());
    ConcreteParser classVisitor = new ConcreteParser();

    // Parse
    Program program = null;
    try {
        program = (Program) classVisitor.visit(parser.program());
    } catch (ParseCancellationException e) {
        System.out.println("Syntax error");
        lexer = new RankPLLexer(new ANTLRInputStream(source));
        tokens = new CommonTokenStream(lexer);
        parser = new RankPLParser(tokens);
        classVisitor = new ConcreteParser();
        try {
            program = (Program) classVisitor.visit(parser.program());
        } catch (Exception ex) {
            // Ignore
        }
        return null;
    }
    return program;
}

public static ReplState start(String code){
Program p=Phase1CacheKey._handleCache();
try{
  boolean cached=p!=null;
  if(!cached){
    Timer.activate("RunningWithoutParsedCache");
    p= L42.parseAndDesugar("Repl",code);
    }
  ProgramReduction pr = new ProgramReduction(Paths.get("localhost","ReplCache.C42"),!cached);
  ReplState res=new ReplState(code,p.top(),p,pr);
  res.desugaredL=res.reduction.allSteps(res.p);
  res.p=res.p.updateTop(res.desugaredL);
  res.code=code.substring(1, code.length()-1); //to remove start and end {}
  return res;
  }
  catch(org.antlr.v4.runtime.misc.ParseCancellationException parser){
    System.out.println(parser.getMessage());
    return null;
    }
  catch(ErrorMessage msg){
    ErrorFormatter.topFormatErrorMessage(msg);
    return null;
    }
}

/**
 * Test of parse method, of class Number.
 */
@Test
public void testParse_String() {
    System.out.println("parse");
    try {
        assertEquals(Number.parse("UINT8_MAX"), 255L);
        assertEquals(Number.parse("UINT16_MAX"), 65535L);
        assertEquals(Number.parse("UINT24_MAX"), 16777215L);
        assertEquals(Number.parse("UINT32_MAX"), 4294967295L);
        assertEquals(Number.parse("UINT64_MAX"), -1L);
        assertEquals(Number.parse("073"), 59L);
        assertEquals(Number.parse("0"), 0L);
        assertEquals(Number.parse("123456789"), 123456789L);
        assertEquals(Number.parse("0xdeadbeef"), 0xdeadbeefL);
        assertEquals(Number.parse("0xdeadBeef"), 0xdeadbeefL);
    } catch (ParseCancellationException ex) {
        fail();
    }
}

@Override
public void recover(Parser recognizer, RecognitionException e) {
    for (ParserRuleContext context = recognizer.getContext(); context != null; context = context.getParent()) {
        context.exception = e;
    }

    if (PredictionMode.LL.equals(recognizer.getInterpreter().getPredictionMode())) {
        if (e instanceof NoViableAltException) {
            this.reportNoViableAlternative(recognizer, (NoViableAltException) e);
        } else if (e instanceof InputMismatchException) {
            this.reportInputMismatch(recognizer, (InputMismatchException) e);
        } else if (e instanceof FailedPredicateException) {
            this.reportFailedPredicate(recognizer, (FailedPredicateException) e);
        }
    }

    throw new ParseCancellationException(e);
}

@Override public String visitSource(MainParser.SourceContext ctx) {
    StringBuilder program = new StringBuilder("v2.0 raw\n");

    for (ParseTree child : ctx.children) {
        String currentByte = visit(child);
        if (! currentByte.isEmpty()) { // empty string doesn't effect program output
            if (currentByte.matches("^[01]{8}$")) {
                int value = Integer.parseInt(currentByte, 2);
                program.append(toBase(value, 16, 2) + " ");
                bytes++; // running count of bytes is important for visitAssignLabel
            } else {
                throw new ParseCancellationException(new com.github.charmoniumq.assembler.backend.InternalError(String.format("Invalid byte produced: %s", currentByte)));
            }
        }
    }
    return program.toString();
}

/**
 * Compile request to AST.
 *
 * @param path request
 * @return AST parse tree
 */
public static ParseTree parse(String path) {
    String normalizedPath = Paths.get(path).normalize().toString().replace(File.separatorChar, '/');
    if (normalizedPath.startsWith("/")) {
        normalizedPath = normalizedPath.substring(1);
    }
    ANTLRInputStream is = new ANTLRInputStream(normalizedPath);
    CoreLexer lexer = new CoreLexer(is);
    lexer.removeErrorListeners();
    lexer.addErrorListener(new BaseErrorListener() {
        @Override
        public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line,
                                int charPositionInLine, String msg, RecognitionException e) {
            throw new ParseCancellationException(msg, e);
        }
    });
    CoreParser parser = new CoreParser(new CommonTokenStream(lexer));
    parser.setErrorHandler(new BailErrorStrategy());
    return parser.start();
}

/**
 * Compile request to AST.
 * @param path request
 * @return AST
 */
public static ParseTree parse(String path) {
    ANTLRInputStream is = new ANTLRInputStream(path);
    CoreLexer lexer = new CoreLexer(is);
    lexer.removeErrorListeners();
    lexer.addErrorListener(new BaseErrorListener() {
        @Override
        public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line,
                int charPositionInLine, String msg, RecognitionException e) {
            throw new ParseCancellationException(e);
        }
    });
    CoreParser parser = new CoreParser(new CommonTokenStream(lexer));
    parser.setErrorHandler(new BailErrorStrategy());
    return parser.start();
}

public static ParseTree parseExpression(String expression) {
    ANTLRInputStream is = new ANTLRInputStream(expression);
    ExpressionLexer lexer = new ExpressionLexer(is);
    lexer.removeErrorListeners();
    lexer.addErrorListener(new BaseErrorListener() {
        @Override
        public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line,
                                int charPositionInLine, String msg, RecognitionException e) {
            throw new ParseCancellationException(msg, e);
        }
    });
    ExpressionParser parser = new ExpressionParser(new CommonTokenStream(lexer));
    parser.setErrorHandler(new BailErrorStrategy());
    lexer.reset();
    return parser.start();
}

@Test
public void testParseFailingExamples() throws IOException {
    FileVisitor<Path> workingFilesVisitior = new SimpleFileVisitor<Path>() {
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
            System.out.println("Testing parser input from file \""+file.toString()+"\"");
            ANTLRFileStream antlrStream = new ANTLRFileStream(file.toString());
            MiniJLexer lexer = new MiniJLexer(antlrStream);
            TokenStream tokens = new CommonTokenStream(lexer);
            MiniJParser parser = new MiniJParser(tokens);
            parser.setErrorHandler(new BailErrorStrategy());
            /*
             * Catch all exceptions first, to ensure that every single
             * compilation unit exits with an Exception. Otherwise, this
             * method will return after the first piece of code.
             */
            try {
                parser.prog();
                fail("The example "+file.toString()+" should have failed, but was accepted by the parser.");
            } catch (ParseCancellationException e) {
            }
            return super.visitFile(file, attrs);
        }
    };
    Files.walkFileTree(EXAMPLE_PROGRAM_PATH_FAILING, workingFilesVisitior);
}

private static Start parse(final CommonTokenStream tokens, final BoaParser parser, final BoaErrorListener parserErrorListener) {
    parser.setBuildParseTree(false);
    parser.getInterpreter().setPredictionMode(PredictionMode.SLL);

    try {
        return parser.start().ast;
    } catch (final ParseCancellationException e) {
        // fall-back to LL mode parsing if SLL fails
        tokens.reset();
        parser.reset();

        parser.removeErrorListeners();
        parser.addErrorListener(parserErrorListener);
        parser.getInterpreter().setPredictionMode(PredictionMode.LL);

        return parser.start().ast;
    }
}

/**
 * "First phase" parsing attempt. Provides better performance than {@link #parseLL(CompilationUnit, String)}, but
 * will erroneously report syntax errors when parsing script text utilizing certain parts of the grammar.
 *
 * @param compilationUnit The unit of work to compile/parse. Represents the grammar's start symbol that should be
 *                        used.
 * @param scriptText A plaintext representation of the HyperTalk script to parse
 * @return The root of the abstract syntax tree associated with the given compilation unit (i.e., {@link Script}),
 * or null if parsing fails.
 */
static Object parseSLL(CompilationUnit compilationUnit, String scriptText) {
    HyperTalkLexer lexer = new HyperTalkLexer(new CaseInsensitiveInputStream(scriptText));
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    HyperTalkParser parser = new HyperTalkParser(tokens);

    parser.setErrorHandler(new BailErrorStrategy());
    parser.removeErrorListeners();
    parser.getInterpreter().setPredictionMode(PredictionMode.SLL);

    try {
        ParseTree tree = compilationUnit.getParseTree(parser);
        return new HyperTalkTreeVisitor().visit(tree);
    } catch (ParseCancellationException e) {
        return null;
    }
}

public Walk compile( CharStream input, ErrorHandler errors ) {
     try  {
         return compile( input );
     } catch (ParseCancellationException ex) {
int line = ErrorHandler.UNKNOWN;
int column = ErrorHandler.UNKNOWN;
String msg = "Parser Cancelled.";
Throwable cause = ex.getCause();
if( cause instanceof InputMismatchException ) {
    InputMismatchException immEx = (InputMismatchException) cause;
    Token offender = immEx.getOffendingToken();
    if( offender != null ) {
        line = offender.getLine();
        column = offender.getCharPositionInLine();
        String txt = offender.getText();
        if(txt != null) {
            msg = " Unexpected Token '" + txt + "'.";
        }
    }
}
         errors.parseError( line, column, msg );
     }      
     return getProgram();
 }

/**
 * <p>parse.</p>
 *
 * @param expression a {@link java.lang.String} object.
 * @return a {@link java.util.List} object.
 */
public static List<QueryExprMeta> parse(String expression) {
    QueryParser parser = parser(tokens(expression));
    try {
        return parse(parser);
    } catch (ParseCancellationException | RecognitionException e) {
        RecognitionException err;
        if (e instanceof ParseCancellationException) {
            err = (RecognitionException) e.getCause();
        } else {
            err = (RecognitionException) e;
        }
        throw new QuerySyntaxException(
                Messages.get("dsl.parse.err", err.getOffendingToken().getCharPositionInLine()),
                e
        );
    }
}

private TemplateContext parse(Reader reader) throws IOException, ParseException {

  ANTLRInputStream inputStream = new ANTLRInputStream(reader);

  StencilLexer lexer = new StencilLexer(inputStream);

  CommonTokenStream tokenStream = new CommonTokenStream(lexer);

  StencilParser parser = new StencilParser(tokenStream);
  parser.setErrorHandler(new StencilErrorStrategy());

  try {
    return parser.template();
  }
  catch(ParseCancellationException e) {
    RecognitionException re = (RecognitionException) e.getCause();
    throw new ParseException("syntax error at " + re.getOffendingToken().getText(), re.getOffendingToken().getLine(), re.getOffendingToken().getCharPositionInLine()+1);
  }
}

@Override
public Void visitFloatingConstant(@NotNull FloatingConstantContext ctx)
{
    NodeState nodeState = getNodeState(ctx);

    Number value;
    DebugType floatType = nodeState.getEffectiveType();
    if (floatType == Types.getType(Types.FLOAT_NAME)) {
        value = Float.parseFloat(ctx.getText());
    }else if (floatType == Types.getType(Types.DOUBLE_NAME)) {
        value = Double.parseDouble(ctx.getText());
    }else{
        throw new ParseCancellationException(INVALID_TREE_MSG);
    }

    nodeState.setExpressionValue(new NumberValue(value));
    return null;
}

@Override
public void syntaxError(
    final Recognizer<?, ?> recognizer,
    final Object offending,
    final int line,
    final int position,
    final String msg,
    final RecognitionException exception
) {
    super.syntaxError(
        recognizer,
        offending,
        line,
        position,
        msg,
        exception
    );
    throw new ParseCancellationException(exception);
}

public StructuredQuery parse(String query) throws ParseCancellationException {
    GraphflowLexer lexer = new GraphflowLexer(CharStreams.fromString(query));
    lexer.removeErrorListeners();   // Remove default listeners first.
    lexer.addErrorListener(ErrorListener.INSTANCE);

    GraphflowParser parser = new GraphflowParser(new CommonTokenStream(lexer));
    parser.removeErrorListeners();   // Remove default listeners first.
    parser.addErrorListener(ErrorListener.INSTANCE);

    try {
        ParseTree tree = parser.graphflow();
        GraphflowVisitor visitor = new GraphflowVisitor();
        return (StructuredQuery) visitor.visit(tree);
    } catch (Exception e) {
        throw new ParseCancellationException(e.getMessage());
    }
}

private Node invokeParser(String name, String sql, Function<SqlBaseParser, ParserRuleContext> parseFunction, ParsingOptions parsingOptions)
{
    try {
        SqlBaseLexer lexer = new SqlBaseLexer(new CaseInsensitiveStream(new ANTLRInputStream(sql)));
        CommonTokenStream tokenStream = new CommonTokenStream(lexer);
        SqlBaseParser parser = new SqlBaseParser(tokenStream);

        parser.addParseListener(new PostProcessor(Arrays.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;
}

/**
 * Returns the value of the given expression.
 *
 * <p>For example, {@code evaluate("1+2")} returns {@code 3.0}, but {@code evaluate("1+")} throws
 * an exception.
 *
 * @param input the {@code String} to parse and evaluate
 * @return the value of the given expression
 * @throws IllegalArgumentException if {@code input} is an invalid expression
 */
public static double evaluate(String input) {
  CalculatorParser parser = ParserUtil.newParser(
      CalculatorLexer::new, CalculatorParser::new, input);
  ExpressionEvaluator evaluator = new ExpressionEvaluator();

  try {
    ParserUtil.parseAndWalk(parser::expression, evaluator);
  } catch (ParseCancellationException e) {
    throw new IllegalArgumentException("Invalid expression", e);
  }

  return evaluator.getValue();
}

/**
 * Returns whether {@code input} consists of balanced parentheses.
 *
 * <p>For example, {@code verify("(())")} returns true, but {@code verify("(")} returns false.
 *
 * @param input the {@code String} to parse and verify
 * @return whether {@code input} consists of balanced parentheses
 */
public static boolean verify(String input) {
  ParenthesesParser parser = ParserUtil.newParser(
      ParenthesesLexer::new, ParenthesesParser::new, input);

  try {
    parser.expression();
  } catch (ParseCancellationException e) {
    return false;
  }

  return true;
}