Function ReplaceN

extensions/regex_ext.cc:174–231

}

Value ReplaceN(int regex_max_program_size, const StringValue& target,
               const StringValue& regex, const StringValue& replacement,
               int64_t count,
               const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
               google::protobuf::MessageFactory* absl_nonnull message_factory,
               google::protobuf::Arena* absl_nonnull arena) {
  if (count == 0) {
    return target;
  }
  if (count < 0) {
    return ReplaceAll(regex_max_program_size, target, regex, replacement,
                      descriptor_pool, message_factory, arena);
  }

  std::string target_scratch;
  std::string regex_scratch;
  std::string replacement_scratch;
  absl::string_view target_view = target.ToStringView(&target_scratch);
  absl::string_view regex_view = regex.ToStringView(&regex_scratch);
  absl::string_view replacement_view =
      replacement.ToStringView(&replacement_scratch);
  RE2 re2(regex_view, cel::internal::MakeRE2Options());
  CEL_RETURN_IF_ERROR(cel::internal::CheckRE2(re2, regex_max_program_size))
      .With(ErrorValueReturn());
  std::string error_string;
  if (!re2.CheckRewriteString(replacement_view, &error_string)) {
    return ErrorValue(absl::InvalidArgumentError(
        absl::StrFormat("invalid replacement string: %s", error_string)));
  }

  std::string output;
  absl::string_view temp_target = target_view;
  int replaced_count = 0;
  // RE2's Rewrite only supports substitutions for groups \0 through \9.
  absl::string_view match[10];
  int nmatch = std::min(9, re2.NumberOfCapturingGroups()) + 1;

  while (replaced_count < count &&
         re2.Match(temp_target, 0, temp_target.length(), RE2::UNANCHORED, match,
                   nmatch)) {
    absl::string_view full_match = match[0];

    output.append(temp_target.data(), full_match.data() - temp_target.data());

    if (!re2.Rewrite(&output, replacement_view, match, nmatch)) {
      // This should ideally not happen given CheckRewriteString passed
      return ErrorValue(absl::InternalError("rewrite failed unexpectedly"));
    }

    temp_target.remove_prefix(full_match.data() - temp_target.data() +
                              full_match.length());
    replaced_count++;
  }

  output.append(temp_target.data(), temp_target.length());

  return StringValue::From(std::move(output), arena);
}