expressir 0.2.4-x64-mingw32

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

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

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

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

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

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