re2 1.22.2 → 1.23.0

package/vendor/re2/README.md

@@ -0,0 +1,259 @@
+# RE2, a regular expression library
+
+RE2 is an efficient, principled regular expression library
+that has been used in production at Google and many other places
+since 2006.
+
+_**Safety is RE2's primary goal.**_
+
+RE2 was designed and implemented with an explicit goal of being able
+to handle regular expressions from untrusted users without risk.
+One of its primary guarantees is that the match time is linear in the
+length of the input string. It was also written with production concerns in mind:
+the parser, the compiler and the execution engines limit their memory usage
+by working within a configurable budget—failing gracefully when exhausted—and
+they avoid stack overflow by eschewing recursion.
+
+It is not a goal to be faster than all other engines under all circumstances.
+Although RE2 guarantees a running time that is asymptotically linear in
+the length of the input, more complex expressions may incur larger constant factors;
+longer expressions increase the overhead required to handle those expressions safely.
+In a sense, RE2 is pessimistic where a backtracking engine is optimistic:
+A backtracking engine tests each alternative sequentially, making it fast when the first alternative is common.
+By contrast RE2 evaluates all alternatives in parallel, avoiding the performance penalty for the last alternative,
+at the cost of some overhead. This pessimism is what makes RE2 secure.
+
+It is also not a goal to implement all of the features offered by Perl, PCRE and other engines.
+As a matter of principle, RE2 does not support constructs for which only backtracking solutions are known to exist.
+Thus, backreferences and look-around assertions are not supported.
+
+For more information, please refer to Russ Cox's articles on regular expression theory and practice:
+
+* [Regular Expression Matching Can Be Simple And Fast](https://swtch.com/~rsc/regexp/regexp1.html)
+* [Regular Expression Matching: the Virtual Machine Approach](https://swtch.com/~rsc/regexp/regexp2.html)
+* [Regular Expression Matching in the Wild](https://swtch.com/~rsc/regexp/regexp3.html)
+
+### Syntax
+
+In POSIX mode, RE2 accepts standard POSIX (egrep) syntax regular expressions.
+In Perl mode, RE2 accepts most Perl operators.  The only excluded ones are
+those that require backtracking (and its potential for exponential runtime)
+to implement.  These include backreferences (submatching is still okay)
+and generalized assertions.
+The [Syntax wiki page](https://github.com/google/re2/wiki/Syntax)
+documents the supported Perl-mode syntax in detail.
+The default is Perl mode.
+
+### C++ API
+
+RE2's native language is C++, although there are [ports and wrappers](#ports-and-wrappers) listed below.
+
+#### Matching Interface
+
+There are two basic operators:
+`RE2::FullMatch` requires the regexp to match the entire input text, and
+`RE2::PartialMatch` looks for a match for a substring of the input text,
+returning the leftmost-longest match in POSIX mode and the
+same match that Perl would have chosen in Perl mode.
+
+Examples:
+
+```cpp
+assert(RE2::FullMatch("hello", "h.*o"))
+assert(!RE2::FullMatch("hello", "e"))
+
+assert(RE2::PartialMatch("hello", "h.*o"))
+assert(RE2::PartialMatch("hello", "e"))
+```
+
+#### Submatch Extraction
+
+Both matching functions take additional arguments in which submatches will be stored.
+The argument can be a `string*`, or an integer type, or the type `absl::string_view*`.
+(The `absl::string_view` type is very similar to the `std::string_view` type,
+but for historical reasons, RE2 uses the former.)
+A `string_view` is a pointer to the original input text, along with a count.
+It behaves like a string but doesn't carry its own storage.
+Like when using a pointer, when using a `string_view`
+you must be careful not to use it once the original text has been deleted or gone out of scope.
+
+Examples:
+
+```cpp
+// Successful parsing.
+int i;
+string s;
+assert(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", &s, &i));
+assert(s == "ruby");
+assert(i == 1234);
+
+// Fails: "ruby" cannot be parsed as an integer.
+assert(!RE2::FullMatch("ruby", "(.+)", &i));
+
+// Success; does not extract the number.
+assert(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", &s));
+
+// Success; skips NULL argument.
+assert(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", (void*)NULL, &i));
+
+// Fails: integer overflow keeps value from being stored in i.
+assert(!RE2::FullMatch("ruby:123456789123", "(\\w+):(\\d+)", &s, &i));
+```
+
+#### Pre-Compiled Regular Expressions
+
+The examples above all recompile the regular expression on each call.
+Instead, you can compile it once to an RE2 object and reuse that object for each call.
+
+Example:
+```cpp
+RE2 re("(\\w+):(\\d+)");
+assert(re.ok());  // compiled; if not, see re.error();
+
+assert(RE2::FullMatch("ruby:1234", re, &s, &i));
+assert(RE2::FullMatch("ruby:1234", re, &s));
+assert(RE2::FullMatch("ruby:1234", re, (void*)NULL, &i));
+assert(!RE2::FullMatch("ruby:123456789123", re, &s, &i));
+```
+
+#### Options
+
+The constructor takes an optional second argument that can
+be used to change RE2's default options.
+For example, `RE2::Quiet` silences the error messages that are
+usually printed when a regular expression fails to parse:
+
+```cpp
+RE2 re("(ab", RE2::Quiet);  // don't write to stderr for parser failure
+assert(!re.ok());  // can check re.error() for details
+```
+
+Other useful predefined options are `Latin1` (disable UTF-8) and `POSIX`
+(use POSIX syntax and leftmost longest matching).
+
+You can also declare your own `RE2::Options` object and then configure it as you like.
+See the [header](https://github.com/google/re2/blob/main/re2/re2.h) for the full set of options.
+
+#### Unicode Normalization
+
+RE2 operates on Unicode code points: it makes no attempt at normalization.
+For example, the regular expression /ü/ (U+00FC, u with diaeresis)
+does not match the input "ü" (U+0075 U+0308, u followed by combining diaeresis).
+Normalization is a long, involved topic.
+The simplest solution, if you need such matches, is to normalize both the regular expressions
+and the input in a preprocessing step before using RE2.
+For more details on the general topic, see <https://www.unicode.org/reports/tr15/>.
+
+#### Additional Tips and Tricks
+
+For advanced usage, like constructing your own argument lists,
+or using RE2 as a lexer, or parsing hex, octal, and C-radix numbers,
+see [re2.h](https://github.com/google/re2/blob/main/re2/re2.h).
+
+### Installation
+
+RE2 can be built and installed using GNU make, CMake, or Bazel.
+The simplest installation instructions are:
+
+	make
+	make test
+	make benchmark
+	make install
+	make testinstall
+
+Building RE2 requires a C++17 compiler and the [Abseil](https://github.com/abseil/abseil-cpp) library.
+Building the tests and benchmarks requires
+[GoogleTest](https://github.com/google/googletest)
+and [Benchmark](https://github.com/google/benchmark).
+To obtain those:
+
+- Linux: `apt install libabsl-dev libgtest-dev libbenchmark-dev`
+- macOS: `brew install abseil googletest google-benchmark pkg-config-wrapper`
+- Windows: `vcpkg install abseil gtest benchmark` \
+  or `vcpkg add port abseil gtest benchmark`
+
+Once those are installed, the build has to be able to find them.
+If the standard Makefile has trouble, then switching to CMake can help:
+
+	rm -rf build
+	cmake -DRE2_TEST=ON -DRE2_BENCHMARK=ON -S . -B build
+	cd build
+	make
+	make test
+	make install
+
+When using CMake, with benchmarks enabled, `make test` builds and runs test binaries
+and builds a `regexp_benchmark` binary but does not run it.
+If you don't need the tests or benchmarks at all, you can omit the corresponding `-D` arguments,
+and then you don't need the GoogleTest or Benchmark dependencies either.
+
+Another useful option is `-DRE2_USE_ICU=ON`, which adds a dependency on the
+ICU Unicode library but also extends the list of property names available in the `\p` and `\P` patterns.
+
+CMake can also be used to generate Visual Studio and Xcode projects, as well as
+Cygwin, MinGW, and MSYS makefiles.
+
+ - Visual Studio users: You need Visual Studio 2019 or later.
+ - Cygwin users: You must run CMake from the Cygwin command line, not the Windows command line.
+
+If you are adding RE2 to your own CMake project,
+CMake has two ways to use a dependency: `add_subdirectory()`,
+which is when the dependency's **_sources_** are in a subdirectory of your project;
+and `find_package()`, which is when the dependency's
+**_binaries_** have been built and installed somewhere on your system.
+The Abseil documentation walks through the former [here](https://abseil.io/docs/cpp/quickstart-cmake)
+versus the latter [here](https://abseil.io/docs/cpp/tools/cmake-installs).
+Once you get Abseil working, getting RE2 working will be a very similar process and,
+either way, `target_link_libraries(… re2::re2)` should Just Work™.
+
+If you are using [Bazel](https://bazel.io), it will handle the dependencies for you,
+although you still need to download Bazel,
+which you can do with [Bazelisk](https://github.com/bazelbuild/bazelisk).
+
+	go install github.com/bazelbuild/bazelisk@latest
+	# or on mac: brew install bazelisk
+
+	bazelisk build :all
+	bazelisk test :all
+
+If you are using RE2 from another project, you need to make sure you are
+using at least C++17.
+See the RE2 [.bazelrc](https://github.com/google/re2/blob/main/.bazelrc) file for an example.
+
+### Ports and Wrappers
+
+RE2 is implemented in C++.
+
+The official Python wrapper is [in the `python` directory](https://github.com/google/re2/tree/main/python)
+and [published on PyPI as `google-re2`](https://pypi.org/project/google-re2/).
+Note that there is also a PyPI `re2` but it is not by the RE2 authors and is unmaintained. Use `google-re2`.
+
+There are also other unofficial wrappers:
+
+- A C wrapper is at <https://github.com/marcomaggi/cre2/>.
+- A D wrapper is at <https://github.com/ShigekiKarita/re2d/> and [on DUB](https://code.dlang.org/packages/re2d).
+- An Erlang wrapper is at <https://github.com/dukesoferl/re2/> and [on Hex](https://hex.pm/packages/re2).
+- An Inferno wrapper is at <https://github.com/powerman/inferno-re2/>.
+- A Node.js wrapper is at <https://github.com/uhop/node-re2/> and [on NPM](https://www.npmjs.com/package/re2).
+- An OCaml wrapper is at <https://github.com/janestreet/re2/> and [on OPAM](https://opam.ocaml.org/packages/re2/).
+- A Perl wrapper is at <https://github.com/dgl/re-engine-RE2/> and [on CPAN](https://metacpan.org/pod/re::engine::RE2).
+- An R wrapper is at <https://github.com/girishji/re2/> and [on CRAN](https://cran.r-project.org/web/packages/re2/index.html).
+- A Ruby wrapper is at <https://github.com/mudge/re2/> and on RubyGems (rubygems.org).
+- A WebAssembly wrapper is at <https://github.com/google/re2-wasm/> and on NPM (npmjs.com).
+
+[RE2J](https://github.com/google/re2j) is a port of the RE2 C++ code to pure Java,
+and [RE2JS](https://github.com/le0pard/re2js) is a port of RE2J to JavaScript.
+
+The [Go `regexp` package](https://go.dev/pkg/regexp)
+and [Rust `regex` crate](https://docs.rs/regex)
+do not share code with RE2, but they follow the same principles,
+accept the same syntax, and provide the same efficiency guarantees.
+
+### Contact
+
+The [issue tracker](https://github.com/google/re2/issues) is the best place for discussions.
+
+There is a [mailing list](https://groups.google.com/group/re2-dev) for keeping up with code changes.
+
+Please read the [contribution guide](https://github.com/google/re2/wiki/Contribute) before sending changes.
+In particular, note that RE2 does not use GitHub pull requests.

package/vendor/re2/python/BUILD.bazel

@@ -70,3 +70,11 @@ platform(
         "@platforms//os:windows",
     ],
 )
+
+platform(
+    name = "arm64_windows",
+    constraint_values = [
+        "@platforms//cpu:arm64",
+        "@platforms//os:windows",
+    ],
+)

package/vendor/re2/python/re2.py

@@ -64,7 +64,7 @@ def compile(pattern, options=None):
     if options:
       raise error('pattern is already compiled, so '
                   'options may not be specified')
-    pattern = pattern._pattern
+    return pattern
   options = options or Options()
   values = tuple(getattr(options, name) for name in Options.NAMES)
   return _Regexp._make(pattern, values)

package/vendor/re2/python/re2_test.py

@@ -315,6 +315,12 @@ class Re2RegexpTest(ReRegexpTest):
     re2.purge()
     self.assertEqual(re2._Regexp._make.cache_info().currsize, 0)
 
+  def test_options(self):
+    opt = re2.Options()
+    opt.case_sensitive = False
+    r = re2.compile('test', opt)
+    self.assertIsNotNone(r.search('TEST'))
+    self.assertIsNotNone(re2.search(r, 'TEST'))
 
 class Re2EscapeTest(parameterized.TestCase):
   """Contains tests that apply to the re2 module only.

package/vendor/re2/python/setup.py

@@ -129,7 +129,7 @@ try:
 
   setuptools.setup(
       name='google-re2',
-      version='1.1.20240702',
+      version='1.1.20251105',
       description='RE2 Python bindings',
       long_description=long_description,
       long_description_content_type='text/plain',
@@ -144,11 +144,11 @@ try:
           'Intended Audience :: Developers',
           'License :: OSI Approved :: BSD License',
           'Programming Language :: C++',
-          'Programming Language :: Python :: 3.8',
+          'Programming Language :: Python :: 3.9',
       ],
       options=options(),
       cmdclass={'build_ext': BuildExt},
-      python_requires='~=3.8',
+      python_requires='~=3.9',
   )
 except:
   raise

package/vendor/re2/re2/bitmap256.cc

@@ -6,7 +6,6 @@
 
 #include <stdint.h>
 
-#include "absl/base/attributes.h"
 #include "absl/log/absl_check.h"
 
 namespace re2 {
@@ -27,15 +26,15 @@ int Bitmap256::FindNextSetBit(int c) const {
     case 1:
       if (words_[1] != 0)
         return (1 * 64) + FindLSBSet(words_[1]);
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 2:
       if (words_[2] != 0)
         return (2 * 64) + FindLSBSet(words_[2]);
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 3:
       if (words_[3] != 0)
         return (3 * 64) + FindLSBSet(words_[3]);
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     default:
       return -1;
   }

package/vendor/re2/re2/bitstate.cc

@@ -49,7 +49,7 @@ class BitState {
               bool longest, absl::string_view* submatch, int nsubmatch);
 
  private:
-  inline bool ShouldVisit(int id, const char* p);
+  static inline bool ShouldVisit(absl::string_view text, uint64_t* visited, uint16_t id, const char* p);
   void Push(int id, const char* p);
   void GrowStack();
   bool TrySearch(int id, const char* p);
@@ -85,16 +85,19 @@ BitState::BitState(Prog* prog)
     njob_(0) {
 }
 
-// Given id, which *must* be a list head, we can look up its list ID.
-// Then the question is: Should the search visit the (list ID, p) pair?
+// Given the text being searched and current visited state,
+// as well as a list ID, should the search visit the (list ID, p) pair?
 // If so, remember that it was visited so that the next time,
 // we don't repeat the visit.
-bool BitState::ShouldVisit(int id, const char* p) {
-  int n = prog_->list_heads()[id] * static_cast<int>(text_.size()+1) +
-          static_cast<int>(p-text_.data());
-  if (visited_[n/kVisitedBits] & (uint64_t{1} << (n & (kVisitedBits-1))))
+// We pass text and visited to this as a static method so that the
+// caller can do those loads once instead of this code dereferencing
+// them multiple times.
+bool BitState::ShouldVisit(absl::string_view text, uint64_t* visited, uint16_t list_id, const char* p) {
+  int n = list_id * static_cast<int>(text.size()+1) +
+          static_cast<int>(p-text.data());
+  if (visited[n/kVisitedBits] & (uint64_t{1} << (n & (kVisitedBits-1))))
     return false;
-  visited_[n/kVisitedBits] |= uint64_t{1} << (n & (kVisitedBits-1));
+  visited[n/kVisitedBits] |= uint64_t{1} << (n & (kVisitedBits-1));
   return true;
 }
 
@@ -140,10 +143,12 @@ void BitState::Push(int id, const char* p) {
 bool BitState::TrySearch(int id0, const char* p0) {
   bool matched = false;
   const char* end = text_.data() + text_.size();
+  uint16_t* list_heads = prog_->list_heads();
+  uint64_t* visited = visited_.data();
   njob_ = 0;
   // Push() no longer checks ShouldVisit(),
   // so we must perform the check ourselves.
-  if (ShouldVisit(id0, p0))
+  if (ShouldVisit(text_, visited, list_heads[id0], p0))
     Push(id0, p0);
   while (njob_ > 0) {
     // Pop job off stack.
@@ -237,7 +242,7 @@ bool BitState::TrySearch(int id0, const char* p0) {
         // Sanity check: id is the head of its list, which must
         // be the case if id-1 is the last of *its* list. :)
         ABSL_DCHECK(id == 0 || prog_->inst(id-1)->last());
-        if (ShouldVisit(id, p))
+        if (ShouldVisit(text_, visited, list_heads[id], p))
           goto Loop;
         break;
 

package/vendor/re2/re2/dfa.cc

@@ -34,7 +34,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/base/attributes.h"
 #include "absl/base/call_once.h"
 #include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_map.h"
@@ -650,7 +649,7 @@ DFA::State* DFA::WorkqToCachedState(Workq* q, Workq* mq, uint32_t flag) {
             absl::FPrintF(stderr, " -> FullMatchState\n");
           return FullMatchState;
         }
-        ABSL_FALLTHROUGH_INTENDED;
+        [[fallthrough]];
       default:
         // Record iff id is the head of its list, which must
         // be the case if id-1 is the last of *its* list. :)

package/vendor/re2/re2/parse.cc

@@ -24,7 +24,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/base/attributes.h"
 #include "absl/base/macros.h"
 #include "absl/log/absl_log.h"
 #include "absl/strings/ascii.h"
@@ -304,7 +303,7 @@ Rune ApplyFold(const CaseFold* f, Rune r) {
     case EvenOddSkip:  // even <-> odd but only applies to every other
       if ((r - f->lo) % 2)
         return r;
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case EvenOdd:  // even <-> odd
       if (r%2 == 0)
         return r + 1;
@@ -313,7 +312,7 @@ Rune ApplyFold(const CaseFold* f, Rune r) {
     case OddEvenSkip:  // odd <-> even but only applies to every other
       if ((r - f->lo) % 2)
         return r;
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case OddEven:  // odd <-> even
       if (r%2 == 1)
         return r + 1;
@@ -1525,7 +1524,7 @@ static bool ParseEscape(absl::string_view* s, Rune* rp,
       // Single non-zero octal digit is a backreference; not supported.
       if (s->empty() || (*s)[0] < '0' || (*s)[0] > '7')
         goto BadEscape;
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case '0':
       // consume up to three octal digits; already have one.
       code = c - '0';

package/vendor/re2/re2/prog.cc

@@ -15,7 +15,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/base/attributes.h"
 #include "absl/log/absl_check.h"
 #include "absl/log/absl_log.h"
 #include "absl/strings/str_format.h"
@@ -820,7 +819,7 @@ void Prog::EmitList(int root, SparseArray<int>* rootmap,
         flat->back().set_opcode(kInstAltMatch);
         flat->back().set_out(static_cast<int>(flat->size()));
         flat->back().out1_ = static_cast<uint32_t>(flat->size())+1;
-        ABSL_FALLTHROUGH_INTENDED;
+        [[fallthrough]];
 
       case kInstAlt:
         stk->push_back(ip->out1());

package/vendor/re2/re2/prog.h

@@ -11,6 +11,7 @@
 
 #include <stdint.h>
 
+#include <cstring>
 #include <functional>
 #include <string>
 #include <type_traits>

package/vendor/re2/re2/re2.cc

@@ -143,6 +143,11 @@ static std::string trunc(absl::string_view pattern) {
 
 
 RE2::RE2(const char* pattern) {
+  // If absl::string_view becomes an alias for std::string_view,
+  // it will stop allowing NULL to be converted.
+  // Handle NULL explicitly to keep callers working no matter what.
+  if (pattern == NULL)
+    pattern = "";
   Init(pattern, DefaultOptions);
 }
 

package/vendor/re2/re2/re2.h

@@ -87,7 +87,7 @@
 //    ABSL_CHECK(RE2::FullMatch("ruby:1234", "(\\w+):(\\d+)", &s, &i));
 //
 // Example: extracts "ruby" into "s" and no value into "i"
-//    absl::optional<int> i;
+//    std::optional<int> i;
 //    std::string s;
 //    ABSL_CHECK(RE2::FullMatch("ruby", "(\\w+)(?::(\\d+))?", &s, &i));
 //
@@ -213,13 +213,13 @@
 
 #include <algorithm>
 #include <map>
+#include <optional>
 #include <string>
 #include <type_traits>
 #include <vector>
 
 #include "absl/base/call_once.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "re2/stringpiece.h"
 
 #if defined(__APPLE__)
@@ -385,7 +385,7 @@ class RE2 {
   // type, or one of:
   //    std::string        (matched piece is copied to string)
   //    absl::string_view  (string_view is mutated to point to matched piece)
-  //    absl::optional<T>  (T is a supported numeric or string type as above)
+  //    std::optional<T>  (T is a supported numeric or string type as above)
   //    T                  ("bool T::ParseFrom(const char*, size_t)" must exist)
   //    (void*)NULL        (the corresponding matched sub-pattern is not copied)
   //
@@ -406,7 +406,7 @@ class RE2 {
   //    int number;
   //    RE2::FullMatch("abc", "[a-z]+(\\d+)?", &number);
   //
-  // Use absl::optional<int> instead to handle this case correctly.
+  // Use std::optional<int> instead to handle this case correctly.
   template <typename... A>
   static bool FullMatch(absl::string_view text, const RE2& re, A&&... a) {
     return Apply(FullMatchN, text, re, Arg(std::forward<A>(a))...);
@@ -842,12 +842,12 @@ template <> struct Parse4ary<unsigned long long> : public std::true_type {};
 template <typename T>
 bool Parse(const char* str, size_t n, T* dest, int radix);
 
-// Support absl::optional<T> for all T with a stock parser.
-template <typename T> struct Parse3ary<absl::optional<T>> : public Parse3ary<T> {};
-template <typename T> struct Parse4ary<absl::optional<T>> : public Parse4ary<T> {};
+// Support std::optional<T> for all T with a stock parser.
+template <typename T> struct Parse3ary<std::optional<T>> : public Parse3ary<T> {};
+template <typename T> struct Parse4ary<std::optional<T>> : public Parse4ary<T> {};
 
 template <typename T>
-bool Parse(const char* str, size_t n, absl::optional<T>* dest) {
+bool Parse(const char* str, size_t n, std::optional<T>* dest) {
   if (str == NULL) {
     if (dest != NULL)
       dest->reset();
@@ -863,7 +863,7 @@ bool Parse(const char* str, size_t n, absl::optional<T>* dest) {
 }
 
 template <typename T>
-bool Parse(const char* str, size_t n, absl::optional<T>* dest, int radix) {
+bool Parse(const char* str, size_t n, std::optional<T>* dest, int radix) {
   if (str == NULL) {
     if (dest != NULL)
       dest->reset();

package/vendor/re2/re2/set.cc

@@ -55,6 +55,12 @@ RE2::Set& RE2::Set::operator=(Set&& other) {
   return *this;
 }
 
+int RE2::Set::Size() const {
+  if (!compiled_)
+    return static_cast<int>(elem_.size());
+  return size_;
+}
+
 int RE2::Set::Add(absl::string_view pattern, std::string* error) {
   if (compiled_) {
     ABSL_LOG(DFATAL) << "RE2::Set::Add() called after compiling";

package/vendor/re2/re2/set.h

@@ -53,6 +53,10 @@ class RE2::Set {
   // the error message from the parser.
   int Add(absl::string_view pattern, std::string* error);
 
+  // Returns the number of patterns in the set.
+  // Can be called before or after Compile().
+  int Size() const;
+
   // Compiles the set in preparation for matching.
   // Returns false if the compiler runs out of memory.
   // Add() must not be called again after Compile().
@@ -62,6 +66,7 @@ class RE2::Set {
   // Returns true if text matches at least one of the regexps in the set.
   // Fills v (if not NULL) with the indices of the matching regexps.
   // Callers must not expect v to be sorted.
+  // The indices are in the half-open interval [0, Size()).
   bool Match(absl::string_view text, std::vector<int>* v) const;
 
   // As above, but populates error_info (if not NULL) when none of the regexps

package/vendor/re2/re2/testing/re2_arg_test.cc

@@ -9,10 +9,10 @@
 
 #include <stdint.h>
 #include <string.h>
+#include <optional>
 
 #include "absl/base/macros.h"
 #include "absl/log/absl_log.h"
-#include "absl/types/optional.h"
 #include "gtest/gtest.h"
 #include "re2/re2.h"
 
@@ -158,7 +158,7 @@ TEST(RE2ArgTest, ParseFromTest) {
 }
 
 TEST(RE2ArgTest, OptionalDoubleTest) {
-  absl::optional<double> opt;
+  std::optional<double> opt;
   RE2::Arg arg(&opt);
   EXPECT_TRUE(arg.Parse(NULL, 0));
   EXPECT_FALSE(opt.has_value());
@@ -169,7 +169,7 @@ TEST(RE2ArgTest, OptionalDoubleTest) {
 }
 
 TEST(RE2ArgTest, OptionalIntWithCRadixTest) {
-  absl::optional<int> opt;
+  std::optional<int> opt;
   RE2::Arg arg = RE2::CRadix(&opt);
   EXPECT_TRUE(arg.Parse(NULL, 0));
   EXPECT_FALSE(opt.has_value());

package/vendor/re2/re2/testing/re2_test.cc

@@ -1688,4 +1688,12 @@ TEST(RE2, Issue477) {
   ASSERT_EQ(s, "\x61\x63");
 }
 
+TEST(RE2, InitNULL) {
+  // RE2::RE2 accepts NULL. Make sure it keeps doing that.
+  RE2 re(NULL);
+  ASSERT_TRUE(re.ok());
+  ASSERT_TRUE(RE2::FullMatch("", re));
+  ASSERT_TRUE(RE2::FullMatch("", NULL));
+}
+
 }  // namespace re2

package/vendor/re2/re2/testing/set_test.cc

@@ -17,10 +17,15 @@ namespace re2 {
 TEST(Set, Unanchored) {
   RE2::Set s(RE2::DefaultOptions, RE2::UNANCHORED);
 
+  ASSERT_EQ(s.Size(), 0);
   ASSERT_EQ(s.Add("foo", NULL), 0);
+  ASSERT_EQ(s.Size(), 1);
   ASSERT_EQ(s.Add("(", NULL), -1);
+  ASSERT_EQ(s.Size(), 1);
   ASSERT_EQ(s.Add("bar", NULL), 1);
+  ASSERT_EQ(s.Size(), 2);
   ASSERT_EQ(s.Compile(), true);
+  ASSERT_EQ(s.Size(), 2);
 
   ASSERT_EQ(s.Match("foobar", NULL), true);
   ASSERT_EQ(s.Match("fooba", NULL), true);

package/vendor/re2/re2/walker-inl.h

@@ -192,7 +192,7 @@ template<typename T> T Regexp::Walker<T>::WalkInternal(Regexp* re, T top_arg,
           s->child_args = &s->child_arg;
         else if (re->nsub_ > 1)
           s->child_args = new T[re->nsub_];
-        ABSL_FALLTHROUGH_INTENDED;
+        [[fallthrough]];
       }
       default: {
         if (re->nsub_ > 0) {