expressir 1.2.3 → 1.2.6

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

@@ -4,10 +4,11 @@
  */
 
 #include "RuntimeMetaData.h"
+#include "Version.h"
 
 using namespace antlr4;
 
-const std::string RuntimeMetaData::VERSION = "4.8";
+const std::string RuntimeMetaData::VERSION = ANTLRCPP_VERSION_STRING;
 
 std::string RuntimeMetaData::getRuntimeVersion() {
   return VERSION;

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

@@ -14,24 +14,24 @@ namespace antlr4 {
   /// we obtained this token.
   class ANTLR4CPP_PUBLIC Token {
   public:
-    static const size_t INVALID_TYPE = 0;
+    static constexpr size_t INVALID_TYPE = 0;
 
     /// During lookahead operations, this "token" signifies we hit rule end ATN state
     /// and did not follow it despite needing to.
-    static const size_t EPSILON = static_cast<size_t>(-2);
-    static const size_t MIN_USER_TOKEN_TYPE = 1;
-    static const size_t EOF = IntStream::EOF;
+    static constexpr size_t EPSILON = std::numeric_limits<size_t>::max() - 1;
+    static constexpr size_t MIN_USER_TOKEN_TYPE = 1;
+    static constexpr size_t EOF = IntStream::EOF;
 
     virtual ~Token();
 
     /// All tokens go to the parser (unless skip() is called in that rule)
     /// on a particular "channel".  The parser tunes to a particular channel
     /// so that whitespace etc... can go to the parser on a "hidden" channel.
-    static const size_t DEFAULT_CHANNEL = 0;
+    static constexpr size_t DEFAULT_CHANNEL = 0;
 
     /// Anything on different channel than DEFAULT_CHANNEL is not parsed
     /// by parser.
-    static const size_t HIDDEN_CHANNEL = 1;
+    static constexpr size_t HIDDEN_CHANNEL = 1;
 
     /**
      * This is the minimum constant value which can be assigned to a
@@ -44,7 +44,7 @@ namespace antlr4 {
      *
      * @see Token#getChannel()
      */
-    static const size_t MIN_USER_CHANNEL_VALUE = 2;
+    static constexpr size_t MIN_USER_CHANNEL_VALUE = 2;
 
     /// Get the text of the token.
     virtual std::string getText() const = 0;

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

@@ -79,7 +79,7 @@ namespace antlr4 {
     /// creating <seealso cref="Token"/> objects from the input.
     /// </summary>
     /// <returns> The <seealso cref="TokenFactory"/> currently used by this token source. </returns>
-    virtual Ref<TokenFactory<CommonToken>> getTokenFactory() = 0;
+    virtual TokenFactory<CommonToken>* getTokenFactory() = 0;
   };
 
 } // namespace antlr4

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

@@ -93,8 +93,8 @@ TokenStreamRewriter::TokenStreamRewriter(TokenStream *tokens_) : tokens(tokens_)
 }
 
 TokenStreamRewriter::~TokenStreamRewriter() {
-  for (auto program : _programs) {
-    for (auto operation : program.second) {
+  for (const auto &program : _programs) {
+    for (auto *operation : program.second) {
       delete operation;
     }
   }
@@ -323,7 +323,7 @@ std::unordered_map<size_t, TokenStreamRewriter::RewriteOperation*> TokenStreamRe
 
     // Wipe prior inserts within range
     std::vector<InsertBeforeOp *> inserts = getKindOfOps<InsertBeforeOp>(rewrites, i);
-    for (auto iop : inserts) {
+    for (auto *iop : inserts) {
       if (iop->index == rop->index) {
         // E.g., insert before 2, delete 2..2; update replace
         // text to include insert before, kill insert
@@ -339,7 +339,7 @@ std::unordered_map<size_t, TokenStreamRewriter::RewriteOperation*> TokenStreamRe
     }
     // Drop any prior replaces contained within
     std::vector<ReplaceOp*> prevReplaces = getKindOfOps<ReplaceOp>(rewrites, i);
-    for (auto prevRop : prevReplaces) {
+    for (auto *prevRop : prevReplaces) {
       if (prevRop->index >= rop->index && prevRop->lastIndex <= rop->lastIndex) {
         // delete replace as it's a no-op.
         delete rewrites[prevRop->instructionIndex];
@@ -373,7 +373,7 @@ std::unordered_map<size_t, TokenStreamRewriter::RewriteOperation*> TokenStreamRe
     // combine current insert with prior if any at same index
 
     std::vector<InsertBeforeOp *> prevInserts = getKindOfOps<InsertBeforeOp>(rewrites, i);
-    for (auto prevIop : prevInserts) {
+    for (auto *prevIop : prevInserts) {
       if (prevIop->index == iop->index) { // combine objects
                                           // convert to strings...we're in process of toString'ing
                                           // whole token buffer so no lazy eval issue with any templates
@@ -385,7 +385,7 @@ std::unordered_map<size_t, TokenStreamRewriter::RewriteOperation*> TokenStreamRe
     }
     // look for replaces where iop.index is in range; error
     std::vector<ReplaceOp*> prevReplaces = getKindOfOps<ReplaceOp>(rewrites, i);
-    for (auto rop : prevReplaces) {
+    for (auto *rop : prevReplaces) {
       if (iop->index == rop->index) {
         rop->text = catOpText(&iop->text, &rop->text);
         delete rewrites[i];

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

@@ -5,6 +5,8 @@
 
 #pragma once
 
+#include "antlr4-common.h"
+
 namespace antlr4 {
 
   /**
@@ -86,8 +88,8 @@ namespace antlr4 {
   class ANTLR4CPP_PUBLIC TokenStreamRewriter {
   public:
     static const std::string DEFAULT_PROGRAM_NAME;
-    static const size_t PROGRAM_INIT_SIZE = 100;
-    static const size_t MIN_TOKEN_INDEX = 0;
+    static constexpr size_t PROGRAM_INIT_SIZE = 100;
+    static constexpr size_t MIN_TOKEN_INDEX = 0;
 
     TokenStreamRewriter(TokenStream *tokens);
     virtual ~TokenStreamRewriter();

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

@@ -5,7 +5,7 @@
 
 #include "misc/Interval.h"
 #include "Exceptions.h"
-#include "support/StringUtils.h"
+#include "support/Utf8.h"
 
 #include "UnbufferedCharStream.h"
 
@@ -13,9 +13,8 @@ using namespace antlrcpp;
 using namespace antlr4;
 using namespace antlr4::misc;
 
-UnbufferedCharStream::UnbufferedCharStream(std::wistream &input) : _input(input) {
-  InitializeInstanceFields();
-
+UnbufferedCharStream::UnbufferedCharStream(std::wistream &input)
+    : _p(0), _numMarkers(0), _lastChar(0), _lastCharBufferStart(0), _currentCharIndex(0), _input(input) {
   // The vector's size is what used to be n in Java code.
   fill(1); // prime
 }
@@ -74,9 +73,7 @@ size_t UnbufferedCharStream::fill(size_t n) {
 }
 
 char32_t UnbufferedCharStream::nextChar()  {
-  wchar_t result = 0;
-  _input >> result;
-  return result;
+  return _input.get();
 }
 
 void UnbufferedCharStream::add(char32_t c) {
@@ -101,7 +98,7 @@ size_t UnbufferedCharStream::LA(ssize_t i) {
     return EOF;
   }
 
-  if (_data[static_cast<size_t>(index)] == 0xFFFF) {
+  if (_data[static_cast<size_t>(index)] == std::char_traits<wchar_t>::eof()) {
     return EOF;
   }
 
@@ -178,7 +175,7 @@ std::string UnbufferedCharStream::getSourceName() const {
 }
 
 std::string UnbufferedCharStream::getText(const misc::Interval &interval) {
-  if (interval.a < 0 || interval.b >= interval.a - 1) {
+  if (interval.a < 0 || interval.b < interval.a - 1) {
     throw IllegalArgumentException("invalid interval");
   }
 
@@ -195,17 +192,17 @@ std::string UnbufferedCharStream::getText(const misc::Interval &interval) {
   }
   // convert from absolute to local index
   size_t i = interval.a - bufferStartIndex;
-  return utf32_to_utf8(_data.substr(i, interval.length()));
+  auto maybeUtf8 = Utf8::strictEncode(std::u32string_view(_data).substr(i, interval.length()));
+  if (!maybeUtf8.has_value()) {
+    throw IllegalArgumentException("Unbuffered stream contains invalid Unicode code points");
+  }
+  return std::move(maybeUtf8).value();
 }
 
-size_t UnbufferedCharStream::getBufferStartIndex() const {
-  return _currentCharIndex - _p;
+std::string UnbufferedCharStream::toString() const {
+  throw UnsupportedOperationException("Unbuffered stream cannot be materialized to a string");
 }
 
-void UnbufferedCharStream::InitializeInstanceFields() {
-  _p = 0;
-  _numMarkers = 0;
-  _lastChar = 0;
-  _lastCharBufferStart = 0;
-  _currentCharIndex = 0;
+size_t UnbufferedCharStream::getBufferStartIndex() const {
+  return _currentCharIndex - _p;
 }

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

@@ -18,10 +18,10 @@ namespace antlr4 {
     /// The name or source of this char stream.
     std::string name;
 
-    UnbufferedCharStream(std::wistream &input);
+    explicit UnbufferedCharStream(std::wistream &input);
 
-    virtual void consume() override;
-    virtual size_t LA(ssize_t i) override;
+    void consume() override;
+    size_t LA(ssize_t i) override;
 
     /// <summary>
     /// Return a marker that we can release later.
@@ -30,35 +30,32 @@ namespace antlr4 {
     /// protection against misuse where {@code seek()} is called on a mark or
     /// {@code release()} is called in the wrong order.
     /// </summary>
-    virtual ssize_t mark() override;
+    ssize_t mark() override;
 
     /// <summary>
     /// Decrement number of markers, resetting buffer if we hit 0. </summary>
     /// <param name="marker"> </param>
-    virtual void release(ssize_t marker) override;
-    virtual size_t index() override;
+    void release(ssize_t marker) override;
+    size_t index() override;
 
     /// <summary>
     /// Seek to absolute character index, which might not be in the current
     ///  sliding window.  Move {@code p} to {@code index-bufferStartIndex}.
     /// </summary>
-    virtual void seek(size_t index) override;
-    virtual size_t size() override;
-    virtual std::string getSourceName() const override;
-    virtual std::string getText(const misc::Interval &interval) override;
+    void seek(size_t index) override;
+    size_t size() override;
+    std::string getSourceName() const override;
+    std::string getText(const misc::Interval &interval) override;
+
+    std::string toString() const override;
 
   protected:
     /// A moving window buffer of the data being scanned. While there's a marker,
     /// we keep adding to buffer. Otherwise, <seealso cref="#consume consume()"/> resets so
     /// we start filling at index 0 again.
     // UTF-32 encoded.
-#if defined(_MSC_VER) && _MSC_VER == 1900
-    i32string _data; // Custom type for VS 2015.
-    typedef __int32 storage_type;
-#else
     std::u32string _data;
     typedef char32_t storage_type;
-#endif
 
     /// <summary>
     /// 0..n-1 index into <seealso cref="#data data"/> of next character.
@@ -115,9 +112,6 @@ namespace antlr4 {
     virtual char32_t nextChar();
     virtual void add(char32_t c);
     size_t getBufferStartIndex() const;
-
-  private:
-    void InitializeInstanceFields();
   };
 
 } // namespace antlr4

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

@@ -0,0 +1,42 @@
+// Copyright 2012-2022 The ANTLR Project
+//
+// Redistribution and use in source and binary forms, with or without modification, are permitted
+// provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of conditions
+//    and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list of
+//    conditions and the following disclaimer in the documentation and/or other materials provided
+//    with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be used to
+//    endorse or promote products derived from this software without specific prior written
+//    permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+// WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include "antlr4-common.h"
+
+#define ANTLRCPP_VERSION_MAJOR 4
+#define ANTLRCPP_VERSION_MINOR 10
+#define ANTLRCPP_VERSION_PATCH 1
+
+#define ANTLRCPP_MAKE_VERSION(major, minor, patch) ((major) * 100000 + (minor) * 1000 + (patch))
+
+#define ANTLRCPP_VERSION \
+  ANTLRCPP_MAKE_VERSION(ANTLR4CPP_VERSION_MAJOR, ANTLR4CPP_VERSION_MINOR, ANTLR4CPP_VERSION_PATCH)
+
+#define ANTLRCPP_VERSION_STRING \
+  ANTLR4CPP_STRINGIFY(ANTLR4CPP_VERSION_MAJOR) "." \
+  ANTLR4CPP_STRINGIFY(ANTLR4CPP_VERSION_MINOR) "." \
+  ANTLR4CPP_STRINGIFY(ANTLR4CPP_VERSION_PATCH)

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

@@ -11,58 +11,18 @@ 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(std::vector<std::string> literalNames, std::vector<std::string> symbolicNames)
+: Vocabulary(std::move(literalNames), std::move(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),
+Vocabulary::Vocabulary(std::vector<std::string> literalNames,
+  std::vector<std::string> symbolicNames, std::vector<std::string> displayNames)
+  : _literalNames(std::move(literalNames)), _symbolicNames(std::move(symbolicNames)), _displayNames(std::move(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 {
+std::string_view Vocabulary::getLiteralName(size_t tokenType) const {
   if (tokenType < _literalNames.size()) {
     return _literalNames[tokenType];
   }
@@ -70,7 +30,7 @@ std::string Vocabulary::getLiteralName(size_t tokenType) const {
   return "";
 }
 
-std::string Vocabulary::getSymbolicName(size_t tokenType) const {
+std::string_view Vocabulary::getSymbolicName(size_t tokenType) const {
   if (tokenType == Token::EOF) {
     return "EOF";
   }
@@ -84,20 +44,20 @@ std::string Vocabulary::getSymbolicName(size_t tokenType) const {
 
 std::string Vocabulary::getDisplayName(size_t tokenType) const {
   if (tokenType < _displayNames.size()) {
-    std::string displayName = _displayNames[tokenType];
+    std::string_view displayName = _displayNames[tokenType];
     if (!displayName.empty()) {
-      return displayName;
+      return std::string(displayName);
     }
   }
 
-  std::string literalName = getLiteralName(tokenType);
+  std::string_view literalName = getLiteralName(tokenType);
   if (!literalName.empty()) {
-    return literalName;
+    return std::string(literalName);
   }
 
-  std::string symbolicName = getSymbolicName(tokenType);
+  std::string_view symbolicName = getSymbolicName(tokenType);
   if (!symbolicName.empty()) {
-    return symbolicName;
+    return std::string(symbolicName);
   }
 
   return std::to_string(tokenType);

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

@@ -12,21 +12,20 @@ namespace dfa {
 
   /// This class provides a default implementation of the <seealso cref="Vocabulary"/>
   /// interface.
-  class ANTLR4CPP_PUBLIC Vocabulary {
+  class ANTLR4CPP_PUBLIC Vocabulary final {
   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;
+    [[deprecated("Use the default constructor of Vocabulary instead.")]] static const Vocabulary EMPTY_VOCABULARY;
 
     Vocabulary() {}
 
+    Vocabulary(const Vocabulary&) = default;
+
     /// <summary>
     /// Constructs a new instance of <seealso cref="Vocabulary"/> from the specified
     /// literal and symbolic token names.
@@ -38,7 +37,7 @@ namespace dfa {
     /// </param>
     /// <seealso cref= #getLiteralName(int) </seealso>
     /// <seealso cref= #getSymbolicName(int) </seealso>
-    Vocabulary(const std::vector<std::string> &literalNames, const std::vector<std::string> &symbolicNames);
+    Vocabulary(std::vector<std::string> literalNames, std::vector<std::string> symbolicNames);
 
     /// <summary>
     /// Constructs a new instance of <seealso cref="Vocabulary"/> from the specified
@@ -56,29 +55,14 @@ namespace dfa {
     /// <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);
+    Vocabulary(std::vector<std::string> literalNames, std::vector<std::string> symbolicNames,
+               std::vector<std::string> displayNames);
 
     /// <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;
+    constexpr size_t getMaxTokenType() const { return _maxTokenType; }
 
     /// <summary>
     /// Gets the string literal associated with a token type. The string returned
@@ -115,7 +99,7 @@ namespace dfa {
     /// </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;
+    std::string_view getLiteralName(size_t tokenType) const;
 
     /// <summary>
     /// Gets the symbolic name associated with a token type. The string returned
@@ -159,7 +143,7 @@ namespace dfa {
     /// </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;
+    std::string_view getSymbolicName(size_t tokenType) const;
 
     /// <summary>
     /// Gets the display name of a token type.
@@ -180,7 +164,7 @@ namespace dfa {
     /// </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;
+    std::string getDisplayName(size_t tokenType) const;
 
   private:
     std::vector<std::string> const _literalNames;

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

@@ -6,36 +6,34 @@
 #pragma once
 
 #include <algorithm>
-#include <assert.h>
+#include <any>
 #include <atomic>
-#include <codecvt>
-#include <chrono>
+#include <bitset>
+#include <cassert>
+#include <climits>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <exception>
 #include <fstream>
 #include <iostream>
 #include <iterator>
 #include <limits>
-#include <limits.h>
-#include <list>
 #include <map>
 #include <memory>
+#include <mutex>
 #include <set>
-#include <stdarg.h>
-#include <stdint.h>
-#include <stdlib.h>
+#include <shared_mutex>
 #include <sstream>
 #include <stack>
 #include <string>
+#include <string_view>
 #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
@@ -49,25 +47,12 @@
     #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
@@ -78,26 +63,13 @@
     #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
@@ -105,27 +77,16 @@
   #endif
 #endif
 
-#include "support/guid.h"
-#include "support/Declarations.h"
+#ifdef __has_builtin
+#define ANTLR4CPP_HAVE_BUILTIN(x) __has_builtin(x)
+#else
+#define ANTLR4CPP_HAVE_BUILTIN(x) 0
+#endif
 
-#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
+#define ANTLR4CPP_INTERNAL_STRINGIFY(x) #x
+#define ANTLR4CPP_STRINGIFY(x) ANTLR4CPP_INTERNAL_STRINGIFY(x)
 
-  #ifdef HAS_NOEXCEPT
-    #define NOEXCEPT noexcept
-  #else
-    #define NOEXCEPT
-  #endif
-#endif
+#include "support/Declarations.h"
 
 // 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.