@nxtedition/rocksdb 15.1.5 → 15.2.0

package/deps/re2/re2/make_unicode_casefold.py

@@ -0,0 +1,151 @@
+#!/usr/bin/python3
+# coding=utf-8
+#
+# Copyright 2008 The RE2 Authors.  All Rights Reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# See unicode_casefold.h for description of case folding tables.
+
+"""Generate C++ table for Unicode case folding."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import sys
+import unicode
+
+_header = """
+// GENERATED BY make_unicode_casefold.py; DO NOT EDIT.
+// make_unicode_casefold.py >unicode_casefold.cc
+
+#include "re2/unicode_casefold.h"
+
+namespace re2 {
+
+"""
+
+_trailer = """
+
+} // namespace re2
+
+"""
+
+def _Delta(a, b):
+  """Compute the delta for b - a.  Even/odd and odd/even
+     are handled specially, as described above."""
+  if a+1 == b:
+    if a%2 == 0:
+      return 'EvenOdd'
+    else:
+      return 'OddEven'
+  if a == b+1:
+    if a%2 == 0:
+      return 'OddEven'
+    else:
+      return 'EvenOdd'
+  return b - a
+
+def _AddDelta(a, delta):
+  """Return a + delta, handling EvenOdd and OddEven specially."""
+  if type(delta) == int:
+    return a+delta
+  if delta == 'EvenOdd':
+    if a%2 == 0:
+      return a+1
+    else:
+      return a-1
+  if delta == 'OddEven':
+    if a%2 == 1:
+      return a+1
+    else:
+      return a-1
+  print("Bad Delta:", delta, file=sys.stderr)
+  raise unicode.Error("Bad Delta")
+
+def _MakeRanges(pairs):
+  """Turn a list like [(65,97), (66, 98), ..., (90,122)]
+     into [(65, 90, +32)]."""
+  ranges = []
+  last = -100
+
+  def evenodd(last, a, b, r):
+    if a != last+1 or b != _AddDelta(a, r[2]):
+      return False
+    r[1] = a
+    return True
+
+  def evenoddpair(last, a, b, r):
+    if a != last+2:
+      return False
+    delta = r[2]
+    d = delta
+    if type(delta) is not str:
+      return False
+    if delta.endswith('Skip'):
+      d = delta[:-4]
+    else:
+      delta = d + 'Skip'
+    if b != _AddDelta(a, d):
+      return False
+    r[1] = a
+    r[2] = delta
+    return True
+
+  for a, b in pairs:
+    if ranges and evenodd(last, a, b, ranges[-1]):
+      pass
+    elif ranges and evenoddpair(last, a, b, ranges[-1]):
+      pass
+    else:
+      ranges.append([a, a, _Delta(a, b)])
+    last = a
+  return ranges
+
+# The maximum size of a case-folding group.
+# Case folding is implemented in parse.cc by a recursive process
+# with a recursion depth equal to the size of the largest
+# case-folding group, so it is important that this bound be small.
+# The current tables have no group bigger than 4.
+# If there are ever groups bigger than 10 or so, it will be
+# time to rework the code in parse.cc.
+MaxCasefoldGroup = 4
+
+def main():
+  lowergroups, casegroups = unicode.CaseGroups()
+  foldpairs = []
+  seen = {}
+  for c in casegroups:
+    if len(c) > MaxCasefoldGroup:
+      raise unicode.Error("casefold group too long: %s" % (c,))
+    for i in range(len(c)):
+      if c[i-1] in seen:
+        raise unicode.Error("bad casegroups %d -> %d" % (c[i-1], c[i]))
+      seen[c[i-1]] = True
+      foldpairs.append([c[i-1], c[i]])
+
+  lowerpairs = []
+  for lower, group in lowergroups.items():
+    for g in group:
+      if g != lower:
+        lowerpairs.append([g, lower])
+
+  def printpairs(name, foldpairs):
+    foldpairs.sort()
+    foldranges = _MakeRanges(foldpairs)
+    print("// %d groups, %d pairs, %d ranges" % (len(casegroups), len(foldpairs), len(foldranges)))
+    print("const CaseFold unicode_%s[] = {" % (name,))
+    for lo, hi, delta in foldranges:
+      print("\t{ %d, %d, %s }," % (lo, hi, delta))
+    print("};")
+    print("const int num_unicode_%s = %d;" % (name, len(foldranges)))
+    print("")
+
+  print(_header)
+  printpairs("casefold", foldpairs)
+  printpairs("tolower", lowerpairs)
+  print(_trailer)
+
+if __name__ == '__main__':
+  main()

package/deps/re2/re2/make_unicode_groups.py

@@ -0,0 +1,117 @@
+#!/usr/bin/python3
+# Copyright 2008 The RE2 Authors.  All Rights Reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+"""Generate C++ tables for Unicode Script and Category groups."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import sys
+import unicode
+
+_header = """
+// GENERATED BY make_unicode_groups.py; DO NOT EDIT.
+// make_unicode_groups.py >unicode_groups.cc
+
+#include "re2/unicode_groups.h"
+
+namespace re2 {
+
+"""
+
+_trailer = """
+
+}  // namespace re2
+
+"""
+
+n16 = 0
+n32 = 0
+
+def MakeRanges(codes):
+  """Turn a list like [1,2,3,7,8,9] into a range list [[1,3], [7,9]]"""
+  ranges = []
+  last = -100
+  for c in codes:
+    if c == last+1:
+      ranges[-1][1] = c
+    else:
+      ranges.append([c, c])
+    last = c
+  return ranges
+
+def PrintRanges(type, name, ranges):
+  """Print the ranges as an array of type named name."""
+  print("static const %s %s[] = {" % (type, name))
+  for lo, hi in ranges:
+    print("\t{ %d, %d }," % (lo, hi))
+  print("};")
+
+# def PrintCodes(type, name, codes):
+#   """Print the codes as an array of type named name."""
+#   print("static %s %s[] = {" % (type, name))
+#   for c in codes:
+#     print("\t%d," % (c,))
+#   print("};")
+
+def PrintGroup(name, codes):
+  """Print the data structures for the group of codes.
+  Return a UGroup literal for the group."""
+
+  # See unicode_groups.h for a description of the data structure.
+
+  # Split codes into 16-bit ranges and 32-bit ranges.
+  range16 = MakeRanges([c for c in codes if c < 65536])
+  range32 = MakeRanges([c for c in codes if c >= 65536])
+
+  # Pull singleton ranges out of range16.
+  # code16 = [lo for lo, hi in range16 if lo == hi]
+  # range16 = [[lo, hi] for lo, hi in range16 if lo != hi]
+
+  global n16
+  global n32
+  n16 += len(range16)
+  n32 += len(range32)
+
+  ugroup = "{ \"%s\", +1" % (name,)
+  # if len(code16) > 0:
+  #   PrintCodes("uint16_t", name+"_code16", code16)
+  #   ugroup += ", %s_code16, %d" % (name, len(code16))
+  # else:
+  #   ugroup += ", 0, 0"
+  if len(range16) > 0:
+    PrintRanges("URange16", name+"_range16", range16)
+    ugroup += ", %s_range16, %d" % (name, len(range16))
+  else:
+    ugroup += ", 0, 0"
+  if len(range32) > 0:
+    PrintRanges("URange32", name+"_range32", range32)
+    ugroup += ", %s_range32, %d" % (name, len(range32))
+  else:
+    ugroup += ", 0, 0"
+  ugroup += " }"
+  return ugroup
+
+def main():
+  categories = unicode.Categories()
+  scripts = unicode.Scripts()
+  print(_header)
+  ugroups = []
+  for name in sorted(categories):
+    ugroups.append(PrintGroup(name, categories[name]))
+  for name in sorted(scripts):
+    ugroups.append(PrintGroup(name, scripts[name]))
+  print("// %d 16-bit ranges, %d 32-bit ranges" % (n16, n32))
+  print("const UGroup unicode_groups[] = {")
+  ugroups.sort()
+  for ug in ugroups:
+    print("\t%s," % (ug,))
+  print("};")
+  print("const int num_unicode_groups = %d;" % (len(ugroups),))
+  print(_trailer)
+
+if __name__ == '__main__':
+  main()

package/deps/re2/re2/mimics_pcre.cc

@@ -0,0 +1,196 @@
+// Copyright 2008 The RE2 Authors.  All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Determine whether this library should match PCRE exactly
+// for a particular Regexp.  (If so, the testing framework can
+// check that it does.)
+//
+// This library matches PCRE except in these cases:
+//   * the regexp contains a repetition of an empty string,
+//     like (a*)* or (a*)+.  In this case, PCRE will treat
+//     the repetition sequence as ending with an empty string,
+//     while this library does not.
+//   * Perl and PCRE differ on whether \v matches \n.
+//     For historical reasons, this library implements the Perl behavior.
+//   * Perl and PCRE allow $ in one-line mode to match either the very
+//     end of the text or just before a \n at the end of the text.
+//     This library requires it to match only the end of the text.
+//   * Similarly, Perl and PCRE do not allow ^ in multi-line mode to
+//     match the end of the text if the last character is a \n.
+//     This library does allow it.
+//
+// Regexp::MimicsPCRE checks for any of these conditions.
+
+#include "absl/log/absl_log.h"
+#include "re2/regexp.h"
+#include "re2/walker-inl.h"
+
+namespace re2 {
+
+// Returns whether re might match an empty string.
+static bool CanBeEmptyString(Regexp *re);
+
+// Walker class to compute whether library handles a regexp
+// exactly as PCRE would.  See comment at top for conditions.
+
+class PCREWalker : public Regexp::Walker<bool> {
+ public:
+  PCREWalker() {}
+
+  virtual bool PostVisit(Regexp* re, bool parent_arg, bool pre_arg,
+                         bool* child_args, int nchild_args);
+
+  virtual bool ShortVisit(Regexp* re, bool a) {
+    // Should never be called: we use Walk(), not WalkExponential().
+#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+    ABSL_LOG(DFATAL) << "PCREWalker::ShortVisit called";
+#endif
+    return a;
+  }
+
+ private:
+  PCREWalker(const PCREWalker&) = delete;
+  PCREWalker& operator=(const PCREWalker&) = delete;
+};
+
+// Called after visiting each of re's children and accumulating
+// the return values in child_args.  So child_args contains whether
+// this library mimics PCRE for those subexpressions.
+bool PCREWalker::PostVisit(Regexp* re, bool parent_arg, bool pre_arg,
+                           bool* child_args, int nchild_args) {
+  // If children failed, so do we.
+  for (int i = 0; i < nchild_args; i++)
+    if (!child_args[i])
+      return false;
+
+  // Otherwise look for other reasons to fail.
+  switch (re->op()) {
+    // Look for repeated empty string.
+    case kRegexpStar:
+    case kRegexpPlus:
+    case kRegexpQuest:
+      if (CanBeEmptyString(re->sub()[0]))
+        return false;
+      break;
+    case kRegexpRepeat:
+      if (re->max() == -1 && CanBeEmptyString(re->sub()[0]))
+        return false;
+      break;
+
+    // Look for \v
+    case kRegexpLiteral:
+      if (re->rune() == '\v')
+        return false;
+      break;
+
+    // Look for $ in single-line mode.
+    case kRegexpEndText:
+    case kRegexpEmptyMatch:
+      if (re->parse_flags() & Regexp::WasDollar)
+        return false;
+      break;
+
+    // Look for ^ in multi-line mode.
+    case kRegexpBeginLine:
+      // No condition: in single-line mode ^ becomes kRegexpBeginText.
+      return false;
+
+    default:
+      break;
+  }
+
+  // Not proven guilty.
+  return true;
+}
+
+// Returns whether this regexp's behavior will mimic PCRE's exactly.
+bool Regexp::MimicsPCRE() {
+  PCREWalker w;
+  return w.Walk(this, true);
+}
+
+
+// Walker class to compute whether a Regexp can match an empty string.
+// It is okay to overestimate.  For example, \b\B cannot match an empty
+// string, because \b and \B are mutually exclusive, but this isn't
+// that smart and will say it can.  Spurious empty strings
+// will reduce the number of regexps we sanity check against PCRE,
+// but they won't break anything.
+
+class EmptyStringWalker : public Regexp::Walker<bool> {
+ public:
+  EmptyStringWalker() {}
+
+  virtual bool PostVisit(Regexp* re, bool parent_arg, bool pre_arg,
+                         bool* child_args, int nchild_args);
+
+  virtual bool ShortVisit(Regexp* re, bool a) {
+    // Should never be called: we use Walk(), not WalkExponential().
+#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+    ABSL_LOG(DFATAL) << "EmptyStringWalker::ShortVisit called";
+#endif
+    return a;
+  }
+
+ private:
+  EmptyStringWalker(const EmptyStringWalker&) = delete;
+  EmptyStringWalker& operator=(const EmptyStringWalker&) = delete;
+};
+
+// Called after visiting re's children.  child_args contains the return
+// value from each of the children's PostVisits (i.e., whether each child
+// can match an empty string).  Returns whether this clause can match an
+// empty string.
+bool EmptyStringWalker::PostVisit(Regexp* re, bool parent_arg, bool pre_arg,
+                                  bool* child_args, int nchild_args) {
+  switch (re->op()) {
+    case kRegexpNoMatch:               // never empty
+    case kRegexpLiteral:
+    case kRegexpAnyChar:
+    case kRegexpAnyByte:
+    case kRegexpCharClass:
+    case kRegexpLiteralString:
+      return false;
+
+    case kRegexpEmptyMatch:            // always empty
+    case kRegexpBeginLine:             // always empty, when they match
+    case kRegexpEndLine:
+    case kRegexpNoWordBoundary:
+    case kRegexpWordBoundary:
+    case kRegexpBeginText:
+    case kRegexpEndText:
+    case kRegexpStar:                  // can always be empty
+    case kRegexpQuest:
+    case kRegexpHaveMatch:
+      return true;
+
+    case kRegexpConcat:                // can be empty if all children can
+      for (int i = 0; i < nchild_args; i++)
+        if (!child_args[i])
+          return false;
+      return true;
+
+    case kRegexpAlternate:             // can be empty if any child can
+      for (int i = 0; i < nchild_args; i++)
+        if (child_args[i])
+          return true;
+      return false;
+
+    case kRegexpPlus:                  // can be empty if the child can
+    case kRegexpCapture:
+      return child_args[0];
+
+    case kRegexpRepeat:                // can be empty if child can or is x{0}
+      return child_args[0] || re->min() == 0;
+  }
+  return false;
+}
+
+// Returns whether re can match an empty string.
+static bool CanBeEmptyString(Regexp* re) {
+  EmptyStringWalker w;
+  return w.Walk(re, true);
+}
+
+}  // namespace re2