expressir 0.2.5-x64-mingw32 → 0.2.11-x64-mingw32

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

@@ -1,104 +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 "Token.h"
-
-#include "Vocabulary.h"
-
-using namespace antlr4::dfa;
-
-const Vocabulary Vocabulary::EMPTY_VOCABULARY;
-
-Vocabulary::Vocabulary(const std::vector<std::string> &literalNames, const std::vector<std::string> &symbolicNames)
-: Vocabulary(literalNames, symbolicNames, {}) {
-}
-
-Vocabulary::Vocabulary(const std::vector<std::string> &literalNames,
-  const std::vector<std::string> &symbolicNames, const std::vector<std::string> &displayNames)
-  : _literalNames(literalNames), _symbolicNames(symbolicNames), _displayNames(displayNames),
-    _maxTokenType(std::max(_displayNames.size(), std::max(_literalNames.size(), _symbolicNames.size())) - 1) {
-  // See note here on -1 part: https://github.com/antlr/antlr4/pull/1146
-}
-
-Vocabulary::~Vocabulary() {
-}
-
-Vocabulary Vocabulary::fromTokenNames(const std::vector<std::string> &tokenNames) {
-  if (tokenNames.empty()) {
-    return EMPTY_VOCABULARY;
-  }
-
-  std::vector<std::string> literalNames = tokenNames;
-  std::vector<std::string> symbolicNames = tokenNames;
-  std::locale locale;
-  for (size_t i = 0; i < tokenNames.size(); i++) {
-    std::string tokenName = tokenNames[i];
-    if (tokenName == "") {
-      continue;
-    }
-
-    if (!tokenName.empty()) {
-      char firstChar = tokenName[0];
-      if (firstChar == '\'') {
-        symbolicNames[i] = "";
-        continue;
-      } else if (std::isupper(firstChar, locale)) {
-        literalNames[i] = "";
-        continue;
-      }
-    }
-
-    // wasn't a literal or symbolic name
-    literalNames[i] = "";
-    symbolicNames[i] = "";
-  }
-
-  return Vocabulary(literalNames, symbolicNames, tokenNames);
-}
-
-size_t Vocabulary::getMaxTokenType() const {
-  return _maxTokenType;
-}
-
-std::string Vocabulary::getLiteralName(size_t tokenType) const {
-  if (tokenType < _literalNames.size()) {
-    return _literalNames[tokenType];
-  }
-
-  return "";
-}
-
-std::string Vocabulary::getSymbolicName(size_t tokenType) const {
-  if (tokenType == Token::EOF) {
-    return "EOF";
-  }
-
-  if (tokenType < _symbolicNames.size()) {
-    return _symbolicNames[tokenType];
-  }
-
-  return "";
-}
-
-std::string Vocabulary::getDisplayName(size_t tokenType) const {
-  if (tokenType < _displayNames.size()) {
-    std::string displayName = _displayNames[tokenType];
-    if (!displayName.empty()) {
-      return displayName;
-    }
-  }
-
-  std::string literalName = getLiteralName(tokenType);
-  if (!literalName.empty()) {
-    return literalName;
-  }
-
-  std::string symbolicName = getSymbolicName(tokenType);
-  if (!symbolicName.empty()) {
-    return symbolicName;
-  }
-
-  return std::to_string(tokenType);
-}

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

@@ -1,193 +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 antlr4 {
-namespace dfa {
-
-  /// This class provides a default implementation of the <seealso cref="Vocabulary"/>
-  /// interface.
-  class ANTLR4CPP_PUBLIC Vocabulary {
-  public:
-    Vocabulary(Vocabulary const&) = default;
-    virtual ~Vocabulary();
-
-    /// Gets an empty <seealso cref="Vocabulary"/> instance.
-    ///
-    /// <para>
-    /// No literal or symbol names are assigned to token types, so
-    /// <seealso cref="#getDisplayName(int)"/> returns the numeric value for all tokens
-    /// except <seealso cref="Token#EOF"/>.</para>
-    static const Vocabulary EMPTY_VOCABULARY;
-
-    Vocabulary() {}
-
-    /// <summary>
-    /// Constructs a new instance of <seealso cref="Vocabulary"/> from the specified
-    /// literal and symbolic token names.
-    /// </summary>
-    /// <param name="literalNames"> The literal names assigned to tokens, or {@code null}
-    /// if no literal names are assigned. </param>
-    /// <param name="symbolicNames"> The symbolic names assigned to tokens, or
-    /// {@code null} if no symbolic names are assigned.
-    /// </param>
-    /// <seealso cref= #getLiteralName(int) </seealso>
-    /// <seealso cref= #getSymbolicName(int) </seealso>
-    Vocabulary(const std::vector<std::string> &literalNames, const std::vector<std::string> &symbolicNames);
-
-    /// <summary>
-    /// Constructs a new instance of <seealso cref="Vocabulary"/> from the specified
-    /// literal, symbolic, and display token names.
-    /// </summary>
-    /// <param name="literalNames"> The literal names assigned to tokens, or {@code null}
-    /// if no literal names are assigned. </param>
-    /// <param name="symbolicNames"> The symbolic names assigned to tokens, or
-    /// {@code null} if no symbolic names are assigned. </param>
-    /// <param name="displayNames"> The display names assigned to tokens, or {@code null}
-    /// to use the values in {@code literalNames} and {@code symbolicNames} as
-    /// the source of display names, as described in
-    /// <seealso cref="#getDisplayName(int)"/>.
-    /// </param>
-    /// <seealso cref= #getLiteralName(int) </seealso>
-    /// <seealso cref= #getSymbolicName(int) </seealso>
-    /// <seealso cref= #getDisplayName(int) </seealso>
-    Vocabulary(const std::vector<std::string> &literalNames, const std::vector<std::string> &symbolicNames,
-                   const std::vector<std::string> &displayNames);
-
-    /// <summary>
-    /// Returns a <seealso cref="Vocabulary"/> instance from the specified set of token
-    /// names. This method acts as a compatibility layer for the single
-    /// {@code tokenNames} array generated by previous releases of ANTLR.
-    ///
-    /// <para>The resulting vocabulary instance returns {@code null} for
-    /// <seealso cref="#getLiteralName(int)"/> and <seealso cref="#getSymbolicName(int)"/>, and the
-    /// value from {@code tokenNames} for the display names.</para>
-    /// </summary>
-    /// <param name="tokenNames"> The token names, or {@code null} if no token names are
-    /// available. </param>
-    /// <returns> A <seealso cref="Vocabulary"/> instance which uses {@code tokenNames} for
-    /// the display names of tokens. </returns>
-    static Vocabulary fromTokenNames(const std::vector<std::string> &tokenNames);
-
-    /// <summary>
-    /// Returns the highest token type value. It can be used to iterate from
-    /// zero to that number, inclusively, thus querying all stored entries. </summary>
-    /// <returns> the highest token type value </returns>
-    virtual size_t getMaxTokenType() const;
-
-    /// <summary>
-    /// Gets the string literal associated with a token type. The string returned
-    /// by this method, when not {@code null}, can be used unaltered in a parser
-    /// grammar to represent this token type.
-    ///
-    /// <para>The following table shows examples of lexer rules and the literal
-    /// names assigned to the corresponding token types.</para>
-    ///
-    /// <table>
-    ///  <tr>
-    ///   <th>Rule</th>
-    ///   <th>Literal Name</th>
-    ///   <th>Java String Literal</th>
-    ///  </tr>
-    ///  <tr>
-    ///   <td>{@code THIS : 'this';}</td>
-    ///   <td>{@code 'this'}</td>
-    ///   <td>{@code "'this'"}</td>
-    ///  </tr>
-    ///  <tr>
-    ///   <td>{@code SQUOTE : '\'';}</td>
-    ///   <td>{@code '\''}</td>
-    ///   <td>{@code "'\\''"}</td>
-    ///  </tr>
-    ///  <tr>
-    ///   <td>{@code ID : [A-Z]+;}</td>
-    ///   <td>n/a</td>
-    ///   <td>{@code null}</td>
-    ///  </tr>
-    /// </table>
-    /// </summary>
-    /// <param name="tokenType"> The token type.
-    /// </param>
-    /// <returns> The string literal associated with the specified token type, or
-    /// {@code null} if no string literal is associated with the type. </returns>
-    virtual std::string getLiteralName(size_t tokenType) const;
-
-    /// <summary>
-    /// Gets the symbolic name associated with a token type. The string returned
-    /// by this method, when not {@code null}, can be used unaltered in a parser
-    /// grammar to represent this token type.
-    ///
-    /// <para>This method supports token types defined by any of the following
-    /// methods:</para>
-    ///
-    /// <ul>
-    ///  <li>Tokens created by lexer rules.</li>
-    ///  <li>Tokens defined in a <code>tokens{}</code> block in a lexer or parser
-    ///  grammar.</li>
-    ///  <li>The implicitly defined {@code EOF} token, which has the token type
-    ///  <seealso cref="Token#EOF"/>.</li>
-    /// </ul>
-    ///
-    /// <para>The following table shows examples of lexer rules and the literal
-    /// names assigned to the corresponding token types.</para>
-    ///
-    /// <table>
-    ///  <tr>
-    ///   <th>Rule</th>
-    ///   <th>Symbolic Name</th>
-    ///  </tr>
-    ///  <tr>
-    ///   <td>{@code THIS : 'this';}</td>
-    ///   <td>{@code THIS}</td>
-    ///  </tr>
-    ///  <tr>
-    ///   <td>{@code SQUOTE : '\'';}</td>
-    ///   <td>{@code SQUOTE}</td>
-    ///  </tr>
-    ///  <tr>
-    ///   <td>{@code ID : [A-Z]+;}</td>
-    ///   <td>{@code ID}</td>
-    ///  </tr>
-    /// </table>
-    /// </summary>
-    /// <param name="tokenType"> The token type.
-    /// </param>
-    /// <returns> The symbolic name associated with the specified token type, or
-    /// {@code null} if no symbolic name is associated with the type. </returns>
-    virtual std::string getSymbolicName(size_t tokenType) const;
-
-    /// <summary>
-    /// Gets the display name of a token type.
-    ///
-    /// <para>ANTLR provides a default implementation of this method, but
-    /// applications are free to override the behavior in any manner which makes
-    /// sense for the application. The default implementation returns the first
-    /// result from the following list which produces a non-{@code null}
-    /// result.</para>
-    ///
-    /// <ol>
-    ///  <li>The result of <seealso cref="#getLiteralName"/></li>
-    ///  <li>The result of <seealso cref="#getSymbolicName"/></li>
-    ///  <li>The result of <seealso cref="Integer#toString"/></li>
-    /// </ol>
-    /// </summary>
-    /// <param name="tokenType"> The token type.
-    /// </param>
-    /// <returns> The display name of the token type, for use in error reporting or
-    /// other user-visible messages which reference specific token types. </returns>
-    virtual std::string getDisplayName(size_t tokenType) const;
-
-  private:
-    std::vector<std::string> const _literalNames;
-    std::vector<std::string> const _symbolicNames;
-    std::vector<std::string> const _displayNames;
-    const size_t _maxTokenType = 0;
-  };
-
-} // namespace atn
-} // namespace antlr4

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

@@ -1,9 +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 "WritableToken.h"
-
-antlr4::WritableToken::~WritableToken() {
-}

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

@@ -1,23 +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 "Token.h"
-
-namespace antlr4 {
-
-  class ANTLR4CPP_PUBLIC WritableToken : public Token {
-  public:
-    virtual ~WritableToken();
-    virtual void setText(const std::string &text) = 0;
-    virtual void setType(size_t ttype) = 0;
-    virtual void setLine(size_t line) = 0;
-    virtual void setCharPositionInLine(size_t pos) = 0;
-    virtual void setChannel(size_t channel) = 0;
-    virtual void setTokenIndex(size_t index) = 0;
-  };
-
-} // namespace antlr4

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

@@ -1,137 +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 <algorithm>
-#include <assert.h>
-#include <atomic>
-#include <codecvt>
-#include <chrono>
-#include <fstream>
-#include <iostream>
-#include <iterator>
-#include <limits>
-#include <limits.h>
-#include <list>
-#include <map>
-#include <memory>
-#include <set>
-#include <stdarg.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <sstream>
-#include <stack>
-#include <string>
-#include <typeinfo>
-#include <type_traits>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-#include <mutex>
-#include <exception>
-#include <bitset>
-#include <condition_variable>
-#include <functional>
-
-// Defines for the Guid class and other platform dependent stuff.
-#ifdef _WIN32
-  #ifdef _MSC_VER
-    #pragma warning (disable: 4250) // Class inherits by dominance.
-    #pragma warning (disable: 4512) // assignment operator could not be generated
-
-    #if _MSC_VER < 1900
-      // Before VS 2015 code like "while (true)" will create a (useless) warning in level 4.
-      #pragma warning (disable: 4127) // conditional expression is constant
-    #endif
-  #endif
-
-  #define GUID_WINDOWS
-
-  #ifdef _WIN64
-    typedef __int64 ssize_t;
-  #else
-    typedef __int32 ssize_t;
-  #endif
-
-  #if _MSC_VER >= 1900 && _MSC_VER < 2000
-    // VS 2015 has a known bug when using std::codecvt_utf8<char32_t>
-    // so we have to temporarily use __int32 instead.
-    // https://connect.microsoft.com/VisualStudio/feedback/details/1403302/unresolved-external-when-using-codecvt-utf8
-    typedef std::basic_string<__int32> i32string;
-
-    typedef i32string UTF32String;
-  #else
-    typedef std::u32string UTF32String;
-  #endif
-
-  #ifdef ANTLR4CPP_EXPORTS
-    #define ANTLR4CPP_PUBLIC __declspec(dllexport)
-  #else
-    #ifdef ANTLR4CPP_STATIC
-      #define ANTLR4CPP_PUBLIC
-    #else
-      #define ANTLR4CPP_PUBLIC __declspec(dllimport)
-    #endif
-  #endif
-
-  #if defined(_MSC_VER) && !defined(__clang__)
-    // clang-cl should escape this to prevent [ignored-attributes].
-    namespace std {
-      class ANTLR4CPP_PUBLIC exception; // Prevents warning C4275 from MSVC.
-    } // namespace std
-  #endif
-
-#elif defined(__APPLE__)
-  typedef std::u32string UTF32String;
-
-  #define GUID_CFUUID
-  #if __GNUC__ >= 4
-    #define ANTLR4CPP_PUBLIC __attribute__ ((visibility ("default")))
-  #else
-    #define ANTLR4CPP_PUBLIC
-  #endif
-#else
-  typedef std::u32string UTF32String;
-
-  #define GUID_LIBUUID
-  #if __GNUC__ >= 6
-    #define ANTLR4CPP_PUBLIC __attribute__ ((visibility ("default")))
-  #else
-    #define ANTLR4CPP_PUBLIC
-  #endif
-#endif
-
-#include "support/guid.h"
-#include "support/Declarations.h"
-
-#if !defined(HAS_NOEXCEPT)
-  #if defined(__clang__)
-    #if __has_feature(cxx_noexcept)
-      #define HAS_NOEXCEPT
-    #endif
-  #else
-    #if defined(__GXX_EXPERIMENTAL_CXX0X__) && __GNUC__ * 10 + __GNUC_MINOR__ >= 46 || \
-      defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023026
-      #define HAS_NOEXCEPT
-    #endif
-  #endif
-
-  #ifdef HAS_NOEXCEPT
-    #define NOEXCEPT noexcept
-  #else
-    #define NOEXCEPT
-  #endif
-#endif
-
-// We have to undefine this symbol as ANTLR will use this name for own members and even
-// generated functions. Because EOF is a global macro we cannot use e.g. a namespace scope to disambiguate.
-#ifdef EOF
-#undef EOF
-#endif
-
-#define INVALID_INDEX std::numeric_limits<size_t>::max()
-template<class T> using Ref = std::shared_ptr<T>;