expressir 1.2.3 → 1.2.6

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

@@ -5,23 +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:
-    static const size_t DEFAULT_SEED = 0;
+    static constexpr size_t DEFAULT_SEED = 0;
 
     /// 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>
@@ -46,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.
@@ -62,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

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

@@ -16,7 +16,7 @@ std::string Arrays::listToString(const std::vector<std::string> &list, const std
   bool firstEntry = true;
 
   ss << '[';
-  for (auto &entry : list) {
+  for (const auto &entry : list) {
     ss << entry;
     if (firstEntry) {
       ss << separator;
@@ -32,7 +32,7 @@ template <>
 std::string Arrays::toString(const std::vector<antlr4::tree::ParseTree*> &source) {
   std::string result = "[";
   bool firstEntry = true;
-  for (auto value : source) {
+  for (auto *value : source) {
     result += value->toStringTree();
     if (firstEntry) {
       result += ", ";

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

@@ -32,8 +32,13 @@ namespace antlrcpp {
         return false;
 
       for (size_t i = 0; i < a.size(); ++i) {
+        if (!a[i] && !b[i])
+          continue;
+        if (!a[i] || !b[i])
+          return false;
         if (a[i] == b[i])
           continue;
+
         if (!(*a[i] == *b[i]))
           return false;
       }
@@ -61,6 +66,26 @@ namespace antlrcpp {
       return true;
     }
 
+    template <typename T>
+    static bool equals(const std::vector<std::unique_ptr<T>> &a, const std::vector<std::unique_ptr<T>> &b) {
+      if (a.size() != b.size())
+        return false;
+
+      for (size_t i = 0; i < a.size(); ++i) {
+        if (!a[i] && !b[i])
+          continue;
+        if (!a[i] || !b[i])
+          return false;
+        if (a[i] == b[i])
+          continue;
+
+        if (!(*a[i] == *b[i]))
+          return false;
+      }
+
+      return true;
+    }
+
     template <typename T>
     static std::string toString(const std::vector<T> &source) {
       std::string result = "[";
@@ -89,6 +114,20 @@ namespace antlrcpp {
       return result + "]";
     }
 
+    template <typename T>
+    static std::string toString(const std::vector<std::unique_ptr<T>> &source) {
+      std::string result = "[";
+      bool firstEntry = true;
+      for (auto &value : source) {
+        result += value->toString();
+        if (firstEntry) {
+          result += ", ";
+          firstEntry = false;
+        }
+      }
+      return result + "]";
+    }
+
     template <typename T>
     static std::string toString(const std::vector<T *> &source) {
       std::string result = "[";

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

@@ -54,7 +54,7 @@ namespace antlrcpp {
       return result;
     }
 
-    std::string toString(){
+    std::string toString() const {
       std::stringstream stream;
       stream << "{";
       bool valueAdded = false;

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

@@ -7,10 +7,10 @@
 
 namespace antlrcpp {
 
-  std::string join(std::vector<std::string> strings, const std::string &separator) {
+  std::string join(const std::vector<std::string> &strings, const std::string &separator) {
     std::string str;
     bool firstItem = true;
-    for (std::string s : strings) {
+    for (const std::string &s : strings) {
       if (!firstItem) {
         str.append(separator);
       }
@@ -46,18 +46,15 @@ namespace antlrcpp {
 
         case ' ':
           if (escapeSpaces) {
-            result += "·";
+            result += "\u00B7";
             break;
           }
-          // else fall through
-#ifndef _MSC_VER
-#if __has_cpp_attribute(clang::fallthrough)
-          [[clang::fallthrough]];
-#endif
-#endif
+          result += c;
+          break;
 
         default:
           result += c;
+          break;
       }
     }
 
@@ -72,8 +69,13 @@ namespace antlrcpp {
 
   std::string arrayToString(const std::vector<std::string> &data) {
     std::string answer;
-    for (auto sub: data) {
-      answer += sub;
+    size_t toReserve = 0;
+    for (const auto &sub : data) {
+      toReserve += sub.size();
+    }
+    answer.reserve(toReserve);
+    for (const auto &sub: data) {
+      answer.append(sub);
     }
     return answer;
   }
@@ -202,47 +204,4 @@ namespace antlrcpp {
     return result;
   }
 
-  //----------------- FinallyAction ------------------------------------------------------------------------------------
-
-  FinalAction finally(std::function<void ()> f) {
-    return FinalAction(f);
-  }
-
-  //----------------- SingleWriteMultipleRead --------------------------------------------------------------------------
-
-  void SingleWriteMultipleReadLock::readLock() {
-    std::unique_lock<std::mutex> lock(_mutex);
-    while (_waitingWriters != 0)
-      _readerGate.wait(lock);
-    ++_activeReaders;
-    lock.unlock();
-  }
-
-  void SingleWriteMultipleReadLock::readUnlock() {
-    std::unique_lock<std::mutex> lock(_mutex);
-    --_activeReaders;
-    lock.unlock();
-    _writerGate.notify_one();
-  }
-
-  void SingleWriteMultipleReadLock::writeLock() {
-    std::unique_lock<std::mutex> lock(_mutex);
-    ++_waitingWriters;
-    while (_activeReaders != 0 || _activeWriters != 0)
-      _writerGate.wait(lock);
-    ++_activeWriters;
-    lock.unlock();
-  }
-
-  void SingleWriteMultipleReadLock::writeUnlock() {
-    std::unique_lock<std::mutex> lock(_mutex);
-    --_waitingWriters;
-    --_activeWriters;
-    if (_waitingWriters > 0)
-      _writerGate.notify_one();
-    else
-      _readerGate.notify_all();
-    lock.unlock();
-  }
-
 } // namespace antlrcpp

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

@@ -9,18 +9,19 @@
 
 namespace antlrcpp {
 
-  std::string join(std::vector<std::string> strings, const std::string &separator);
-  std::map<std::string, size_t> toMap(const std::vector<std::string> &keys);
-  std::string escapeWhitespace(std::string str, bool escapeSpaces);
-  std::string toHexString(const int t);
-  std::string arrayToString(const std::vector<std::string> &data);
-  std::string replaceString(const std::string &s, const std::string &from, const std::string &to);
-  std::vector<std::string> split(const std::string &s, const std::string &sep, int count);
-  std::string indent(const std::string &s, const std::string &indentation, bool includingFirst = true);
+  ANTLR4CPP_PUBLIC std::string join(const std::vector<std::string> &strings, const std::string &separator);
+  ANTLR4CPP_PUBLIC std::map<std::string, size_t> toMap(const std::vector<std::string> &keys);
+  ANTLR4CPP_PUBLIC std::string escapeWhitespace(std::string str, bool escapeSpaces);
+  ANTLR4CPP_PUBLIC std::string toHexString(const int t);
+  ANTLR4CPP_PUBLIC std::string arrayToString(const std::vector<std::string> &data);
+  ANTLR4CPP_PUBLIC std::string replaceString(const std::string &s, const std::string &from, const std::string &to);
+  ANTLR4CPP_PUBLIC std::vector<std::string> split(const std::string &s, const std::string &sep, int count);
+  ANTLR4CPP_PUBLIC std::string indent(const std::string &s, const std::string &indentation, bool includingFirst = true);
 
   // Using RAII + a lambda to implement a "finally" replacement.
+  template <typename OnEnd>
   struct FinalAction {
-    FinalAction(std::function<void ()> f) : _cleanUp { f } {}
+    FinalAction(OnEnd f) : _cleanUp { std::move(f) } {}
     FinalAction(FinalAction &&other) :
 	_cleanUp(std::move(other._cleanUp)), _enabled(other._enabled) {
       other._enabled = false; // Don't trigger the lambda after ownership has moved.
@@ -29,11 +30,14 @@ namespace antlrcpp {
 
     void disable() { _enabled = false; }
   private:
-    std::function<void ()> _cleanUp;
+    OnEnd _cleanUp;
     bool _enabled {true};
   };
 
-  ANTLR4CPP_PUBLIC FinalAction finally(std::function<void ()> f);
+  template <typename OnEnd>
+  FinalAction<OnEnd> finally(OnEnd f) {
+    return FinalAction<OnEnd>(std::move(f));
+  }
 
   // Convenience functions to avoid lengthy dynamic_cast() != nullptr checks in many places.
   template <typename T1, typename T2>
@@ -56,23 +60,6 @@ namespace antlrcpp {
   }
 
   // Get the error text from an exception pointer or the current exception.
-  std::string what(std::exception_ptr eptr = std::current_exception());
-
-  class SingleWriteMultipleReadLock {
-  public:
-    void readLock();
-    void readUnlock();
-    void writeLock();
-    void writeUnlock();
-
-  private:
-    std::condition_variable _readerGate;
-    std::condition_variable _writerGate;
-
-    std::mutex _mutex;
-    size_t _activeReaders = 0;
-    size_t _waitingWriters = 0;
-    size_t _activeWriters = 0;
-  };
+  ANTLR4CPP_PUBLIC std::string what(std::exception_ptr eptr = std::current_exception());
 
 } // namespace antlrcpp

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

@@ -0,0 +1,34 @@
+/* Copyright (c) 2012-2021 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+#pragma once
+
+#include <cassert>
+#include <memory>
+#include <type_traits>
+
+namespace antlrcpp {
+
+  template <typename To, typename From>
+  To downCast(From* from) {
+    static_assert(std::is_pointer_v<To>, "Target type not a pointer.");
+    static_assert(std::is_base_of_v<From, std::remove_pointer_t<To>>, "Target type not derived from source type.");
+  #if !defined(__GNUC__) || defined(__GXX_RTTI)
+    assert(from == nullptr || dynamic_cast<To>(from) != nullptr);
+  #endif
+    return static_cast<To>(from);
+  }
+
+  template <typename To, typename From>
+  To downCast(From& from) {
+    static_assert(std::is_lvalue_reference_v<To>, "Target type not a lvalue reference.");
+    static_assert(std::is_base_of_v<From, std::remove_reference_t<To>>, "Target type not derived from source type.");
+  #if !defined(__GNUC__) || defined(__GXX_RTTI)
+    assert(dynamic_cast<std::add_pointer_t<std::remove_reference_t<To>>>(std::addressof(from)) != nullptr);
+  #endif
+    return static_cast<To>(from);
+  }
+
+}

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

@@ -69,7 +69,6 @@ namespace antlr4 {
     class ATNSimulator;
     class ATNState;
     enum class ATNType;
-    class AbstractPredicateTransition;
     class ActionTransition;
     class ArrayPredictionContext;
     class AtomTransition;
@@ -78,7 +77,6 @@ namespace antlr4 {
     class BlockEndState;
     class BlockStartState;
     class DecisionState;
-    class EmptyPredictionContext;
     class EpsilonTransition;
     class LL1Analyzer;
     class LexerAction;

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

@@ -7,30 +7,32 @@
 
 namespace antlrcpp {
 
-void replaceAll(std::string& str, std::string const& from, std::string const& to)
-{
-  if (from.empty())
-    return;
-
-  size_t start_pos = 0;
-  while ((start_pos = str.find(from, start_pos)) != std::string::npos) {
-    str.replace(start_pos, from.length(), to);
-    start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'.
+  std::string escapeWhitespace(std::string_view in) {
+    std::string out;
+    escapeWhitespace(out, in);
+    out.shrink_to_fit();
+    return out;
   }
-}
-
-std::string ws2s(std::wstring const& wstr) {
-  std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
-  std::string narrow = converter.to_bytes(wstr);
 
-  return narrow;
-}
-
-std::wstring s2ws(const std::string &str) {
-  std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
-  std::wstring wide = converter.from_bytes(str);
-  
-  return wide;
-}
+  std::string& escapeWhitespace(std::string& out, std::string_view in) {
+    out.reserve(in.size());  // Best case, no escaping.
+    for (const auto &c : in) {
+      switch (c) {
+        case '\t':
+          out.append("\\t");
+          break;
+        case '\r':
+          out.append("\\r");
+          break;
+        case '\n':
+          out.append("\\n");
+          break;
+        default:
+          out.push_back(c);
+          break;
+      }
+    }
+    return out;
+  }
 
 } // namespace antrlcpp

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

@@ -9,46 +9,8 @@
 
 namespace antlrcpp {
 
-  // For all conversions utf8 <-> utf32.
-  // VS 2015 and VS 2017 have different bugs in std::codecvt_utf8<char32_t> (VS 2013 works fine).
-#if defined(_MSC_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
-  typedef std::wstring_convert<std::codecvt_utf8<__int32>, __int32> UTF32Converter;
-#else
-  typedef std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> UTF32Converter;
-#endif
-  
-  // The conversion functions fails in VS2017, so we explicitly use a workaround.
-  template<typename T>
-  inline std::string utf32_to_utf8(T const& data)
-  {
-    // Don't make the converter static or we have to serialize access to it.
-    thread_local UTF32Converter converter;
+  ANTLR4CPP_PUBLIC std::string escapeWhitespace(std::string_view in);
 
-    #if defined(_MSC_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
-      auto p = reinterpret_cast<const int32_t *>(data.data());
-      return converter.to_bytes(p, p + data.size());
-    #else
-      return converter.to_bytes(data);
-    #endif
-  }
+  ANTLR4CPP_PUBLIC std::string& escapeWhitespace(std::string& out, std::string_view in);
 
-  inline UTF32String utf8_to_utf32(const char* first, const char* last)
-  {
-    thread_local UTF32Converter converter;
-
-    #if defined(_MSC_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
-      auto r = converter.from_bytes(first, last);
-      i32string s = reinterpret_cast<const int32_t *>(r.data());
-    #else
-      std::u32string s = converter.from_bytes(first, last);
-    #endif
-    
-    return s;
-  }
-
-  void replaceAll(std::string &str, std::string const& from, std::string const& to);
-
-  // string <-> wstring conversion (UTF-16), e.g. for use with Window's wide APIs.
-  ANTLR4CPP_PUBLIC std::string ws2s(std::wstring const& wstr);
-  ANTLR4CPP_PUBLIC std::wstring s2ws(std::string const& str);
 }