expressir 0.2.5-x64-mingw32 → 0.2.7-x64-mingw32

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

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

@@ -1,78 +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 {
-
-  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);
-
-  // Using RAII + a lambda to implement a "finally" replacement.
-  struct FinalAction {
-    FinalAction(std::function<void ()> f) : _cleanUp { f } {}
-    FinalAction(FinalAction &&other) :
-	_cleanUp(std::move(other._cleanUp)), _enabled(other._enabled) {
-      other._enabled = false; // Don't trigger the lambda after ownership has moved.
-    }
-    ~FinalAction() { if (_enabled) _cleanUp(); }
-
-    void disable() { _enabled = false; }
-  private:
-    std::function<void ()> _cleanUp;
-    bool _enabled {true};
-  };
-
-  ANTLR4CPP_PUBLIC FinalAction finally(std::function<void ()> f);
-
-  // Convenience functions to avoid lengthy dynamic_cast() != nullptr checks in many places.
-  template <typename T1, typename T2>
-  inline bool is(T2 *obj) { // For pointer types.
-    return dynamic_cast<typename std::add_const<T1>::type>(obj) != nullptr;
-  }
-
-  template <typename T1, typename T2>
-  inline bool is(Ref<T2> const& obj) { // For shared pointers.
-    return dynamic_cast<T1 *>(obj.get()) != nullptr;
-  }
-
-  template <typename T>
-  std::string toString(const T &o) {
-    std::stringstream ss;
-    // typeid gives the mangled class name, but that's all what's possible
-    // in a portable way.
-    ss << typeid(o).name() << "@" << std::hex << reinterpret_cast<uintptr_t>(&o);
-    return ss.str();
-  }
-
-  // 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;
-  };
-
-} // namespace antlrcpp

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

@@ -1,163 +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
-
-namespace antlr4 {
-  class ANTLRErrorListener;
-  class ANTLRErrorStrategy;
-  class ANTLRFileStream;
-  class ANTLRInputStream;
-  class BailErrorStrategy;
-  class BaseErrorListener;
-  class BufferedTokenStream;
-  class CharStream;
-  class CommonToken;
-  class CommonTokenFactory;
-  class CommonTokenStream;
-  class ConsoleErrorListener;
-  class DefaultErrorStrategy;
-  class DiagnosticErrorListener;
-  class EmptyStackException;
-  class FailedPredicateException;
-  class IllegalArgumentException;
-  class IllegalStateException;
-  class InputMismatchException;
-  class IntStream;
-  class InterpreterRuleContext;
-  class Lexer;
-  class LexerInterpreter;
-  class LexerNoViableAltException;
-  class ListTokenSource;
-  class NoSuchElementException;
-  class NoViableAltException;
-  class NullPointerException;
-  class ParseCancellationException;
-  class Parser;
-  class ParserInterpreter;
-  class ParserRuleContext;
-  class ProxyErrorListener;
-  class RecognitionException;
-  class Recognizer;
-  class RuleContext;
-  class Token;
-  template<typename Symbol> class TokenFactory;
-  class TokenSource;
-  class TokenStream;
-  class TokenStreamRewriter;
-  class UnbufferedCharStream;
-  class UnbufferedTokenStream;
-  class WritableToken;
-
-  namespace misc {
-    class InterpreterDataReader;
-    class Interval;
-    class IntervalSet;
-    class MurmurHash;
-    class Utils;
-    class Predicate;
-  }
-  namespace atn {
-    class ATN;
-    class ATNConfig;
-    class ATNConfigSet;
-    class ATNDeserializationOptions;
-    class ATNDeserializer;
-    class ATNSerializer;
-    class ATNSimulator;
-    class ATNState;
-    enum class ATNType;
-    class AbstractPredicateTransition;
-    class ActionTransition;
-    class ArrayPredictionContext;
-    class AtomTransition;
-    class BasicBlockStartState;
-    class BasicState;
-    class BlockEndState;
-    class BlockStartState;
-    class DecisionState;
-    class EmptyPredictionContext;
-    class EpsilonTransition;
-    class LL1Analyzer;
-    class LexerAction;
-    class LexerActionExecutor;
-    class LexerATNConfig;
-    class LexerATNSimulator;
-    class LexerMoreAction;
-    class LexerPopModeAction;
-    class LexerSkipAction;
-    class LookaheadEventInfo;
-    class LoopEndState;
-    class NotSetTransition;
-    class OrderedATNConfigSet;
-    class ParseInfo;
-    class ParserATNSimulator;
-    class PlusBlockStartState;
-    class PlusLoopbackState;
-    class PrecedencePredicateTransition;
-    class PredicateTransition;
-    class PredictionContext;
-    enum class PredictionMode;
-    class PredictionModeClass;
-    class RangeTransition;
-    class RuleStartState;
-    class RuleStopState;
-    class RuleTransition;
-    class SemanticContext;
-    class SetTransition;
-    class SingletonPredictionContext;
-    class StarBlockStartState;
-    class StarLoopEntryState;
-    class StarLoopbackState;
-    class TokensStartState;
-    class Transition;
-    class WildcardTransition;
-  }
-  namespace dfa {
-    class DFA;
-    class DFASerializer;
-    class DFAState;
-    class LexerDFASerializer;
-    class Vocabulary;
-  }
-  namespace tree {
-    class AbstractParseTreeVisitor;
-    class ErrorNode;
-    class ErrorNodeImpl;
-    class ParseTree;
-    class ParseTreeListener;
-    template<typename T> class ParseTreeProperty;
-    class ParseTreeVisitor;
-    class ParseTreeWalker;
-    class SyntaxTree;
-    class TerminalNode;
-    class TerminalNodeImpl;
-    class Tree;
-    class Trees;
-
-    namespace pattern {
-      class Chunk;
-      class ParseTreeMatch;
-      class ParseTreePattern;
-      class ParseTreePatternMatcher;
-      class RuleTagToken;
-      class TagChunk;
-      class TextChunk;
-      class TokenTagToken;
-    }
-
-    namespace xpath {
-      class XPath;
-      class XPathElement;
-      class XPathLexerErrorListener;
-      class XPathRuleAnywhereElement;
-      class XPathRuleElement;
-      class XPathTokenAnywhereElement;
-      class XPathTokenElement;
-      class XPathWildcardAnywhereElement;
-      class XPathWildcardElement;
-    }
-  }
-}

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

@@ -1,36 +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/StringUtils.h"
-
-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 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;
-}
-
-} // namespace antrlcpp

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

@@ -1,54 +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 {
-
-  // 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;
-
-    #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
-  }
-
-  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);
-}