react-native-executorch 0.5.1 → 0.5.3

package/third-party/ios/ExecutorchLib/frameworks/re2.xcframework/ios-arm64/re2.framework/Headers/stringpiece.h

@@ -1,205 +0,0 @@
-// Copyright 2001-2010 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.
-
-#ifndef RE2_STRINGPIECE_H_
-#define RE2_STRINGPIECE_H_
-
-// A string-like object that points to a sized piece of memory.
-//
-// Functions or methods may use const StringPiece& parameters to accept either
-// a "const char*" or a "string" value that will be implicitly converted to
-// a StringPiece.  The implicit conversion means that it is often appropriate
-// to include this .h file in other files rather than forward-declaring
-// StringPiece as would be appropriate for most other Google classes.
-//
-// Systematic usage of StringPiece is encouraged as it will reduce unnecessary
-// conversions from "const char*" to "string" and back again.
-//
-//
-// Arghh!  I wish C++ literals were "string".
-
-#include <algorithm>
-#include <iosfwd>
-#include <iterator>
-#include <stddef.h>
-#include <string.h>
-#include <string>
-#ifdef __cpp_lib_string_view
-#include <string_view>
-#endif
-
-namespace re2 {
-
-class StringPiece {
-public:
-  typedef std::char_traits<char> traits_type;
-  typedef char value_type;
-  typedef char *pointer;
-  typedef const char *const_pointer;
-  typedef char &reference;
-  typedef const char &const_reference;
-  typedef const char *const_iterator;
-  typedef const_iterator iterator;
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-  typedef const_reverse_iterator reverse_iterator;
-  typedef size_t size_type;
-  typedef ptrdiff_t difference_type;
-  static const size_type npos = static_cast<size_type>(-1);
-
-  // We provide non-explicit singleton constructors so users can pass
-  // in a "const char*" or a "string" wherever a "StringPiece" is
-  // expected.
-  StringPiece() : data_(NULL), size_(0) {}
-#ifdef __cpp_lib_string_view
-  StringPiece(const std::string_view &str)
-      : data_(str.data()), size_(str.size()) {}
-#endif
-  StringPiece(const std::string &str) : data_(str.data()), size_(str.size()) {}
-  StringPiece(const char *str)
-      : data_(str), size_(str == NULL ? 0 : strlen(str)) {}
-  StringPiece(const char *str, size_type len) : data_(str), size_(len) {}
-
-  const_iterator begin() const { return data_; }
-  const_iterator end() const { return data_ + size_; }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(data_ + size_);
-  }
-  const_reverse_iterator rend() const { return const_reverse_iterator(data_); }
-
-  size_type size() const { return size_; }
-  size_type length() const { return size_; }
-  bool empty() const { return size_ == 0; }
-
-  const_reference operator[](size_type i) const { return data_[i]; }
-  const_pointer data() const { return data_; }
-
-  void remove_prefix(size_type n) {
-    data_ += n;
-    size_ -= n;
-  }
-
-  void remove_suffix(size_type n) { size_ -= n; }
-
-  void set(const char *str) {
-    data_ = str;
-    size_ = str == NULL ? 0 : strlen(str);
-  }
-
-  void set(const char *str, size_type len) {
-    data_ = str;
-    size_ = len;
-  }
-
-#ifdef __cpp_lib_string_view
-  // Converts to `std::basic_string_view`.
-  operator std::basic_string_view<char, traits_type>() const {
-    if (!data_)
-      return {};
-    return std::basic_string_view<char, traits_type>(data_, size_);
-  }
-#endif
-
-  // Converts to `std::basic_string`.
-  template <typename A>
-  explicit operator std::basic_string<char, traits_type, A>() const {
-    if (!data_)
-      return {};
-    return std::basic_string<char, traits_type, A>(data_, size_);
-  }
-
-  std::string as_string() const { return std::string(data_, size_); }
-
-  // We also define ToString() here, since many other string-like
-  // interfaces name the routine that converts to a C++ string
-  // "ToString", and it's confusing to have the method that does that
-  // for a StringPiece be called "as_string()".  We also leave the
-  // "as_string()" method defined here for existing code.
-  std::string ToString() const { return std::string(data_, size_); }
-
-  void CopyToString(std::string *target) const { target->assign(data_, size_); }
-
-  void AppendToString(std::string *target) const {
-    target->append(data_, size_);
-  }
-
-  size_type copy(char *buf, size_type n, size_type pos = 0) const;
-  StringPiece substr(size_type pos = 0, size_type n = npos) const;
-
-  int compare(const StringPiece &x) const {
-    size_type min_size = std::min(size(), x.size());
-    if (min_size > 0) {
-      int r = memcmp(data(), x.data(), min_size);
-      if (r < 0)
-        return -1;
-      if (r > 0)
-        return 1;
-    }
-    if (size() < x.size())
-      return -1;
-    if (size() > x.size())
-      return 1;
-    return 0;
-  }
-
-  // Does "this" start with "x"?
-  bool starts_with(const StringPiece &x) const {
-    return x.empty() ||
-           (size() >= x.size() && memcmp(data(), x.data(), x.size()) == 0);
-  }
-
-  // Does "this" end with "x"?
-  bool ends_with(const StringPiece &x) const {
-    return x.empty() ||
-           (size() >= x.size() &&
-            memcmp(data() + (size() - x.size()), x.data(), x.size()) == 0);
-  }
-
-  bool contains(const StringPiece &s) const { return find(s) != npos; }
-
-  size_type find(const StringPiece &s, size_type pos = 0) const;
-  size_type find(char c, size_type pos = 0) const;
-  size_type rfind(const StringPiece &s, size_type pos = npos) const;
-  size_type rfind(char c, size_type pos = npos) const;
-
-private:
-  const_pointer data_;
-  size_type size_;
-};
-
-inline bool operator==(const StringPiece &x, const StringPiece &y) {
-  StringPiece::size_type len = x.size();
-  if (len != y.size())
-    return false;
-  return x.data() == y.data() || len == 0 ||
-         memcmp(x.data(), y.data(), len) == 0;
-}
-
-inline bool operator!=(const StringPiece &x, const StringPiece &y) {
-  return !(x == y);
-}
-
-inline bool operator<(const StringPiece &x, const StringPiece &y) {
-  StringPiece::size_type min_size = std::min(x.size(), y.size());
-  int r = min_size == 0 ? 0 : memcmp(x.data(), y.data(), min_size);
-  return (r < 0) || (r == 0 && x.size() < y.size());
-}
-
-inline bool operator>(const StringPiece &x, const StringPiece &y) {
-  return y < x;
-}
-
-inline bool operator<=(const StringPiece &x, const StringPiece &y) {
-  return !(x > y);
-}
-
-inline bool operator>=(const StringPiece &x, const StringPiece &y) {
-  return !(x < y);
-}
-
-// Allow StringPiece to be logged.
-std::ostream &operator<<(std::ostream &o, const StringPiece &p);
-
-} // namespace re2
-
-#endif // RE2_STRINGPIECE_H_

package/third-party/ios/ExecutorchLib/frameworks/re2.xcframework/ios-arm64/re2.framework/Headers/unicode_casefold.h

@@ -1,78 +0,0 @@
-// 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.
-
-#ifndef RE2_UNICODE_CASEFOLD_H_
-#define RE2_UNICODE_CASEFOLD_H_
-
-// Unicode case folding tables.
-
-// The Unicode case folding tables encode the mapping from one Unicode point
-// to the next largest Unicode point with equivalent folding.  The largest
-// point wraps back to the first.  For example, the tables map:
-//
-//     'A' -> 'a'
-//     'a' -> 'A'
-//
-//     'K' -> 'k'
-//     'k' -> 'K'  (Kelvin symbol)
-//     'K' -> 'K'
-//
-// Like everything Unicode, these tables are big.  If we represent the table
-// as a sorted list of uint32_t pairs, it has 2049 entries and is 16 kB.
-// Most table entries look like the ones around them:
-// 'A' maps to 'A'+32, 'B' maps to 'B'+32, etc.
-// Instead of listing all the pairs explicitly, we make a list of ranges
-// and deltas, so that the table entries for 'A' through 'Z' can be represented
-// as a single entry { 'A', 'Z', +32 }.
-//
-// In addition to blocks that map to each other (A-Z mapping to a-z)
-// there are blocks of pairs that individually map to each other
-// (for example, 0100<->0101, 0102<->0103, 0104<->0105, ...).
-// For those, the special delta value EvenOdd marks even/odd pairs
-// (if even, add 1; if odd, subtract 1), and OddEven marks odd/even pairs.
-//
-// In this form, the table has 274 entries, about 3kB.  If we were to split
-// the table into one for 16-bit codes and an overflow table for larger ones,
-// we could get it down to about 1.5kB, but that's not worth the complexity.
-//
-// The grouped form also allows for efficient fold range calculations
-// rather than looping one character at a time.
-
-#include <stdint.h>
-
-#include "util/utf.h"
-#include "util/util.h"
-
-namespace re2 {
-
-enum {
-  EvenOdd = 1,
-  OddEven = -1,
-  EvenOddSkip = 1 << 30,
-  OddEvenSkip,
-};
-
-struct CaseFold {
-  Rune lo;
-  Rune hi;
-  int32_t delta;
-};
-
-extern const CaseFold unicode_casefold[];
-extern const int num_unicode_casefold;
-
-extern const CaseFold unicode_tolower[];
-extern const int num_unicode_tolower;
-
-// Returns the CaseFold* in the tables that contains rune.
-// If rune is not in the tables, returns the first CaseFold* after rune.
-// If rune is larger than any value in the tables, returns NULL.
-extern const CaseFold *LookupCaseFold(const CaseFold *, int, Rune rune);
-
-// Returns the result of applying the fold f to the rune r.
-extern Rune ApplyFold(const CaseFold *f, Rune r);
-
-} // namespace re2
-
-#endif // RE2_UNICODE_CASEFOLD_H_

package/third-party/ios/ExecutorchLib/frameworks/re2.xcframework/ios-arm64/re2.framework/Headers/unicode_groups.h

@@ -1,64 +0,0 @@
-// 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.
-
-#ifndef RE2_UNICODE_GROUPS_H_
-#define RE2_UNICODE_GROUPS_H_
-
-// Unicode character groups.
-
-// The codes get split into ranges of 16-bit codes
-// and ranges of 32-bit codes.  It would be simpler
-// to use only 32-bit ranges, but these tables are large
-// enough to warrant extra care.
-//
-// Using just 32-bit ranges gives 27 kB of data.
-// Adding 16-bit ranges gives 18 kB of data.
-// Adding an extra table of 16-bit singletons would reduce
-// to 16.5 kB of data but make the data harder to use;
-// we don't bother.
-
-#include <stdint.h>
-
-#include "util/utf.h"
-#include "util/util.h"
-
-namespace re2 {
-
-struct URange16 {
-  uint16_t lo;
-  uint16_t hi;
-};
-
-struct URange32 {
-  Rune lo;
-  Rune hi;
-};
-
-struct UGroup {
-  const char *name;
-  int sign; // +1 for [abc], -1 for [^abc]
-  const URange16 *r16;
-  int nr16;
-  const URange32 *r32;
-  int nr32;
-};
-
-// Named by property or script name (e.g., "Nd", "N", "Han").
-// Negated groups are not included.
-extern const UGroup unicode_groups[];
-extern const int num_unicode_groups;
-
-// Named by POSIX name (e.g., "[:alpha:]", "[:^lower:]").
-// Negated groups are included.
-extern const UGroup posix_groups[];
-extern const int num_posix_groups;
-
-// Named by Perl name (e.g., "\\d", "\\D").
-// Negated groups are included.
-extern const UGroup perl_groups[];
-extern const int num_perl_groups;
-
-} // namespace re2
-
-#endif // RE2_UNICODE_GROUPS_H_

package/third-party/ios/ExecutorchLib/frameworks/re2.xcframework/ios-arm64/re2.framework/Headers/walker-inl.h

@@ -1,235 +0,0 @@
-// Copyright 2006 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.
-
-#ifndef RE2_WALKER_INL_H_
-#define RE2_WALKER_INL_H_
-
-// Helper class for traversing Regexps without recursion.
-// Clients should declare their own subclasses that override
-// the PreVisit and PostVisit methods, which are called before
-// and after visiting the subexpressions.
-
-// Not quite the Visitor pattern, because (among other things)
-// the Visitor pattern is recursive.
-
-#include <stack>
-
-#include "re2/regexp.h"
-#include "util/logging.h"
-
-namespace re2 {
-
-template <typename T> struct WalkState;
-
-template <typename T> class Regexp::Walker {
-public:
-  Walker();
-  virtual ~Walker();
-
-  // Virtual method called before visiting re's children.
-  // PreVisit passes ownership of its return value to its caller.
-  // The Arg* that PreVisit returns will be passed to PostVisit as pre_arg
-  // and passed to the child PreVisits and PostVisits as parent_arg.
-  // At the top-most Regexp, parent_arg is arg passed to walk.
-  // If PreVisit sets *stop to true, the walk does not recurse
-  // into the children.  Instead it behaves as though the return
-  // value from PreVisit is the return value from PostVisit.
-  // The default PreVisit returns parent_arg.
-  virtual T PreVisit(Regexp *re, T parent_arg, bool *stop);
-
-  // Virtual method called after visiting re's children.
-  // The pre_arg is the T that PreVisit returned.
-  // The child_args is a vector of the T that the child PostVisits returned.
-  // PostVisit takes ownership of pre_arg.
-  // PostVisit takes ownership of the Ts
-  // in *child_args, but not the vector itself.
-  // PostVisit passes ownership of its return value
-  // to its caller.
-  // The default PostVisit simply returns pre_arg.
-  virtual T PostVisit(Regexp *re, T parent_arg, T pre_arg, T *child_args,
-                      int nchild_args);
-
-  // Virtual method called to copy a T,
-  // when Walk notices that more than one child is the same re.
-  virtual T Copy(T arg);
-
-  // Virtual method called to do a "quick visit" of the re,
-  // but not its children.  Only called once the visit budget
-  // has been used up and we're trying to abort the walk
-  // as quickly as possible.  Should return a value that
-  // makes sense for the parent PostVisits still to be run.
-  // This function is (hopefully) only called by
-  // WalkExponential, but must be implemented by all clients,
-  // just in case.
-  virtual T ShortVisit(Regexp *re, T parent_arg) = 0;
-
-  // Walks over a regular expression.
-  // Top_arg is passed as parent_arg to PreVisit and PostVisit of re.
-  // Returns the T returned by PostVisit on re.
-  T Walk(Regexp *re, T top_arg);
-
-  // Like Walk, but doesn't use Copy.  This can lead to
-  // exponential runtimes on cross-linked Regexps like the
-  // ones generated by Simplify.  To help limit this,
-  // at most max_visits nodes will be visited and then
-  // the walk will be cut off early.
-  // If the walk *is* cut off early, ShortVisit(re)
-  // will be called on regexps that cannot be fully
-  // visited rather than calling PreVisit/PostVisit.
-  T WalkExponential(Regexp *re, T top_arg, int max_visits);
-
-  // Clears the stack.  Should never be necessary, since
-  // Walk always enters and exits with an empty stack.
-  // Logs DFATAL if stack is not already clear.
-  void Reset();
-
-  // Returns whether walk was cut off.
-  bool stopped_early() { return stopped_early_; }
-
-private:
-  // Walk state for the entire traversal.
-  std::stack<WalkState<T>> stack_;
-  bool stopped_early_;
-  int max_visits_;
-
-  T WalkInternal(Regexp *re, T top_arg, bool use_copy);
-
-  Walker(const Walker &) = delete;
-  Walker &operator=(const Walker &) = delete;
-};
-
-template <typename T>
-T Regexp::Walker<T>::PreVisit(Regexp *re, T parent_arg, bool *stop) {
-  return parent_arg;
-}
-
-template <typename T>
-T Regexp::Walker<T>::PostVisit(Regexp *re, T parent_arg, T pre_arg,
-                               T *child_args, int nchild_args) {
-  return pre_arg;
-}
-
-template <typename T> T Regexp::Walker<T>::Copy(T arg) { return arg; }
-
-// State about a single level in the traversal.
-template <typename T> struct WalkState {
-  WalkState(Regexp *re, T parent)
-      : re(re), n(-1), parent_arg(parent), child_args(NULL) {}
-
-  Regexp *re; // The regexp
-  int n; // The index of the next child to process; -1 means need to PreVisit
-  T parent_arg; // Accumulated arguments.
-  T pre_arg;
-  T child_arg; // One-element buffer for child_args.
-  T *child_args;
-};
-
-template <typename T> Regexp::Walker<T>::Walker() { stopped_early_ = false; }
-
-template <typename T> Regexp::Walker<T>::~Walker() { Reset(); }
-
-// Clears the stack.  Should never be necessary, since
-// Walk always enters and exits with an empty stack.
-// Logs DFATAL if stack is not already clear.
-template <typename T> void Regexp::Walker<T>::Reset() {
-  if (!stack_.empty()) {
-    LOG(DFATAL) << "Stack not empty.";
-    while (!stack_.empty()) {
-      if (stack_.top().re->nsub_ > 1)
-        delete[] stack_.top().child_args;
-      stack_.pop();
-    }
-  }
-}
-
-template <typename T>
-T Regexp::Walker<T>::WalkInternal(Regexp *re, T top_arg, bool use_copy) {
-  Reset();
-
-  if (re == NULL) {
-    LOG(DFATAL) << "Walk NULL";
-    return top_arg;
-  }
-
-  stack_.push(WalkState<T>(re, top_arg));
-
-  WalkState<T> *s;
-  for (;;) {
-    T t;
-    s = &stack_.top();
-    re = s->re;
-    switch (s->n) {
-    case -1: {
-      if (--max_visits_ < 0) {
-        stopped_early_ = true;
-        t = ShortVisit(re, s->parent_arg);
-        break;
-      }
-      bool stop = false;
-      s->pre_arg = PreVisit(re, s->parent_arg, &stop);
-      if (stop) {
-        t = s->pre_arg;
-        break;
-      }
-      s->n = 0;
-      s->child_args = NULL;
-      if (re->nsub_ == 1)
-        s->child_args = &s->child_arg;
-      else if (re->nsub_ > 1)
-        s->child_args = new T[re->nsub_];
-      FALLTHROUGH_INTENDED;
-    }
-    default: {
-      if (re->nsub_ > 0) {
-        Regexp **sub = re->sub();
-        if (s->n < re->nsub_) {
-          if (use_copy && s->n > 0 && sub[s->n - 1] == sub[s->n]) {
-            s->child_args[s->n] = Copy(s->child_args[s->n - 1]);
-            s->n++;
-          } else {
-            stack_.push(WalkState<T>(sub[s->n], s->pre_arg));
-          }
-          continue;
-        }
-      }
-
-      t = PostVisit(re, s->parent_arg, s->pre_arg, s->child_args, s->n);
-      if (re->nsub_ > 1)
-        delete[] s->child_args;
-      break;
-    }
-    }
-
-    // We've finished stack_.top().
-    // Update next guy down.
-    stack_.pop();
-    if (stack_.empty())
-      return t;
-    s = &stack_.top();
-    if (s->child_args != NULL)
-      s->child_args[s->n] = t;
-    else
-      s->child_arg = t;
-    s->n++;
-  }
-}
-
-template <typename T> T Regexp::Walker<T>::Walk(Regexp *re, T top_arg) {
-  // Without the exponential walking behavior,
-  // this budget should be more than enough for any
-  // regexp, and yet not enough to get us in trouble
-  // as far as CPU time.
-  max_visits_ = 1000000;
-  return WalkInternal(re, top_arg, true);
-}
-
-template <typename T>
-T Regexp::Walker<T>::WalkExponential(Regexp *re, T top_arg, int max_visits) {
-  max_visits_ = max_visits;
-  return WalkInternal(re, top_arg, false);
-}
-
-} // namespace re2
-
-#endif // RE2_WALKER_INL_H_

package/third-party/ios/ExecutorchLib/frameworks/re2.xcframework/ios-arm64/re2.framework/Info.plist

@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>CFBundleDevelopmentRegion</key>
-	<string>English</string>
-	<key>CFBundleExecutable</key>
-	<string>re2</string>
-	<key>CFBundleIconFile</key>
-	<string></string>
-	<key>CFBundleIdentifier</key>
-	<string>com.google.re2</string>
-	<key>CFBundleInfoDictionaryVersion</key>
-	<string>6.0</string>
-	<key>CFBundlePackageType</key>
-	<string>FMWK</string>
-	<key>CFBundleSignature</key>
-	<string>????</string>
-	<key>CFBundleVersion</key>
-	<string></string>
-	<key>CFBundleShortVersionString</key>
-	<string></string>
-	<key>CSResourcesFileMapped</key>
-	<true/>
-</dict>
-</plist>

package/third-party/ios/ExecutorchLib/frameworks/re2.xcframework/ios-arm64-simulator/re2.framework/Headers/bitmap256.h

@@ -1,82 +0,0 @@
-// Copyright 2016 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.
-
-#ifndef RE2_BITMAP256_H_
-#define RE2_BITMAP256_H_
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#endif
-#include <stdint.h>
-#include <string.h>
-
-#include "util/logging.h"
-
-namespace re2 {
-
-class Bitmap256 {
-public:
-  Bitmap256() { Clear(); }
-
-  // Clears all of the bits.
-  void Clear() { memset(words_, 0, sizeof words_); }
-
-  // Tests the bit with index c.
-  bool Test(int c) const {
-    DCHECK_GE(c, 0);
-    DCHECK_LE(c, 255);
-
-    return (words_[c / 64] & (uint64_t{1} << (c % 64))) != 0;
-  }
-
-  // Sets the bit with index c.
-  void Set(int c) {
-    DCHECK_GE(c, 0);
-    DCHECK_LE(c, 255);
-
-    words_[c / 64] |= (uint64_t{1} << (c % 64));
-  }
-
-  // Finds the next non-zero bit with index >= c.
-  // Returns -1 if no such bit exists.
-  int FindNextSetBit(int c) const;
-
-private:
-  // Finds the least significant non-zero bit in n.
-  static int FindLSBSet(uint64_t n) {
-    DCHECK_NE(n, 0);
-#if defined(__GNUC__)
-    return __builtin_ctzll(n);
-#elif defined(_MSC_VER) && defined(_M_X64)
-    unsigned long c;
-    _BitScanForward64(&c, n);
-    return static_cast<int>(c);
-#elif defined(_MSC_VER) && defined(_M_IX86)
-    unsigned long c;
-    if (static_cast<uint32_t>(n) != 0) {
-      _BitScanForward(&c, static_cast<uint32_t>(n));
-      return static_cast<int>(c);
-    } else {
-      _BitScanForward(&c, static_cast<uint32_t>(n >> 32));
-      return static_cast<int>(c) + 32;
-    }
-#else
-    int c = 63;
-    for (int shift = 1 << 5; shift != 0; shift >>= 1) {
-      uint64_t word = n << shift;
-      if (word != 0) {
-        n = word;
-        c -= shift;
-      }
-    }
-    return c;
-#endif
-  }
-
-  uint64_t words_[4];
-};
-
-} // namespace re2
-
-#endif // RE2_BITMAP256_H_