expressir 0.2.0 → 0.2.5

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

@@ -0,0 +1,170 @@
+/* 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

@@ -0,0 +1,43 @@
+/* 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

@@ -0,0 +1,110 @@
+/* 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

@@ -0,0 +1,76 @@
+/* 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

@@ -0,0 +1,248 @@
+/* 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