Function ParseImpl

parser/parser.cc:1643–1705

};

absl::StatusOr<ParseResult> ParseImpl(const cel::Source& source,
                                      const cel::MacroRegistry& registry,
                                      const ParserOptions& options) {
  try {
    CodePointStream input(source.content(), source.description());
    if (input.size() > options.expression_size_codepoint_limit) {
      return absl::InvalidArgumentError(absl::StrCat(
          "expression size exceeds codepoint limit.", " input size: ",
          input.size(), ", limit: ", options.expression_size_codepoint_limit));
    }
    CelLexer lexer(&input);
    CommonTokenStream tokens(&lexer);
    CelParser parser(&tokens);
    ExprRecursionListener listener(options.max_recursion_depth);
    absl::string_view accu_var = cel::kAccumulatorVariableName;
    if (options.enable_hidden_accumulator_var) {
      accu_var = cel::kHiddenAccumulatorVariableName;
    }
    ParserVisitor visitor(source, options.max_recursion_depth, accu_var,
                          registry, options.add_macro_calls,
                          options.enable_optional_syntax,
                          options.enable_quoted_identifiers);

    lexer.removeErrorListeners();
    parser.removeErrorListeners();
    lexer.addErrorListener(&visitor);
    parser.addErrorListener(&visitor);
    parser.addParseListener(&listener);

    // Limit the number of error recovery attempts to prevent bad expressions
    // from consuming lots of cpu / memory.
    parser.setErrorHandler(std::make_shared<RecoveryLimitErrorStrategy>(
        options.error_recovery_limit,
        options.error_recovery_token_lookahead_limit));

    Expr expr;
    try {
      expr = ExprFromAny(visitor.visit(parser.start()));
    } catch (const ParseCancellationException& e) {
      if (visitor.HasErrored()) {
        return absl::InvalidArgumentError(visitor.ErrorMessage());
      }
      return absl::CancelledError(e.what());
    }

    if (visitor.HasErrored()) {
      return absl::InvalidArgumentError(visitor.ErrorMessage());
    }

    return {
        ParseResult{.expr = std::move(expr),
                    .source_info = visitor.GetSourceInfo(),
                    .enriched_source_info = visitor.enriched_source_info()}};
  } catch (const std::exception& e) {
    return absl::AbortedError(e.what());
  } catch (const char* what) {
    // ANTLRv4 has historically thrown C string literals.
    return absl::AbortedError(what);