expressir 1.2.3 → 1.2.4

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

@@ -18,20 +18,33 @@ namespace antlr4 {
   /// of speed.
   class ANTLR4CPP_PUBLIC Lexer : public Recognizer, public TokenSource {
   public:
-    static const size_t DEFAULT_MODE = 0;
-    static const size_t MORE = static_cast<size_t>(-2);
-    static const size_t SKIP = static_cast<size_t>(-3);
-
-    static const size_t DEFAULT_TOKEN_CHANNEL = Token::DEFAULT_CHANNEL;
-    static const size_t HIDDEN = Token::HIDDEN_CHANNEL;
-    static const size_t MIN_CHAR_VALUE = 0;
-    static const size_t MAX_CHAR_VALUE = 0x10FFFF;
+#if __cplusplus >= 201703L
+    static constexpr size_t DEFAULT_MODE = 0;
+    static constexpr size_t MORE = std::numeric_limits<size_t>::max() - 1;
+    static constexpr size_t SKIP = std::numeric_limits<size_t>::max() - 2;
+
+    static constexpr size_t DEFAULT_TOKEN_CHANNEL = Token::DEFAULT_CHANNEL;
+    static constexpr size_t HIDDEN = Token::HIDDEN_CHANNEL;
+    static constexpr size_t MIN_CHAR_VALUE = 0;
+    static constexpr size_t MAX_CHAR_VALUE = 0x10FFFF;
+#else
+    enum : size_t {
+      DEFAULT_MODE = 0,
+      MORE = static_cast<size_t>(-2), // std::numeric_limits<size_t>::max() - 1; doesn't work in VS 2013
+      SKIP = static_cast<size_t>(-3), // std::numeric_limits<size_t>::max() - 2; doesn't work in VS 2013
+
+      DEFAULT_TOKEN_CHANNEL = Token::DEFAULT_CHANNEL,
+      HIDDEN = Token::HIDDEN_CHANNEL,
+      MIN_CHAR_VALUE = 0,
+      MAX_CHAR_VALUE = 0x10FFFF,
+    };
+#endif
 
     CharStream *_input; // Pure reference, usually from statically allocated instance.
 
   protected:
     /// How to create token objects.
-    Ref<TokenFactory<CommonToken>> _factory;
+    TokenFactory<CommonToken> *_factory;
 
   public:
     /// The goal of all lexer rules/methods is to create a token object.
@@ -100,7 +113,7 @@ namespace antlr4 {
       this->_factory = factory;
     }
 
-    virtual Ref<TokenFactory<CommonToken>> getTokenFactory() override;
+    virtual TokenFactory<CommonToken>* getTokenFactory() override;
 
     /// Set the char stream and reset the lexer
     virtual void setInputStream(IntStream *input) override;

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

@@ -82,11 +82,11 @@ std::string ListTokenSource::getSourceName() {
   return "List";
 }
 
-Ref<TokenFactory<CommonToken>> ListTokenSource::getTokenFactory() {
+TokenFactory<CommonToken>* ListTokenSource::getTokenFactory() {
   return _factory;
 }
 
 void ListTokenSource::InitializeInstanceFields() {
   i = 0;
-  _factory = CommonTokenFactory::DEFAULT;
+  _factory = CommonTokenFactory::DEFAULT.get();
 }

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

@@ -40,7 +40,7 @@ namespace antlr4 {
   private:
     /// This is the backing field for <seealso cref="#getTokenFactory"/> and
     /// <seealso cref="setTokenFactory"/>.
-    Ref<TokenFactory<CommonToken>> _factory = CommonTokenFactory::DEFAULT;
+    TokenFactory<CommonToken> *_factory = CommonTokenFactory::DEFAULT.get();
 
   public:
     /// Constructs a new <seealso cref="ListTokenSource"/> instance from the specified
@@ -79,7 +79,7 @@ namespace antlr4 {
       this->_factory = factory;
     }
 
-    virtual Ref<TokenFactory<CommonToken>> getTokenFactory() override;
+    virtual TokenFactory<CommonToken>* getTokenFactory() override;
 
   private:
     void InitializeInstanceFields();

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

@@ -190,7 +190,7 @@ void Parser::removeParseListeners() {
 }
 
 void Parser::triggerEnterRuleEvent() {
-  for (auto listener : _parseListeners) {
+  for (auto *listener : _parseListeners) {
     listener->enterEveryRule(_ctx);
     _ctx->enterRule(listener);
   }
@@ -208,7 +208,7 @@ size_t Parser::getNumberOfSyntaxErrors() {
   return _syntaxErrors;
 }
 
-Ref<TokenFactory<CommonToken>> Parser::getTokenFactory() {
+TokenFactory<CommonToken>* Parser::getTokenFactory() {
   return _input->getTokenSource()->getTokenFactory();
 }
 
@@ -307,14 +307,14 @@ Token* Parser::consume() {
       tree::ErrorNode *node = createErrorNode(o);
       _ctx->addChild(node);
       if (_parseListeners.size() > 0) {
-        for (auto listener : _parseListeners) {
+        for (auto *listener : _parseListeners) {
           listener->visitErrorNode(node);
         }
       }
     } else {
       tree::TerminalNode *node = _ctx->addChild(createTerminalNode(o));
       if (_parseListeners.size() > 0) {
-        for (auto listener : _parseListeners) {
+        for (auto *listener : _parseListeners) {
           listener->visitTerminal(node);
         }
       }

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

@@ -193,7 +193,7 @@ namespace antlr4 {
     /// <seealso cref= #notifyErrorListeners </seealso>
     virtual size_t getNumberOfSyntaxErrors();
 
-    virtual Ref<TokenFactory<CommonToken>> getTokenFactory() override;
+    virtual TokenFactory<CommonToken>* getTokenFactory() override;
 
     /// <summary>
     /// Tell our token source and error strategy about a new way to create tokens. </summary>

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

@@ -38,8 +38,8 @@ void ParserRuleContext::copyFrom(ParserRuleContext *ctx) {
 
   // copy any error nodes to alt label node
   if (!ctx->children.empty()) {
-    for (auto child : ctx->children) {
-      auto errorNode = dynamic_cast<ErrorNode *>(child);
+    for (auto *child : ctx->children) {
+      auto *errorNode = dynamic_cast<ErrorNode *>(child);
       if (errorNode != nullptr) {
         errorNode->setParent(this);
         children.push_back(errorNode);
@@ -82,7 +82,7 @@ tree::TerminalNode* ParserRuleContext::getToken(size_t ttype, size_t i) {
   }
 
   size_t j = 0; // what token with ttype have we found?
-  for (auto o : children) {
+  for (auto *o : children) {
     if (is<tree::TerminalNode *>(o)) {
       tree::TerminalNode *tnode = dynamic_cast<tree::TerminalNode *>(o);
       Token *symbol = tnode->getSymbol();

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

@@ -114,7 +114,7 @@ namespace antlr4 {
     template<typename T>
     std::vector<T *> getRuleContexts() {
       std::vector<T *> contexts;
-      for (auto child : children) {
+      for (auto *child : children) {
         if (antlrcpp::is<T *>(child)) {
           contexts.push_back(dynamic_cast<T *>(child));
         }

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

@@ -26,28 +26,28 @@ void ProxyErrorListener::removeErrorListeners() {
 void ProxyErrorListener::syntaxError(Recognizer *recognizer, Token *offendingSymbol, size_t line,
   size_t charPositionInLine, const std::string &msg, std::exception_ptr e) {
 
-  for (auto listener : _delegates) {
+  for (auto *listener : _delegates) {
     listener->syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e);
   }
 }
 
 void ProxyErrorListener::reportAmbiguity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex,
   bool exact, const antlrcpp::BitSet &ambigAlts, atn::ATNConfigSet *configs) {
-  for (auto listener : _delegates) {
+  for (auto *listener : _delegates) {
     listener->reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs);
   }
 }
 
 void ProxyErrorListener::reportAttemptingFullContext(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex,
   size_t stopIndex, const antlrcpp::BitSet &conflictingAlts, atn::ATNConfigSet *configs) {
-  for (auto listener : _delegates) {
+  for (auto *listener : _delegates) {
     listener->reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs);
   }
 }
 
 void ProxyErrorListener::reportContextSensitivity(Parser *recognizer, const dfa::DFA &dfa, size_t startIndex, size_t stopIndex,
   size_t prediction, atn::ATNConfigSet *configs) {
-  for (auto listener : _delegates) {
+  for (auto *listener : _delegates) {
     listener->reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs);
   }
 }

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

@@ -11,7 +11,13 @@ namespace antlr4 {
 
   class ANTLR4CPP_PUBLIC Recognizer {
   public:
-    static const size_t EOF = static_cast<size_t>(-1); // std::numeric_limits<size_t>::max(); doesn't work in VS 2013.
+#if __cplusplus >= 201703L
+    static constexpr size_t EOF = std::numeric_limits<size_t>::max();
+#else
+    enum : size_t {
+      EOF = static_cast<size_t>(-1), // std::numeric_limits<size_t>::max(); doesn't work in VS 2013.
+    };
+#endif
 
     Recognizer();
     Recognizer(Recognizer const&) = delete;
@@ -138,7 +144,7 @@ namespace antlr4 {
 
     virtual void setInputStream(IntStream *input) = 0;
 
-    virtual Ref<TokenFactory<CommonToken>> getTokenFactory() = 0;
+    virtual TokenFactory<CommonToken>* getTokenFactory() = 0;
 
     template<typename T1>
     void setTokenFactory(TokenFactory<T1> *input);

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

@@ -7,7 +7,7 @@
 
 using namespace antlr4;
 
-const std::string RuntimeMetaData::VERSION = "4.8";
+const std::string RuntimeMetaData::VERSION = "4.9.2";
 
 std::string RuntimeMetaData::getRuntimeVersion() {
   return VERSION;

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

@@ -14,24 +14,50 @@ namespace antlr4 {
   /// we obtained this token.
   class ANTLR4CPP_PUBLIC Token {
   public:
-    static const size_t INVALID_TYPE = 0;
+#if __cplusplus >= 201703L
+    static constexpr size_t INVALID_TYPE = 0;
+#else
+    enum : size_t {
+      INVALID_TYPE = 0,
+    };
+#endif
 
     /// 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;
+#if __cplusplus >= 201703L
+    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;
+#else
+    enum : size_t {
+      EPSILON = static_cast<size_t>(-2), // std::numeric_limits<size_t>::max() - 1; doesn't work in VS 2013
+      MIN_USER_TOKEN_TYPE = 1,
+      EOF = IntStream::EOF,
+    };
+#endif
 
     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;
+#if __cplusplus >= 201703L
+    static constexpr size_t DEFAULT_CHANNEL = 0;
+#else
+    enum : size_t {
+      DEFAULT_CHANNEL = 0,
+    };
+#endif
 
     /// Anything on different channel than DEFAULT_CHANNEL is not parsed
     /// by parser.
-    static const size_t HIDDEN_CHANNEL = 1;
+#if __cplusplus >= 201703L
+    static constexpr size_t HIDDEN_CHANNEL = 1;
+#else
+    enum : size_t {
+      HIDDEN_CHANNEL = 1,
+    };
+#endif
 
     /**
      * This is the minimum constant value which can be assigned to a
@@ -44,7 +70,13 @@ namespace antlr4 {
      *
      * @see Token#getChannel()
      */
-    static const size_t MIN_USER_CHANNEL_VALUE = 2;
+#if __cplusplus >= 201703L
+    static constexpr size_t MIN_USER_CHANNEL_VALUE = 2;
+#else
+    enum : size_t {
+      MIN_USER_CHANNEL_VALUE = 2,
+    };
+#endif
 
     /// 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

@@ -94,7 +94,7 @@ TokenStreamRewriter::TokenStreamRewriter(TokenStream *tokens_) : tokens(tokens_)
 
 TokenStreamRewriter::~TokenStreamRewriter() {
   for (auto program : _programs) {
-    for (auto operation : program.second) {
+    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

@@ -86,8 +86,15 @@ 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;
+#if __cplusplus >= 201703L
+    static constexpr size_t PROGRAM_INIT_SIZE = 100;
+    static constexpr size_t MIN_TOKEN_INDEX = 0;
+#else
+    enum : size_t {
+      PROGRAM_INIT_SIZE = 100,
+      MIN_TOKEN_INDEX = 0,
+    };
+#endif
 
     TokenStreamRewriter(TokenStream *tokens);
     virtual ~TokenStreamRewriter();

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

@@ -22,8 +22,7 @@ Vocabulary::Vocabulary(const std::vector<std::string> &literalNames,
   // See note here on -1 part: https://github.com/antlr/antlr4/pull/1146
 }
 
-Vocabulary::~Vocabulary() {
-}
+Vocabulary::~Vocabulary() = default;
 
 Vocabulary Vocabulary::fromTokenNames(const std::vector<std::string> &tokenNames) {
   if (tokenNames.empty()) {
@@ -34,25 +33,18 @@ Vocabulary Vocabulary::fromTokenNames(const std::vector<std::string> &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 == "") {
+    const std::string& tokenName = tokenNames[i];
+    if (tokenName.empty()) {
       continue;
+    } else if (tokenName.front() == '\'') {
+      symbolicNames[i].clear();
+    } else if (std::isupper(tokenName.front(), locale)) {
+      literalNames[i].clear();
+    } else {
+      // wasn't a literal or symbolic name
+      literalNames[i].clear();
+      symbolicNames[i].clear();
     }
-
-    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);

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

@@ -14,9 +14,6 @@ namespace dfa {
   /// interface.
   class ANTLR4CPP_PUBLIC Vocabulary {
   public:
-    Vocabulary(Vocabulary const&) = default;
-    virtual ~Vocabulary();
-
     /// Gets an empty <seealso cref="Vocabulary"/> instance.
     ///
     /// <para>
@@ -26,6 +23,8 @@ namespace dfa {
     static const Vocabulary EMPTY_VOCABULARY;
 
     Vocabulary() {}
+    Vocabulary(Vocabulary const&) = default;
+    virtual ~Vocabulary();
 
     /// <summary>
     /// Constructs a new instance of <seealso cref="Vocabulary"/> from the specified

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

@@ -8,7 +8,6 @@
 #include <algorithm>
 #include <assert.h>
 #include <atomic>
-#include <codecvt>
 #include <chrono>
 #include <fstream>
 #include <iostream>
@@ -37,6 +36,10 @@
 #include <condition_variable>
 #include <functional>
 
+#ifndef USE_UTF8_INSTEAD_OF_CODECVT
+  #include <codecvt>
+#endif
+
 // Defines for the Guid class and other platform dependent stuff.
 #ifdef _WIN32
   #ifdef _MSC_VER

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

@@ -183,7 +183,7 @@ std::string ATN::toString() const {
   ss << "states (" << states.size() << ") {" << std::endl;
 
   size_t index = 0;
-  for (auto state : states) {
+  for (auto *state : states) {
     if (state == nullptr) {
       ss << "  " << index++ << ": nul" << std::endl;
     } else {
@@ -193,7 +193,7 @@ std::string ATN::toString() const {
   }
 
   index = 0;
-  for (auto state : decisionToState) {
+  for (auto *state : decisionToState) {
     if (state == nullptr) {
       ss << "  " << index++ << ": nul" << std::endl;
     } else {

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

@@ -12,7 +12,13 @@ namespace atn {
 
   class ANTLR4CPP_PUBLIC ATN {
   public:
-    static const size_t INVALID_ALT_NUMBER = 0;
+#if __cplusplus >= 201703L
+    static constexpr size_t INVALID_ALT_NUMBER = 0;
+#else
+    enum : size_t {
+      INVALID_ALT_NUMBER = 0,
+    };
+#endif
 
     /// Used for runtime deserialization of ATNs from strings.
     ATN();

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

@@ -11,8 +11,6 @@
 
 using namespace antlr4::atn;
 
-const size_t ATNConfig::SUPPRESS_PRECEDENCE_FILTER = 0x40000000;
-
 ATNConfig::ATNConfig(ATNState *state_, size_t alt_, Ref<PredictionContext> const& context_)
   : ATNConfig(state_, alt_, context_, SemanticContext::NONE) {
 }

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

@@ -114,7 +114,13 @@ namespace atn {
      * {@link #isPrecedenceFilterSuppressed} property as a bit within the
      * existing {@link #reachesIntoOuterContext} field.
      */
-    static const size_t SUPPRESS_PRECEDENCE_FILTER;
+#if __cplusplus >= 201703L
+    static constexpr size_t SUPPRESS_PRECEDENCE_FILTER = 0x40000000;
+#else
+    enum : size_t {
+      SUPPRESS_PRECEDENCE_FILTER = 0x40000000,
+    };
+#endif
   };
 
 } // namespace atn
@@ -139,7 +145,7 @@ namespace std {
     size_t operator() (const std::vector<Ref<ATNConfig>> &vector) const
     {
       std::size_t seed = 0;
-      for (auto &config : vector) {
+      for (const auto &config : vector) {
         seed ^= config->hashCode() + 0x9e3779b9 + (seed << 6) + (seed >> 2);
       }
       return seed;

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

@@ -57,8 +57,6 @@ using namespace antlr4;
 using namespace antlr4::atn;
 using namespace antlrcpp;
 
-const size_t ATNDeserializer::SERIALIZED_VERSION = 3;
-
 namespace {
 
 uint32_t deserializeInt32(const std::vector<uint16_t>& data, size_t offset) {

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

@@ -13,7 +13,13 @@ namespace atn {
 
   class ANTLR4CPP_PUBLIC ATNDeserializer {
   public:
-    static const size_t SERIALIZED_VERSION;
+#if __cplusplus >= 201703L
+    static constexpr size_t SERIALIZED_VERSION = 3;
+#else
+    enum : size_t {
+      SERIALIZED_VERSION = 3,
+    };
+#endif
 
     /// This is the current serialized UUID.
     // ml: defined as function to avoid the “static initialization order fiasco”.

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

@@ -166,7 +166,7 @@ std::vector<size_t> ATNSerializer::serialize() {
     }
 
     data.push_back(containsEof ? 1 : 0);
-    for (auto &interval : set.getIntervals()) {
+    for (const auto &interval : set.getIntervals()) {
       if (interval.a == -1) {
         if (interval.b == -1) {
           continue;

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

@@ -17,7 +17,7 @@ ATNState::ATNState() {
 }
 
 ATNState::~ATNState() {
-  for (auto transition : transitions) {
+  for (auto *transition : transitions) {
     delete transition;
   }
 }

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

@@ -81,8 +81,15 @@ namespace atn {
 
     ATNState& operator=(ATNState const&) = delete;
 
-    static const size_t INITIAL_NUM_TRANSITIONS = 4;
-    static const size_t INVALID_STATE_NUMBER = static_cast<size_t>(-1); // std::numeric_limits<size_t>::max();
+#if __cplusplus >= 201703L
+    static constexpr size_t INITIAL_NUM_TRANSITIONS = 4;
+    static constexpr size_t INVALID_STATE_NUMBER = std::numeric_limits<size_t>::max();
+#else
+    enum : size_t {
+      INITIAL_NUM_TRANSITIONS = 4,
+      INVALID_STATE_NUMBER = static_cast<size_t>(-1), // std::numeric_limits<size_t>::max(); doesn't work in VS 2013
+    };
+#endif
 
     enum {
       ATN_INVALID_TYPE = 0,

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

@@ -100,18 +100,16 @@ void LL1Analyzer::_LOOK(ATNState *s, ATNState *stopState, Ref<PredictionContext>
     }
 
     if (ctx != PredictionContext::EMPTY) {
-      // run thru all possible stack tops in ctx
+      bool removed = calledRuleStack.test(s->ruleIndex);
+      calledRuleStack[s->ruleIndex] = false;
+       auto onExit = finally([removed, &calledRuleStack, s] {
+                if (removed) {
+                  calledRuleStack.set(s->ruleIndex);
+                }
+              });
+       // run thru all possible stack tops in ctx
       for (size_t i = 0; i < ctx->size(); i++) {
         ATNState *returnState = _atn.states[ctx->getReturnState(i)];
-
-        bool removed = calledRuleStack.test(returnState->ruleIndex);
-        auto onExit = finally([removed, &calledRuleStack, returnState] {
-          if (removed) {
-            calledRuleStack.set(returnState->ruleIndex);
-          }
-        });
-
-        calledRuleStack[returnState->ruleIndex] = false;
         _LOOK(returnState, stopState, ctx->getParent(i), look, lookBusy, calledRuleStack, seeThruPreds, addEOF);
       }
       return;

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

@@ -17,7 +17,13 @@ namespace atn {
   public:
     /// Special value added to the lookahead sets to indicate that we hit
     ///  a predicate during analysis if {@code seeThruPreds==false}.
-    static const size_t HIT_PRED = Token::INVALID_TYPE;
+#if __cplusplus >= 201703L
+    static constexpr size_t HIT_PRED = Token::INVALID_TYPE;
+#else
+    enum : size_t {
+      HIT_PRED = Token::INVALID_TYPE,
+    };
+#endif
 
     const atn::ATN &_atn;