expressir 0.2.4-x64-mingw32 → 0.2.10-x64-mingw32

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

@@ -1,170 +0,0 @@
-/* Copyright (c) 2012-2017 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.
- */
-
-// A standard C++ class loosely modeled after boost::Any.
-
-#pragma once
-
-#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) {
-  }
-
-
-} // namespace antlrcpp
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif

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

@@ -1,43 +0,0 @@
-/* Copyright (c) 2012-2017 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.
- */
-
-#include "tree/ParseTree.h"
-#include "Exceptions.h"
-
-#include "support/Arrays.h"
-
-using namespace antlrcpp;
-
-std::string Arrays::listToString(const std::vector<std::string> &list, const std::string &separator)
-{
-  std::stringstream ss;
-  bool firstEntry = true;
-
-  ss << '[';
-  for (auto &entry : list) {
-    ss << entry;
-    if (firstEntry) {
-      ss << separator;
-      firstEntry = false;
-    }
-  }
-
-  ss << ']';
-  return ss.str();
-}
-
-template <>
-std::string Arrays::toString(const std::vector<antlr4::tree::ParseTree*> &source) {
-  std::string result = "[";
-  bool firstEntry = true;
-  for (auto value : source) {
-    result += value->toStringTree();
-    if (firstEntry) {
-      result += ", ";
-      firstEntry = false;
-    }
-  }
-  return result + "]";
-}

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

@@ -1,110 +0,0 @@
-/* Copyright (c) 2012-2017 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 Arrays {
-  public:
-
-    static std::string listToString(const std::vector<std::string> &list, const std::string &separator);
-
-    template <typename T>
-    static bool equals(const std::vector<T> &a, const std::vector<T> &b) {
-      if (a.size() != b.size())
-        return false;
-
-      for (size_t i = 0; i < a.size(); ++i)
-        if (!(a[i] == b[i]))
-          return false;
-
-      return true;
-    }
-
-    template <typename T>
-    static bool equals(const std::vector<T *> &a, const std::vector<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;
-      }
-
-      return true;
-    }
-
-    template <typename T>
-    static bool equals(const std::vector<Ref<T>> &a, const std::vector<Ref<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 = "[";
-      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<Ref<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 = "[";
-      bool firstEntry = true;
-      for (auto value : source) {
-        result += value->toString();
-        if (firstEntry) {
-          result += ", ";
-          firstEntry = false;
-        }
-      }
-      return result + "]";
-    }
-
-  };
-
-  template <>
-  std::string Arrays::toString(const std::vector<antlr4::tree::ParseTree *> &source);
-}

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

@@ -1,76 +0,0 @@
-/* Copyright (c) 2012-2017 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 BitSet : public std::bitset<2048> {
-  public:
-    size_t nextSetBit(size_t pos) const {
-      for (size_t i = pos; i < size(); i++){
-        if (test(i)) {
-          return i;
-        }
-      }
-
-      return INVALID_INDEX;
-    }
-
-    // Prints a list of every index for which the bitset contains a bit in true.
-    friend std::wostream& operator << (std::wostream& os, const BitSet& obj)
-    {
-      os << "{";
-      size_t total = obj.count();
-      for (size_t i = 0; i < obj.size(); i++){
-        if (obj.test(i)){
-          os << i;
-          --total;
-          if (total > 1){
-            os << ", ";
-          }
-        }
-      }
-
-      os << "}";
-      return os;
-    }
-
-    static std::string subStringRepresentation(const std::vector<BitSet>::iterator &begin,
-                                                const std::vector<BitSet>::iterator &end) {
-      std::string result;
-      std::vector<BitSet>::iterator vectorIterator;
-
-      for (vectorIterator = begin; vectorIterator != end; vectorIterator++) {
-        result += vectorIterator->toString();
-      }
-      // Grab the end
-      result += end->toString();
-
-      return result;
-    }
-
-    std::string toString(){
-      std::stringstream stream;
-      stream << "{";
-      bool valueAdded = false;
-      for (size_t i = 0; i < size(); ++i){
-        if (test(i)){
-          if (valueAdded) {
-            stream << ", ";
-          }
-          stream << i;
-          valueAdded = true;
-        }
-      }
-
-      stream << "}";
-      return stream.str();
-    }
-
-  };
-}

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

@@ -1,248 +0,0 @@
-/* Copyright (c) 2012-2017 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.
- */
-
-#include "support/CPPUtils.h"
-
-namespace antlrcpp {
-
-  std::string join(std::vector<std::string> strings, const std::string &separator) {
-    std::string str;
-    bool firstItem = true;
-    for (std::string s : strings) {
-      if (!firstItem) {
-        str.append(separator);
-      }
-      firstItem = false;
-      str.append(s);
-    }
-    return str;
-  }
-
-  std::map<std::string, size_t> toMap(const std::vector<std::string> &keys) {
-    std::map<std::string, size_t> result;
-    for (size_t i = 0; i < keys.size(); ++i) {
-      result.insert({ keys[i], i });
-    }
-    return result;
-  }
-
-  std::string escapeWhitespace(std::string str, bool escapeSpaces) {
-    std::string result;
-    for (auto c : str) {
-      switch (c) {
-        case '\n':
-          result += "\\n";
-          break;
-
-        case '\r':
-          result += "\\r";
-          break;
-
-        case '\t':
-          result += "\\t";
-          break;
-
-        case ' ':
-          if (escapeSpaces) {
-            result += "·";
-            break;
-          }
-          // else fall through
-#ifndef _MSC_VER
-#if __has_cpp_attribute(clang::fallthrough)
-          [[clang::fallthrough]];
-#endif
-#endif
-
-        default:
-          result += c;
-      }
-    }
-
-    return result;
-  }
-
-  std::string toHexString(const int t) {
-    std::stringstream stream;
-    stream << std::uppercase << std::hex << t;
-    return stream.str();
-  }
-
-  std::string arrayToString(const std::vector<std::string> &data) {
-    std::string answer;
-    for (auto sub: data) {
-      answer += sub;
-    }
-    return answer;
-  }
-
-  std::string replaceString(const std::string &s, const std::string &from, const std::string &to) {
-    std::string::size_type p;
-    std::string ss, res;
-
-    ss = s;
-    p = ss.find(from);
-    while (p != std::string::npos) {
-      if (p > 0)
-        res.append(ss.substr(0, p)).append(to);
-      else
-        res.append(to);
-      ss = ss.substr(p + from.size());
-      p = ss.find(from);
-    }
-    res.append(ss);
-
-    return res;
-  }
-
-  std::vector<std::string> split(const std::string &s, const std::string &sep, int count) {
-    std::vector<std::string> parts;
-    std::string ss = s;
-
-    std::string::size_type p;
-
-    if (s.empty())
-      return parts;
-
-    if (count == 0)
-      count= -1;
-
-    p = ss.find(sep);
-    while (!ss.empty() && p != std::string::npos && (count < 0 || count > 0)) {
-      parts.push_back(ss.substr(0, p));
-      ss = ss.substr(p+sep.size());
-
-      --count;
-      p = ss.find(sep);
-    }
-    parts.push_back(ss);
-
-    return parts;
-  }
-
-  //--------------------------------------------------------------------------------------------------
-
-  // Debugging helper. Adds indentation to all lines in the given string.
-  std::string indent(const std::string &s, const std::string &indentation, bool includingFirst) {
-    std::vector<std::string> parts = split(s, "\n", -1);
-    for (size_t i = 0; i < parts.size(); ++i) {
-      if (i == 0 && !includingFirst)
-        continue;
-      parts[i].insert(0, indentation);
-    }
-
-    return join(parts, "\n");
-  }
-
-  //--------------------------------------------------------------------------------------------------
-
-  // Recursively get the error from a, possibly nested, exception.
-#if defined(_MSC_FULL_VER) && _MSC_FULL_VER < 190023026
-  // No nested exceptions before VS 2015.
-  template <typename T>
-  std::exception_ptr get_nested(const T &/*e*/) {
-    try {
-      return nullptr;
-    }
-    catch (const std::bad_cast &) {
-      return nullptr;
-    }
-  }
-#else
-  template <typename T>
-  std::exception_ptr get_nested(const T &e) {
-    try {
-      auto nested = dynamic_cast<const std::nested_exception&>(e);
-      return nested.nested_ptr();
-    }
-    catch (const std::bad_cast &) {
-      return nullptr;
-    }
-  }
-#endif
-
-  std::string what(std::exception_ptr eptr) {
-    if (!eptr) {
-      throw std::bad_exception();
-    }
-
-    std::string result;
-    std::size_t nestCount = 0;
-
-    next: {
-      try {
-        std::exception_ptr yeptr;
-        std::swap(eptr, yeptr);
-        std::rethrow_exception(yeptr);
-      }
-      catch (const std::exception &e) {
-        result += e.what();
-        eptr = get_nested(e);
-      }
-      catch (const std::string &e) {
-        result += e;
-      }
-      catch (const char *e) {
-        result += e;
-      }
-      catch (...) {
-        result += "cannot be determined";
-      }
-
-      if (eptr) {
-        result += " (";
-        ++nestCount;
-        goto next;
-      }
-    }
-
-    result += std::string(nestCount, ')');
-    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