expressir 1.2.3 → 1.2.4

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

@@ -38,8 +38,15 @@ namespace atn {
 
 
   public:
-    static const size_t MIN_DFA_EDGE = 0;
-    static const size_t MAX_DFA_EDGE = 127; // forces unicode to stay in ATN
+#if __cplusplus >= 201703L
+    static constexpr size_t MIN_DFA_EDGE = 0;
+    static constexpr size_t MAX_DFA_EDGE = 127; // forces unicode to stay in ATN
+#else
+    enum : size_t {
+      MIN_DFA_EDGE = 0,
+      MAX_DFA_EDGE = 127, // forces unicode to stay in ATN
+    };
+#endif
 
   protected:
     /// <summary>

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

@@ -774,7 +774,7 @@ std::pair<ATNConfigSet *, ATNConfigSet *> ParserATNSimulator::splitAccordingToSe
 BitSet ParserATNSimulator::evalSemanticContext(std::vector<dfa::DFAState::PredPrediction*> predPredictions,
                                                ParserRuleContext *outerContext, bool complete) {
   BitSet predictions;
-  for (auto prediction : predPredictions) {
+  for (auto *prediction : predPredictions) {
     if (prediction->pred == SemanticContext::NONE) {
       predictions.set(prediction->alt);
       if (!complete) {
@@ -1348,7 +1348,9 @@ Parser* ParserATNSimulator::getParser() {
   return parser;
 }
 
-#pragma warning (disable:4996) // 'getenv': This function or variable may be unsafe. Consider using _dupenv_s instead. 
+#ifdef _MSC_VER
+#pragma warning (disable:4996) // 'getenv': This function or variable may be unsafe. Consider using _dupenv_s instead.
+#endif
 
 bool ParserATNSimulator::getLrLoopSetting() {
   char *var = std::getenv("TURN_OFF_LR_LOOP_ENTRY_BRANCH_OPT");
@@ -1358,7 +1360,9 @@ bool ParserATNSimulator::getLrLoopSetting() {
   return value == "true" || value == "1";
 }
 
+#ifdef _MSC_VER
 #pragma warning (default:4996)
+#endif
 
 void ParserATNSimulator::InitializeInstanceFields() {
   _mode = PredictionMode::LL;

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

@@ -30,10 +30,22 @@ namespace atn {
     // ml: originally Integer.MAX_VALUE, which would be -1 for us, but this is already used in places where
     //     -1 is converted to unsigned, so we use a different value here. Any value does the job provided it doesn't
     //     conflict with real return states.
-    static const size_t EMPTY_RETURN_STATE = static_cast<size_t>(-10); // std::numeric_limits<size_t>::max() - 9;
+#if __cplusplus >= 201703L
+    static constexpr size_t EMPTY_RETURN_STATE = std::numeric_limits<size_t>::max() - 9;
+#else
+    enum : size_t {
+      EMPTY_RETURN_STATE = static_cast<size_t>(-10), // std::numeric_limits<size_t>::max() - 9; doesn't work in VS 2013
+    };
+#endif
 
   private:
-    static const size_t INITIAL_HASH = 1;
+#if __cplusplus >= 201703L
+    static constexpr size_t INITIAL_HASH = 1;
+#else
+    enum : size_t {
+      INITIAL_HASH = 1,
+    };
+#endif
 
   public:
     static size_t globalNodeCount;

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

@@ -46,7 +46,7 @@ DFA::DFA(DFA &&other) : atnStartState(other.atnStartState), decision(other.decis
 
 DFA::~DFA() {
   bool s0InList = (s0 == nullptr);
-  for (auto state : states) {
+  for (auto *state : states) {
     if (state == s0)
       s0InList = true;
     delete state;
@@ -88,7 +88,7 @@ void DFA::setPrecedenceStartState(int precedence, DFAState *startState, SingleWr
 
 std::vector<DFAState *> DFA::getStates() const {
   std::vector<DFAState *> result;
-  for (auto state : states)
+  for (auto *state : states)
     result.push_back(state);
 
   std::sort(result.begin(), result.end(), [](DFAState *o1, DFAState *o2) -> bool {

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

@@ -27,7 +27,7 @@ std::string DFASerializer::toString() const {
 
   std::stringstream ss;
   std::vector<DFAState *> states = _dfa->getStates();
-  for (auto s : states) {
+  for (auto *s : states) {
     for (size_t i = 0; i < s->edges.size(); i++) {
       DFAState *t = s->edges[i];
       if (t != nullptr && t->stateNumber != INT32_MAX) {

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

@@ -42,7 +42,7 @@ DFAState::DFAState(std::unique_ptr<ATNConfigSet> configs_) : DFAState() {
 }
 
 DFAState::~DFAState() {
-  for (auto predicate : predicates) {
+  for (auto *predicate : predicates) {
     delete predicate;
   }
 }

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

@@ -112,7 +112,7 @@ void IntervalSet::add(const Interval &addition) {
 
 IntervalSet IntervalSet::Or(const std::vector<IntervalSet> &sets) {
   IntervalSet result;
-  for (auto &s : sets) {
+  for (const auto &s : sets) {
     result.addAll(s);
   }
   return result;
@@ -271,7 +271,7 @@ bool IntervalSet::contains(ssize_t el) const {
   if (el < _intervals[0].a) // list is sorted and el is before first interval; not here
     return false;
 
-  for (auto &interval : _intervals) {
+  for (const auto &interval : _intervals) {
     if (el >= interval.a && el <= interval.b) {
       return true; // found in this interval
     }
@@ -315,7 +315,7 @@ std::vector<Interval> const& IntervalSet::getIntervals() const {
 
 size_t IntervalSet::hashCode() const {
   size_t hash = MurmurHash::initialize();
-  for (auto &interval : _intervals) {
+  for (const auto &interval : _intervals) {
     hash = MurmurHash::update(hash, interval.a);
     hash = MurmurHash::update(hash, interval.b);
   }
@@ -349,7 +349,7 @@ std::string IntervalSet::toString(bool elemAreChar) const {
   }
 
   bool firstEntry = true;
-  for (auto &interval : _intervals) {
+  for (const auto &interval : _intervals) {
     if (!firstEntry)
       ss << ", ";
     firstEntry = false;
@@ -395,7 +395,7 @@ std::string IntervalSet::toString(const dfa::Vocabulary &vocabulary) const {
   }
 
   bool firstEntry = true;
-  for (auto &interval : _intervals) {
+  for (const auto &interval : _intervals) {
     if (!firstEntry)
       ss << ", ";
     firstEntry = false;
@@ -436,7 +436,7 @@ std::string IntervalSet::elementName(const dfa::Vocabulary &vocabulary, ssize_t
 
 size_t IntervalSet::size() const {
   size_t result = 0;
-  for (auto &interval : _intervals) {
+  for (const auto &interval : _intervals) {
     result += size_t(interval.b - interval.a + 1);
   }
   return result;
@@ -444,7 +444,7 @@ size_t IntervalSet::size() const {
 
 std::vector<ssize_t> IntervalSet::toList() const {
   std::vector<ssize_t> result;
-  for (auto &interval : _intervals) {
+  for (const auto &interval : _intervals) {
     ssize_t a = interval.a;
     ssize_t b = interval.b;
     for (ssize_t v = a; v <= b; v++) {
@@ -456,7 +456,7 @@ std::vector<ssize_t> IntervalSet::toList() const {
 
 std::set<ssize_t> IntervalSet::toSet() const {
   std::set<ssize_t> result;
-  for (auto &interval : _intervals) {
+  for (const auto &interval : _intervals) {
     ssize_t a = interval.a;
     ssize_t b = interval.b;
     for (ssize_t v = a; v <= b; v++) {
@@ -468,7 +468,7 @@ std::set<ssize_t> IntervalSet::toSet() const {
 
 ssize_t IntervalSet::get(size_t i) const {
   size_t index = 0;
-  for (auto &interval : _intervals) {
+  for (const auto &interval : _intervals) {
     ssize_t a = interval.a;
     ssize_t b = interval.b;
     for (ssize_t v = a; v <= b; v++) {

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

@@ -13,7 +13,13 @@ namespace misc {
   class ANTLR4CPP_PUBLIC MurmurHash {
 
   private:
-    static const size_t DEFAULT_SEED = 0;
+#if __cplusplus >= 201703L
+    static constexpr size_t DEFAULT_SEED = 0;
+#else
+    enum : size_t {
+      DEFAULT_SEED = 0,
+    };
+#endif
 
     /// Initialize the hash using the default seed value.
     /// Returns the intermediate hash value.

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

@@ -79,7 +79,7 @@ struct ANTLR4CPP_PUBLIC Any
     if (_ptr == a._ptr)
       return *this;
 
-    auto old_ptr = _ptr;
+    auto * old_ptr = _ptr;
     _ptr = a.clone();
 
     if (old_ptr)

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

@@ -16,7 +16,7 @@ std::string Arrays::listToString(const std::vector<std::string> &list, const std
   bool firstEntry = true;
 
   ss << '[';
-  for (auto &entry : list) {
+  for (const auto &entry : list) {
     ss << entry;
     if (firstEntry) {
       ss << separator;
@@ -32,7 +32,7 @@ template <>
 std::string Arrays::toString(const std::vector<antlr4::tree::ParseTree*> &source) {
   std::string result = "[";
   bool firstEntry = true;
-  for (auto value : source) {
+  for (auto *value : source) {
     result += value->toStringTree();
     if (firstEntry) {
       result += ", ";

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

@@ -46,7 +46,7 @@ namespace antlrcpp {
 
         case ' ':
           if (escapeSpaces) {
-            result += "·";
+            result += "\u00B7";
             break;
           }
           // else fall through

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

@@ -20,16 +20,26 @@ void replaceAll(std::string& str, std::string const& from, std::string const& to
 }
 
 std::string ws2s(std::wstring const& wstr) {
+#ifndef USE_UTF8_INSTEAD_OF_CODECVT
   std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
   std::string narrow = converter.to_bytes(wstr);
+#else
+  std::string narrow;
+  utf8::utf32to8(wstr.begin(), wstr.end(), std::back_inserter(narrow));
+#endif
 
   return narrow;
 }
 
 std::wstring s2ws(const std::string &str) {
+#ifndef USE_UTF8_INSTEAD_OF_CODECVT
   std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
   std::wstring wide = converter.from_bytes(str);
-  
+#else
+  std::wstring wide;
+  utf8::utf8to32(str.begin(), str.end(), std::back_inserter(wide));
+#endif
+
   return wide;
 }
 

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

@@ -7,43 +7,65 @@
 
 #include "antlr4-common.h"
 
+#ifdef USE_UTF8_INSTEAD_OF_CODECVT
+#include "utf8.h"
+#endif
+
 namespace antlrcpp {
 
   // For all conversions utf8 <-> utf32.
+  // I wouldn't prefer wstring_convert because: according to
+  // https://en.cppreference.com/w/cpp/locale/wstring_convert,
+  // wstring_convert is deprecated in C++17.
+  // utfcpp (https://github.com/nemtrif/utfcpp) is a substitution.
+#ifndef USE_UTF8_INSTEAD_OF_CODECVT
   // 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;
+  #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
 #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;
+    #ifndef USE_UTF8_INSTEAD_OF_CODECVT
+      // 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());
+      #if defined(_MSC_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
+        const auto p = reinterpret_cast<const int32_t *>(data.data());
+        return converter.to_bytes(p, p + data.size());
+      #else
+        return converter.to_bytes(data);
+      #endif
     #else
-      return converter.to_bytes(data);
+      std::string narrow;
+      utf8::utf32to8(data.begin(), data.end(), std::back_inserter(narrow));
+      return narrow;
     #endif
   }
 
   inline UTF32String utf8_to_utf32(const char* first, const char* last)
   {
-    thread_local UTF32Converter converter;
+    #ifndef USE_UTF8_INSTEAD_OF_CODECVT
+      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());
+      #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());
+        return s;
+      #else
+        std::u32string s = converter.from_bytes(first, last);
+        return s;
+      #endif
     #else
-      std::u32string s = converter.from_bytes(first, last);
+      UTF32String wide;
+      utf8::utf8to32(first, last, std::back_inserter(wide));
+      return wide;
     #endif
-    
-    return s;
   }
 
   void replaceAll(std::string &str, std::string const& from, std::string const& to);

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

@@ -88,7 +88,7 @@ namespace tree {
     }
 
     void reset() {
-      for (auto entry : _allocated)
+      for (auto * entry : _allocated)
         delete entry;
       _allocated.clear();
     }

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

@@ -15,15 +15,39 @@ namespace tree {
     static ParseTreeWalker &DEFAULT;
 
     virtual ~ParseTreeWalker();
-
+    
+    /**
+    * <summary>
+    * Performs a walk on the given parse tree starting at the root and going down recursively
+	* with depth-first search. On each node, <seealso cref="ParseTreeWalker#enterRule"/> is called before
+    * recursively walking down into child nodes, then
+    * <seealso cref="ParseTreeWalker#exitRule"/> is called after the recursive call to wind up.
+	* </summary>
+    * <param name='listener'> The listener used by the walker to process grammar rules </param>
+	* <param name='t'> The parse tree to be walked on </param>
+    */
     virtual void walk(ParseTreeListener *listener, ParseTree *t) const;
 
   protected:
-    /// The discovery of a rule node, involves sending two events: the generic
-    /// <seealso cref="ParseTreeListener#enterEveryRule"/> and a
-    /// <seealso cref="RuleContext"/>-specific event. First we trigger the generic and then
-    /// the rule specific. We do them in reverse order upon finishing the node.
+    
+    /**
+    * <summary>
+    * Enters a grammar rule by first triggering the generic event <seealso cref="ParseTreeListener#enterEveryRule"/>
+	* then by triggering the event specific to the given parse tree node
+	* </summary>
+    * <param name='listener'> The listener responding to the trigger events </param>
+	* <param name='r'> The grammar rule containing the rule context </param>
+    */
     virtual void enterRule(ParseTreeListener *listener, ParseTree *r) const;
+    
+    /**
+    * <summary>
+    * Exits a grammar rule by first triggering the event specific to the given parse tree node
+	* then by triggering the generic event <seealso cref="ParseTreeListener#exitEveryRule"/>
+	* </summary>
+    * <param name='listener'> The listener responding to the trigger events </param>
+	* <param name='r'> The grammar rule containing the rule context </param>
+    */
     virtual void exitRule(ParseTreeListener *listener, ParseTree *r) const;
   };
 

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

@@ -192,7 +192,7 @@ std::vector<ParseTree *> Trees::getDescendants(ParseTree *t) {
   std::size_t n = t->children.size();
   for (size_t i = 0 ; i < n ; i++) {
     auto descentants = getDescendants(t->children[i]);
-    for (auto entry: descentants) {
+    for (auto *entry: descentants) {
       nodes.push_back(entry);
     }
   }

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/pattern/ParseTreePattern.cpp

@@ -37,7 +37,7 @@ std::vector<ParseTreeMatch> ParseTreePattern::findAll(ParseTree *tree, const std
   xpath::XPath finder(_matcher->getParser(), xpath);
   std::vector<ParseTree *> subtrees = finder.evaluate(tree);
   std::vector<ParseTreeMatch> matches;
-  for (auto t : subtrees) {
+  for (auto *t : subtrees) {
     ParseTreeMatch aMatch = match(t);
     if (aMatch.succeeded()) {
       matches.push_back(aMatch);

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/xpath/XPath.cpp

@@ -137,7 +137,7 @@ std::vector<ParseTree *> XPath::evaluate(ParseTree *t) {
 
   while (i < elements.size()) {
     std::vector<ParseTree *> next;
-    for (auto node : work) {
+    for (auto *node : work) {
       if (!node->children.empty()) {
         // only try to match next element if it has children
         // e.g., //func/*/stat might have a token node for which

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/xpath/XPathRuleElement.cpp

@@ -18,7 +18,7 @@ XPathRuleElement::XPathRuleElement(const std::string &ruleName, size_t ruleIndex
 std::vector<ParseTree *> XPathRuleElement::evaluate(ParseTree *t) {
   // return all children of t that match nodeName
   std::vector<ParseTree *> nodes;
-  for (auto c : t->children) {
+  for (auto *c : t->children) {
     if (antlrcpp::is<ParserRuleContext *>(c)) {
       ParserRuleContext *ctx = dynamic_cast<ParserRuleContext *>(c);
       if ((ctx->getRuleIndex() == _ruleIndex && !_invert) || (ctx->getRuleIndex() != _ruleIndex && _invert)) {

data/ext/express-parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/xpath/XPathTokenElement.cpp

@@ -21,7 +21,7 @@ XPathTokenElement::XPathTokenElement(const std::string &tokenName, size_t tokenT
 std::vector<ParseTree *> XPathTokenElement::evaluate(ParseTree *t) {
   // return all children of t that match nodeName
   std::vector<ParseTree *> nodes;
-  for (auto c : t->children) {
+  for (auto *c : t->children) {
     if (antlrcpp::is<TerminalNode *>(c)) {
       TerminalNode *tnode = dynamic_cast<TerminalNode *>(c);
       if ((tnode->getSymbol()->getType() == _tokenType && !_invert) || (tnode->getSymbol()->getType() != _tokenType && _invert)) {