expressir 1.2.4 → 1.2.7

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);
       }
@@ -49,15 +49,12 @@ namespace antlrcpp {
             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,40 +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) {
-#ifndef USE_UTF8_INSTEAD_OF_CODECVT
-  std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
-  std::string narrow = converter.to_bytes(wstr);
-#else
-  std::string narrow;
-  utf8::utf32to8(wstr.begin(), wstr.end(), std::back_inserter(narrow));
-#endif
-
-  return narrow;
-}
 
-std::wstring s2ws(const std::string &str) {
-#ifndef USE_UTF8_INSTEAD_OF_CODECVT
-  std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
-  std::wstring wide = converter.from_bytes(str);
-#else
-  std::wstring wide;
-  utf8::utf8to32(str.begin(), str.end(), std::back_inserter(wide));
-#endif
-
-  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

@@ -7,70 +7,10 @@
 
 #include "antlr4-common.h"
 
-#ifdef USE_UTF8_INSTEAD_OF_CODECVT
-#include "utf8.h"
-#endif
-
 namespace antlrcpp {
 
-  // For all conversions utf8 <-> utf32.
-  // I wouldn't prefer wstring_convert because: according to
-  // https://en.cppreference.com/w/cpp/locale/wstring_convert,
-  // wstring_convert is deprecated in C++17.
-  // utfcpp (https://github.com/nemtrif/utfcpp) is a substitution.
-#ifndef USE_UTF8_INSTEAD_OF_CODECVT
-  // 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
-#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)
-  {
-    #ifndef USE_UTF8_INSTEAD_OF_CODECVT
-      // Don't make the converter static or we have to serialize access to it.
-      thread_local UTF32Converter converter;
-
-      #if defined(_MSC_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
-        const auto p = reinterpret_cast<const int32_t *>(data.data());
-        return converter.to_bytes(p, p + data.size());
-      #else
-        return converter.to_bytes(data);
-      #endif
-    #else
-      std::string narrow;
-      utf8::utf32to8(data.begin(), data.end(), std::back_inserter(narrow));
-      return narrow;
-    #endif
-  }
-
-  inline UTF32String utf8_to_utf32(const char* first, const char* last)
-  {
-    #ifndef USE_UTF8_INSTEAD_OF_CODECVT
-      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());
-        return s;
-      #else
-        std::u32string s = converter.from_bytes(first, last);
-        return s;
-      #endif
-    #else
-      UTF32String wide;
-      utf8::utf8to32(first, last, std::back_inserter(wide));
-      return wide;
-    #endif
-  }
+  ANTLR4CPP_PUBLIC std::string escapeWhitespace(std::string_view in);
 
-  void replaceAll(std::string &str, std::string const& from, std::string const& to);
+  ANTLR4CPP_PUBLIC std::string& escapeWhitespace(std::string& out, std::string_view in);
 
-  // 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);
 }

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

@@ -0,0 +1,28 @@
+/* Copyright (c) 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 "antlr4-common.h"
+
+namespace antlrcpp {
+
+  class ANTLR4CPP_PUBLIC Unicode final {
+  public:
+    static constexpr char32_t REPLACEMENT_CHARACTER = 0xfffd;
+
+    static constexpr bool isValid(char32_t codePoint) {
+      return codePoint < 0xd800 || (codePoint > 0xdfff && codePoint <= 0x10ffff);
+    }
+
+  private:
+    Unicode() = delete;
+    Unicode(const Unicode&) = delete;
+    Unicode(Unicode&&) = delete;
+    Unicode& operator=(const Unicode&) = delete;
+    Unicode& operator=(Unicode&&) = delete;
+  };
+
+}