expressir 1.2.4 → 1.2.7

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/dfa/LexerDFASerializer.cpp

@@ -9,10 +9,7 @@
 
 using namespace antlr4::dfa;
 
-LexerDFASerializer::LexerDFASerializer(DFA *dfa) : DFASerializer(dfa, Vocabulary::EMPTY_VOCABULARY) {
-}
-
-LexerDFASerializer::~LexerDFASerializer() {
+LexerDFASerializer::LexerDFASerializer(const DFA *dfa) : DFASerializer(dfa, Vocabulary()) {
 }
 
 std::string LexerDFASerializer::getEdgeLabel(size_t i) const {

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/dfa/LexerDFASerializer.h

@@ -10,13 +10,12 @@
 namespace antlr4 {
 namespace dfa {
 
-  class ANTLR4CPP_PUBLIC LexerDFASerializer : public DFASerializer {
+  class ANTLR4CPP_PUBLIC LexerDFASerializer final : public DFASerializer {
   public:
-    LexerDFASerializer(DFA *dfa);
-    virtual ~LexerDFASerializer();
+    explicit LexerDFASerializer(const DFA *dfa);
 
   protected:
-    virtual std::string getEdgeLabel(size_t i) const override;
+    std::string getEdgeLabel(size_t i) const override;
   };
 
 } // namespace atn

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/misc/InterpreterDataReader.cpp

@@ -101,7 +101,7 @@ InterpreterData InterpreterDataReader::parseFile(std::string const& fileName) {
     };
   }
 
-  std::vector<uint16_t> serializedATN;
+  std::vector<int32_t> serializedATN;
 
   std::getline(input, line, '\n');
   assert(line == "atn:");
@@ -115,7 +115,7 @@ InterpreterData InterpreterDataReader::parseFile(std::string const& fileName) {
       number = std::strtoul(&value[1], nullptr, 10);
     else
       number = std::strtoul(value.c_str(), nullptr, 10);
-    serializedATN.push_back(static_cast<uint16_t>(number));
+    serializedATN.push_back(static_cast<int32_t>(number));
   }
 
   ATNDeserializer deserializer;

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/misc/InterpreterDataReader.h

@@ -6,12 +6,14 @@
 #pragma once
 
 #include "antlr4-common.h"
+#include "atn/ATN.h"
+#include "Vocabulary.h"
 
 namespace antlr4 {
 namespace misc {
 
   struct InterpreterData {
-    atn::ATN atn;
+    std::unique_ptr<atn::ATN> atn;
     dfa::Vocabulary vocabulary;
     std::vector<std::string> ruleNames;
     std::vector<std::string> channels; // Only valid for lexer grammars.

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/misc/Interval.cpp

@@ -7,35 +7,7 @@
 
 using namespace antlr4::misc;
 
-size_t antlr4::misc::numericToSymbol(ssize_t v) {
-  return static_cast<size_t>(v);
-}
-
-ssize_t antlr4::misc::symbolToNumeric(size_t v) {
-  return static_cast<ssize_t>(v);
-}
-
-Interval const Interval::INVALID;
-
-Interval::Interval() : Interval(static_cast<ssize_t>(-1), -2) { // Need an explicit cast here for VS.
-}
-
-Interval::Interval(size_t a_, size_t b_) : Interval(symbolToNumeric(a_), symbolToNumeric(b_)) {
-}
-
-Interval::Interval(ssize_t a_, ssize_t b_) : a(a_), b(b_) {
-}
-
-size_t Interval::length() const {
-  if (b < a) {
-    return 0;
-  }
-  return size_t(b - a + 1);
-}
-
-bool Interval::operator == (const Interval &other) const {
-  return a == other.a && b == other.b;
-}
+const Interval Interval::INVALID;
 
 size_t Interval::hashCode() const {
   size_t hash = 23;

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/misc/Interval.h

@@ -13,11 +13,11 @@ namespace misc {
   // Helpers to convert certain unsigned symbols (e.g. Token::EOF) to their original numeric value (e.g. -1)
   // and vice versa. This is needed mostly for intervals to keep their original order and for toString()
   // methods to print the original numeric value (e.g. for tests).
-  size_t numericToSymbol(ssize_t v);
-  ssize_t symbolToNumeric(size_t v);
+  constexpr size_t numericToSymbol(ssize_t v) { return static_cast<size_t>(v); }
+  constexpr ssize_t symbolToNumeric(size_t v) { return static_cast<ssize_t>(v); }
 
   /// An immutable inclusive interval a..b
-  class ANTLR4CPP_PUBLIC Interval {
+  class ANTLR4CPP_PUBLIC Interval final {
   public:
     static const Interval INVALID;
 
@@ -25,15 +25,17 @@ namespace misc {
     ssize_t a;
     ssize_t b;
 
-    Interval();
-    explicit Interval(size_t a_, size_t b_); // For unsigned -> signed mappings.
-    Interval(ssize_t a_, ssize_t b_);
+    constexpr Interval() : Interval(static_cast<ssize_t>(-1), static_cast<ssize_t>(-2)) {}
+
+    constexpr explicit Interval(size_t a_, size_t b_) : Interval(symbolToNumeric(a_), symbolToNumeric(b_)) {}
+
+    constexpr Interval(ssize_t a_, ssize_t b_) : a(a_), b(b_) {}
 
     /// return number of elements between a and b inclusively. x..x is length 1.
     ///  if b < a, then length is 0.  9..10 has length 2.
-    size_t length() const;
+    constexpr size_t length() const { return b >= a ? static_cast<size_t>(b - a + 1) : 0; }
 
-    bool operator == (const Interval &other) const;
+    constexpr bool operator==(const Interval &other) const { return a == other.a && b == other.b; }
 
     size_t hashCode() const;
 
@@ -76,8 +78,6 @@ namespace misc {
     Interval intersection(const Interval &other) const;
 
     std::string toString() const;
-
-  private:
   };
 
 } // namespace atn

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/misc/IntervalSet.cpp

@@ -13,7 +13,7 @@
 using namespace antlr4;
 using namespace antlr4::misc;
 
-IntervalSet const IntervalSet::COMPLETE_CHAR_SET = 
+IntervalSet const IntervalSet::COMPLETE_CHAR_SET =
     IntervalSet::of(Lexer::MIN_CHAR_VALUE, Lexer::MAX_CHAR_VALUE);
 
 IntervalSet const IntervalSet::EMPTY_SET;
@@ -265,18 +265,13 @@ bool IntervalSet::contains(size_t el) const {
 }
 
 bool IntervalSet::contains(ssize_t el) const {
-  if (_intervals.empty())
+  if (_intervals.empty() || el < _intervals.front().a || el > _intervals.back().b) {
     return false;
-
-  if (el < _intervals[0].a) // list is sorted and el is before first interval; not here
-    return false;
-
-  for (const auto &interval : _intervals) {
-    if (el >= interval.a && el <= interval.b) {
-      return true; // found in this interval
-    }
   }
-  return false;
+
+  return std::binary_search(_intervals.begin(), _intervals.end(), Interval(el, el), [](const Interval &lhs, const Interval &rhs) {
+    return lhs.b < rhs.a;
+  });
 }
 
 bool IntervalSet::isEmpty() const {
@@ -306,7 +301,7 @@ ssize_t IntervalSet::getMinElement() const {
     return Token::INVALID_TYPE;
   }
 
-  return _intervals[0].a;
+  return _intervals.front().a;
 }
 
 std::vector<Interval> const& IntervalSet::getIntervals() const {
@@ -379,10 +374,6 @@ std::string IntervalSet::toString(bool elemAreChar) const {
   return ss.str();
 }
 
-std::string IntervalSet::toString(const std::vector<std::string> &tokenNames) const {
-  return toString(dfa::Vocabulary::fromTokenNames(tokenNames));
-}
-
 std::string IntervalSet::toString(const dfa::Vocabulary &vocabulary) const {
   if (_intervals.empty()) {
     return "{}";
@@ -420,10 +411,6 @@ std::string IntervalSet::toString(const dfa::Vocabulary &vocabulary) const {
   return ss.str();
 }
 
-std::string IntervalSet::elementName(const std::vector<std::string> &tokenNames, ssize_t a) const {
-  return elementName(dfa::Vocabulary::fromTokenNames(tokenNames), a);
-}
-
 std::string IntervalSet::elementName(const dfa::Vocabulary &vocabulary, ssize_t a) const {
   if (a == -1) {
     return "<EOF>";

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/misc/IntervalSet.h

@@ -23,7 +23,7 @@ namespace misc {
    * the range {@link Integer#MIN_VALUE} to {@link Integer#MAX_VALUE}
    * (inclusive).</p>
    */
-  class ANTLR4CPP_PUBLIC IntervalSet {
+  class ANTLR4CPP_PUBLIC IntervalSet final {
   public:
     static IntervalSet const COMPLETE_CHAR_SET;
     static IntervalSet const EMPTY_SET;
@@ -151,17 +151,9 @@ namespace misc {
     std::string toString() const;
     std::string toString(bool elemAreChar) const;
 
-    /**
-     * @deprecated Use {@link #toString(Vocabulary)} instead.
-     */
-    std::string toString(const std::vector<std::string> &tokenNames) const;
     std::string toString(const dfa::Vocabulary &vocabulary) const;
 
   protected:
-    /**
-     * @deprecated Use {@link #elementName(Vocabulary, int)} instead.
-     */
-    std::string elementName(const std::vector<std::string> &tokenNames, ssize_t a) const;
     std::string elementName(const dfa::Vocabulary &vocabulary, ssize_t a) const;
 
   public:

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/misc/MurmurHash.cpp

@@ -3,6 +3,10 @@
  * can be found in the LICENSE.txt file in the project root.
  */
 
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
 #include "misc/MurmurHash.h"
 
 using namespace antlr4::misc;
@@ -17,118 +21,100 @@ using namespace antlr4::misc;
 
 #if defined(_MSC_VER)
 
-#define FORCE_INLINE	__forceinline
-
 #include <stdlib.h>
 
 #define ROTL32(x,y)	_rotl(x,y)
 #define ROTL64(x,y)	_rotl64(x,y)
 
-#define BIG_CONSTANT(x) (x)
+#elif ANTLR4CPP_HAVE_BUILTIN(__builtin_rotateleft32) && ANTLR4CPP_HAVE_BUILTIN(__builtin_rotateleft64)
+
+#define ROTL32(x, y) __builtin_rotateleft32(x, y)
+#define ROTL64(x, y) __builtin_rotateleft64(x, y)
 
 #else	// defined(_MSC_VER)
 
 // Other compilers
 
-#define	FORCE_INLINE inline __attribute__((always_inline))
+namespace {
 
-inline uint32_t rotl32 (uint32_t x, int8_t r)
-{
+constexpr uint32_t ROTL32(uint32_t x, int r) {
   return (x << r) | (x >> (32 - r));
 }
-
-inline uint64_t rotl64 (uint64_t x, int8_t r)
-{
+constexpr uint64_t ROTL64(uint64_t x, int r) {
   return (x << r) | (x >> (64 - r));
 }
 
-#define	ROTL32(x,y)	rotl32(x,y)
-#define ROTL64(x,y)	rotl64(x,y)
-
-#define BIG_CONSTANT(x) (x##LLU)
-
-#endif // !defined(_MSC_VER)
-
-size_t MurmurHash::initialize() {
-  return initialize(DEFAULT_SEED);
-}
-
-size_t MurmurHash::initialize(size_t seed) {
-  return seed;
 }
 
-#if defined(_WIN32) || defined(_WIN64)
-  #if _WIN64
-    #define ENVIRONMENT64
-  #else
-    #define ENVIRONMENT32
-  #endif
-#endif
-
-#if defined(__GNUC__)
-  #if defined(__x86_64__) || defined(__ppc64__)
-    #define ENVIRONMENT64
-  #else
-    #define ENVIRONMENT32
-  #endif
-#endif
+#endif // !defined(_MSC_VER)
 
-#if defined(ENVIRONMENT32)
+#if SIZE_MAX == UINT64_MAX
 
 size_t MurmurHash::update(size_t hash, size_t value) {
-  static const size_t c1 = 0xCC9E2D51;
-  static const size_t c2 = 0x1B873593;
-
   size_t k1 = value;
-  k1 *= c1;
-  k1 = ROTL32(k1, 15);
-  k1 *= c2;
+  k1 *= UINT64_C(0x87c37b91114253d5);
+  k1 = ROTL64(k1, 31);
+  k1 *= UINT64_C(0x4cf5ad432745937f);
 
   hash ^= k1;
-  hash = ROTL32(hash, 13);
-  hash = hash * 5 + 0xE6546B64;
+  hash = ROTL64(hash, 27);
+  hash = hash * 5 + UINT64_C(0x52dce729);
 
   return hash;
 }
 
+size_t MurmurHash::update(size_t hash, const void *data, size_t size) {
+  size_t value;
+  const uint8_t *bytes = static_cast<const uint8_t*>(data);
+  while (size >= sizeof(size_t)) {
+    std::memcpy(&value, bytes, sizeof(size_t));
+    hash = update(hash, value);
+    bytes += sizeof(size_t);
+    size -= sizeof(size_t);
+  }
+  if (size != 0) {
+    value = 0;
+    std::memcpy(&value, bytes, size);
+    hash = update(hash, value);
+  }
+  return hash;
+}
 
 size_t MurmurHash::finish(size_t hash, size_t entryCount) {
-  hash ^= entryCount * 4;
-  hash ^= hash >> 16;
-  hash *= 0x85EBCA6B;
-  hash ^= hash >> 13;
-  hash *= 0xC2B2AE35;
-  hash ^= hash >> 16;
+  hash ^= entryCount * 8;
+  hash ^= hash >> 33;
+  hash *= UINT64_C(0xff51afd7ed558ccd);
+  hash ^= hash >> 33;
+  hash *= UINT64_C(0xc4ceb9fe1a85ec53);
+  hash ^= hash >> 33;
   return hash;
 }
 
-#else
+#elif SIZE_MAX == UINT32_MAX
 
 size_t MurmurHash::update(size_t hash, size_t value) {
-  static const size_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
-  static const size_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);
-
   size_t k1 = value;
-  k1 *= c1;
-  k1 = ROTL64(k1, 31);
-  k1 *= c2;
+  k1 *= UINT32_C(0xCC9E2D51);
+  k1 = ROTL32(k1, 15);
+  k1 *= UINT32_C(0x1B873593);
 
   hash ^= k1;
-  hash = ROTL64(hash, 27);
-  hash = hash * 5 + 0x52dce729;
+  hash = ROTL32(hash, 13);
+  hash = hash * 5 + UINT32_C(0xE6546B64);
 
   return hash;
 }
 
-
 size_t MurmurHash::finish(size_t hash, size_t entryCount) {
-  hash ^= entryCount * 8;
-  hash ^= hash >> 33;
-  hash *= 0xff51afd7ed558ccd;
-  hash ^= hash >> 33;
-  hash *= 0xc4ceb9fe1a85ec53;
-  hash ^= hash >> 33;
+  hash ^= entryCount * 4;
+  hash ^= hash >> 16;
+  hash *= UINT32_C(0x85EBCA6B);
+  hash ^= hash >> 13;
+  hash *= UINT32_C(0xC2B2AE35);
+  hash ^= hash >> 16;
   return hash;
 }
 
+#else
+#error "Expected sizeof(size_t) to be 4 or 8."
 #endif

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/misc/MurmurHash.h

@@ -5,29 +5,25 @@
 
 #pragma once
 
+#include <cstdint>
+#include <type_traits>
+
 #include "antlr4-common.h"
 
 namespace antlr4 {
 namespace misc {
 
-  class ANTLR4CPP_PUBLIC MurmurHash {
-
+  class ANTLR4CPP_PUBLIC MurmurHash final {
   private:
-#if __cplusplus >= 201703L
     static constexpr size_t DEFAULT_SEED = 0;
-#else
-    enum : size_t {
-      DEFAULT_SEED = 0,
-    };
-#endif
 
     /// Initialize the hash using the default seed value.
     /// Returns the intermediate hash value.
   public:
-    static size_t initialize();
+    static size_t initialize() { return initialize(DEFAULT_SEED); }
 
     /// Initialize the hash using the specified seed.
-    static size_t initialize(size_t seed);
+    static size_t initialize(size_t seed) { return seed; }
 
     /// Update the intermediate hash value for the next input {@code value}.
     /// <param name="hash"> the intermediate hash value </param>
@@ -52,6 +48,13 @@ namespace misc {
       return update(hash, value != nullptr ? value->hashCode() : 0);
     }
 
+    static size_t update(size_t hash, const void *data, size_t size);
+
+    template <typename T>
+    static size_t update(size_t hash, const T *data, size_t size) {
+      return update(hash, static_cast<const void*>(data), size * sizeof(std::remove_reference_t<T>));
+    }
+
     /// <summary>
     /// Apply the final computation steps to the intermediate value {@code hash}
     /// to form the final result of the MurmurHash 3 hash function.
@@ -68,14 +71,31 @@ namespace misc {
     /// <param name="seed"> the seed for the MurmurHash algorithm </param>
     /// <returns> the hash code of the data </returns>
     template<typename T> // where T is C array type
-    static size_t hashCode(const std::vector<Ref<T>> &data, size_t seed) {
+    static size_t hashCode(const std::vector<Ref<T>> &data, size_t seed = DEFAULT_SEED) {
       size_t hash = initialize(seed);
-      for (auto entry : data) {
-        hash = update(hash, entry->hashCode());
+      for (auto &entry : data) {
+        hash = update(hash, entry);
       }
-
       return finish(hash, data.size());
     }
+
+    static size_t hashCode(const void *data, size_t size, size_t seed = DEFAULT_SEED) {
+      size_t hash = initialize(seed);
+      hash = update(hash, data, size);
+      return finish(hash, size);
+    }
+
+    template <typename T>
+    static size_t hashCode(const T *data, size_t size, size_t seed = DEFAULT_SEED) {
+      return hashCode(static_cast<const void*>(data), size * sizeof(std::remove_reference_t<T>), seed);
+    }
+
+  private:
+    MurmurHash() = delete;
+
+    MurmurHash(const MurmurHash&) = delete;
+
+    MurmurHash& operator=(const MurmurHash&) = delete;
   };
 
 } // namespace atn

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/support/Any.cpp

@@ -6,8 +6,3 @@
 #include "Any.h"
 
 using namespace antlrcpp;
-
-Any::~Any()
-{
-    delete _ptr;
-}

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/support/Any.h

@@ -9,162 +9,8 @@
 
 #include "antlr4-common.h"
 
-#ifdef _MSC_VER
-  #pragma warning(push)
-  #pragma warning(disable: 4521) // 'antlrcpp::Any': multiple copy constructors specified
-#endif
-
 namespace antlrcpp {
 
-template<class T>
-  using StorageType = typename std::decay<T>::type;
-
-struct ANTLR4CPP_PUBLIC Any
-{
-  bool isNull() const { return _ptr == nullptr; }
-  bool isNotNull() const { return _ptr != nullptr; }
-
-  Any() : _ptr(nullptr) {
-  }
-
-  Any(Any& that) : _ptr(that.clone()) {
-  }
-
-  Any(Any&& that) : _ptr(that._ptr) {
-    that._ptr = nullptr;
-  }
-
-  Any(const Any& that) : _ptr(that.clone()) {
-  }
-
-  Any(const Any&& that) : _ptr(that.clone()) {
-  }
-
-  template<typename U>
-  Any(U&& value) : _ptr(new Derived<StorageType<U>>(std::forward<U>(value))) {
-  }
-
-  template<class U>
-  bool is() const {
-    auto derived = getDerived<U>(false);
-
-    return derived != nullptr;
-  }
-
-  template<class U>
-  StorageType<U>& as() {
-    auto derived = getDerived<U>(true);
-
-    return derived->value;
-  }
-
-  template<class U>
-  const StorageType<U>& as() const {
-    auto derived = getDerived<U>(true);
-
-    return derived->value;
-  }
-
-  template<class U>
-  operator U() {
-    return as<StorageType<U>>();
-  }
-
-  template<class U>
-  operator const U() const {
-    return as<const StorageType<U>>();
-  }
-
-  Any& operator = (const Any& a) {
-    if (_ptr == a._ptr)
-      return *this;
-
-    auto * old_ptr = _ptr;
-    _ptr = a.clone();
-
-    if (old_ptr)
-      delete old_ptr;
-
-    return *this;
-  }
-
-  Any& operator = (Any&& a) {
-    if (_ptr == a._ptr)
-      return *this;
-
-    std::swap(_ptr, a._ptr);
-
-    return *this;
-  }
-
-  virtual ~Any();
-
-  virtual bool equals(Any other) const {
-    return _ptr == other._ptr;
-  }
-
-private:
-  struct Base {
-    virtual ~Base() {};
-    virtual Base* clone() const = 0;
-  };
-
-  template<typename T>
-  struct Derived : Base
-  {
-    template<typename U> Derived(U&& value_) : value(std::forward<U>(value_)) {
-    }
-
-    T value;
-
-    Base* clone() const {
-      return clone<>();
-    }
-
-  private:
-    template<int N = 0, typename std::enable_if<N == N && std::is_nothrow_copy_constructible<T>::value, int>::type = 0>
-    Base* clone() const {
-      return new Derived<T>(value);
-    }
-
-    template<int N = 0, typename std::enable_if<N == N && !std::is_nothrow_copy_constructible<T>::value, int>::type = 0>
-    Base* clone() const {
-      return nullptr;
-    }
-
-  };
-
-  Base* clone() const
-  {
-    if (_ptr)
-      return _ptr->clone();
-    else
-      return nullptr;
-  }
-
-  template<class U>
-  Derived<StorageType<U>>* getDerived(bool checkCast) const {
-    typedef StorageType<U> T;
-
-    auto derived = dynamic_cast<Derived<T>*>(_ptr);
-
-    if (checkCast && !derived)
-      throw std::bad_cast();
-
-    return derived;
-  }
-
-  Base *_ptr;
-
-};
-
-  template<> inline
-  Any::Any(std::nullptr_t&& ) : _ptr(nullptr) {
-  }
-
+  using Any = std::any;
 
 } // namespace antlrcpp
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif