expressir 1.2.3 → 1.2.6

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

@@ -0,0 +1,22 @@
+/* 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 <cstddef>
+
+#include "antlr4-common.h"
+
+namespace antlr4 {
+namespace tree {
+
+  enum class ParseTreeType : size_t {
+    TERMINAL = 1,
+    ERROR = 2,
+    RULE = 3,
+  };
+
+} // namespace tree
+} // namespace antlr4

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

@@ -27,7 +27,7 @@ namespace tree {
     /// </summary>
     /// <param name="tree"> The <seealso cref="ParseTree"/> to visit. </param>
     /// <returns> The result of visiting the parse tree. </returns>
-    virtual antlrcpp::Any visit(ParseTree *tree) = 0;
+    virtual std::any visit(ParseTree *tree) = 0;
 
     /// <summary>
     /// Visit the children of a node, and return a user-defined result of the
@@ -35,21 +35,21 @@ namespace tree {
     /// </summary>
     /// <param name="node"> The <seealso cref="ParseTree"/> whose children should be visited. </param>
     /// <returns> The result of visiting the children of the node. </returns>
-    virtual antlrcpp::Any visitChildren(ParseTree *node) = 0;
+    virtual std::any visitChildren(ParseTree *node) = 0;
 
     /// <summary>
     /// Visit a terminal node, and return a user-defined result of the operation.
     /// </summary>
     /// <param name="node"> The <seealso cref="TerminalNode"/> to visit. </param>
     /// <returns> The result of visiting the node. </returns>
-    virtual antlrcpp::Any visitTerminal(TerminalNode *node) = 0;
+    virtual std::any visitTerminal(TerminalNode *node) = 0;
 
     /// <summary>
     /// Visit an error node, and return a user-defined result of the operation.
     /// </summary>
     /// <param name="node"> The <seealso cref="ErrorNode"/> to visit. </param>
     /// <returns> The result of visiting the node. </returns>
-    virtual antlrcpp::Any visitErrorNode(ErrorNode *node) = 0;
+    virtual std::any visitErrorNode(ErrorNode *node) = 0;
 
   };
 

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

@@ -7,6 +7,7 @@
 #include "ParserRuleContext.h"
 #include "tree/ParseTreeListener.h"
 #include "support/CPPUtils.h"
+#include "support/Casts.h"
 
 #include "tree/IterativeParseTreeWalker.h"
 #include "tree/ParseTreeWalker.h"
@@ -17,15 +18,13 @@ using namespace antlrcpp;
 static IterativeParseTreeWalker defaultWalker;
 ParseTreeWalker &ParseTreeWalker::DEFAULT = defaultWalker;
 
-ParseTreeWalker::~ParseTreeWalker() {
-}
-
 void ParseTreeWalker::walk(ParseTreeListener *listener, ParseTree *t) const {
-  if (is<ErrorNode *>(t)) {
-    listener->visitErrorNode(dynamic_cast<ErrorNode *>(t));
+  if (ErrorNode::is(*t)) {
+    listener->visitErrorNode(downCast<ErrorNode*>(t));
     return;
-  } else if (is<TerminalNode *>(t)) {
-    listener->visitTerminal(dynamic_cast<TerminalNode *>(t));
+  }
+  if (TerminalNode::is(*t)) {
+    listener->visitTerminal(downCast<TerminalNode*>(t));
     return;
   }
 
@@ -37,13 +36,13 @@ void ParseTreeWalker::walk(ParseTreeListener *listener, ParseTree *t) const {
 }
 
 void ParseTreeWalker::enterRule(ParseTreeListener *listener, ParseTree *r) const {
-  ParserRuleContext *ctx = dynamic_cast<ParserRuleContext *>(r);
+  auto *ctx = downCast<ParserRuleContext*>(r);
   listener->enterEveryRule(ctx);
   ctx->enterRule(listener);
 }
 
 void ParseTreeWalker::exitRule(ParseTreeListener *listener, ParseTree *r) const {
-  ParserRuleContext *ctx = dynamic_cast<ParserRuleContext *>(r);
+  auto *ctx = downCast<ParserRuleContext*>(r);
   ctx->exitRule(listener);
   listener->exitEveryRule(ctx);
 }

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

@@ -14,16 +14,40 @@ namespace tree {
   public:
     static ParseTreeWalker &DEFAULT;
 
-    virtual ~ParseTreeWalker();
-
+    virtual ~ParseTreeWalker() = default;
+
+    /**
+    * <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/TerminalNode.h

@@ -12,9 +12,14 @@ namespace tree {
 
   class ANTLR4CPP_PUBLIC TerminalNode : public ParseTree {
   public:
-    ~TerminalNode() override;
+    static bool is(const tree::ParseTree &parseTree) {
+      const auto treeType = parseTree.getTreeType();
+      return treeType == ParseTreeType::TERMINAL || treeType == ParseTreeType::ERROR;
+    }
 
-    virtual Token* getSymbol() = 0;
+    static bool is(const tree::ParseTree *parseTree) { return parseTree != nullptr && is(*parseTree); }
+
+    virtual Token* getSymbol() const = 0;
 
     /** Set the parent for this leaf node.
      *
@@ -26,6 +31,9 @@ namespace tree {
      *  @since 4.7
      */
     virtual void setParent(RuleContext *parent) = 0;
+
+  protected:
+    using ParseTree::ParseTree;
   };
 
 } // namespace tree

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

@@ -13,10 +13,7 @@
 using namespace antlr4;
 using namespace antlr4::tree;
 
-TerminalNodeImpl::TerminalNodeImpl(Token *symbol_) : symbol(symbol_) {
-}
-
-Token* TerminalNodeImpl::getSymbol() {
+Token* TerminalNodeImpl::getSymbol() const {
   return symbol;
 }
 
@@ -33,7 +30,7 @@ misc::Interval TerminalNodeImpl::getSourceInterval() {
   return misc::Interval(tokenIndex, tokenIndex);
 }
 
-antlrcpp::Any TerminalNodeImpl::accept(ParseTreeVisitor *visitor) {
+std::any TerminalNodeImpl::accept(ParseTreeVisitor *visitor) {
   return visitor->visitTerminal(this);
 }
 

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

@@ -10,23 +10,22 @@
 namespace antlr4 {
 namespace tree {
 
-  class ANTLR4CPP_PUBLIC TerminalNodeImpl : public virtual TerminalNode {
+  class ANTLR4CPP_PUBLIC TerminalNodeImpl : public TerminalNode {
   public:
     Token *symbol;
 
-    TerminalNodeImpl(Token *symbol);
+    explicit TerminalNodeImpl(Token *symbol) : TerminalNode(ParseTreeType::TERMINAL), symbol(symbol) {}
 
-    virtual Token* getSymbol() override;
+    virtual Token* getSymbol() const override;
     virtual void setParent(RuleContext *parent) override;
     virtual misc::Interval getSourceInterval() override;
 
-    virtual antlrcpp::Any accept(ParseTreeVisitor *visitor) override;
+    virtual std::any accept(ParseTreeVisitor *visitor) override;
 
     virtual std::string getText() override;
     virtual std::string toStringTree(Parser *parser, bool pretty = false) override;
     virtual std::string toString() override;
     virtual std::string toStringTree(bool pretty = false) override;
-
   };
 
 } // namespace tree

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/pattern/ParseTreePatternMatcher.cpp

@@ -21,7 +21,6 @@
 #include "ANTLRInputStream.h"
 #include "support/Arrays.h"
 #include "Exceptions.h"
-#include "support/StringUtils.h"
 #include "support/CPPUtils.h"
 
 #include "tree/pattern/ParseTreePatternMatcher.h"
@@ -109,7 +108,7 @@ ParseTreePattern ParseTreePatternMatcher::compile(const std::string &pattern, in
     throw e;
 #else
   } catch (std::exception & /*e*/) {
-    std::throw_with_nested((const char*)"Cannot invoke start rule"); // Wrap any other exception. We should however probably use one of the ANTLR exceptions here.
+    std::throw_with_nested(RuntimeException("Cannot invoke start rule")); // Wrap any other exception.
 #endif
   }
 

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/XPathLexer.cpp

@@ -1,11 +1,125 @@
+
+// Generated from XPathLexer.g4 by ANTLR 4.9.3
+
+
 #include "XPathLexer.h"
 
 
 using namespace antlr4;
 
+namespace {
+
+struct XPathLexerStaticData final {
+  XPathLexerStaticData(std::vector<std::string> ruleNames,
+                        std::vector<std::string> channelNames,
+                        std::vector<std::string> modeNames,
+                        std::vector<std::string> literalNames,
+                        std::vector<std::string> symbolicNames)
+      : ruleNames(std::move(ruleNames)), channelNames(std::move(channelNames)),
+        modeNames(std::move(modeNames)), literalNames(std::move(literalNames)),
+        symbolicNames(std::move(symbolicNames)),
+        vocabulary(this->literalNames, this->symbolicNames) {}
+
+  XPathLexerStaticData(const XPathLexerStaticData&) = delete;
+  XPathLexerStaticData(XPathLexerStaticData&&) = delete;
+  XPathLexerStaticData& operator=(const XPathLexerStaticData&) = delete;
+  XPathLexerStaticData& operator=(XPathLexerStaticData&&) = delete;
+
+  std::vector<antlr4::dfa::DFA> decisionToDFA;
+  antlr4::atn::PredictionContextCache sharedContextCache;
+  const std::vector<std::string> ruleNames;
+  const std::vector<std::string> channelNames;
+  const std::vector<std::string> modeNames;
+  const std::vector<std::string> literalNames;
+  const std::vector<std::string> symbolicNames;
+  const antlr4::dfa::Vocabulary vocabulary;
+  antlr4::atn::SerializedATNView serializedATN;
+  std::unique_ptr<antlr4::atn::ATN> atn;
+};
+
+std::once_flag xpathLexerOnceFlag;
+XPathLexerStaticData *xpathLexerStaticData = nullptr;
+
+void xpathLexerInitialize() {
+  assert(xpathLexerStaticData == nullptr);
+  auto staticData = std::make_unique<XPathLexerStaticData>(
+    std::vector<std::string>{
+      "ANYWHERE", "ROOT", "WILDCARD", "BANG", "ID", "NameChar", "NameStartChar",
+      "STRING"
+    },
+    std::vector<std::string>{
+      "DEFAULT_TOKEN_CHANNEL", "HIDDEN"
+    },
+    std::vector<std::string>{
+      "DEFAULT_MODE"
+    },
+    std::vector<std::string>{
+      "", "", "", "'//'", "'/'", "'*'", "'!'"
+    },
+    std::vector<std::string>{
+      "", "TOKEN_REF", "RULE_REF", "ANYWHERE", "ROOT", "WILDCARD", "BANG", "ID",
+      "STRING"
+    }
+  );
+  static const int32_t serializedATNSegment[] = {
+    0x4, 0x0, 0x8, 0x32, 0x6, -1, 0x2, 0x0, 0x7, 0x0, 0x2, 0x1, 0x7,
+       0x1, 0x2, 0x2, 0x7, 0x2, 0x2, 0x3, 0x7, 0x3, 0x2, 0x4, 0x7, 0x4,
+       0x2, 0x5, 0x7, 0x5, 0x2, 0x6, 0x7, 0x6, 0x2, 0x7, 0x7, 0x7, 0x1,
+       0x0, 0x1, 0x0, 0x1, 0x0, 0x1, 0x1, 0x1, 0x1, 0x1, 0x2, 0x1, 0x2,
+       0x1, 0x3, 0x1, 0x3, 0x1, 0x4, 0x1, 0x4, 0x5, 0x4, 0x1d, 0x8, 0x4,
+       0xa, 0x4, 0xc, 0x4, 0x20, 0x9, 0x4, 0x1, 0x4, 0x1, 0x4, 0x1, 0x5,
+       0x1, 0x5, 0x3, 0x5, 0x26, 0x8, 0x5, 0x1, 0x6, 0x1, 0x6, 0x1, 0x7,
+       0x1, 0x7, 0x5, 0x7, 0x2c, 0x8, 0x7, 0xa, 0x7, 0xc, 0x7, 0x2f, 0x9,
+       0x7, 0x1, 0x7, 0x1, 0x7, 0x1, 0x2d, 0x0, 0x8, 0x1, 0x3, 0x3, 0x4,
+       0x5, 0x5, 0x7, 0x6, 0x9, 0x7, 0xb, 0x0, 0xd, 0x0, 0xf, 0x8, 0x1,
+       0x0, 0x2, 0x5, 0x0, 0x30, 0x39, 0x5f, 0x5f, 0xb7, 0xb7, 0x300, 0x36f,
+       0x203f, 0x2040, 0xd, 0x0, 0x41, 0x5a, 0x61, 0x7a, 0xc0, 0xd6, 0xd8,
+       0xf6, 0xf8, 0x2ff, 0x370, 0x37d, 0x37f, 0x1fff, 0x200c, 0x200d, 0x2070,
+       0x218f, 0x2c00, 0x2fef, 0x3001, 0xd7ff, 0xf900, 0xfdcf, 0xfdf0, -1,
+       0x0, 0x32, 0x0, 0x1, 0x1, 0x0, 0x0, 0x0, 0x0, 0x3, 0x1, 0x0, 0x0,
+       0x0, 0x0, 0x5, 0x1, 0x0, 0x0, 0x0, 0x0, 0x7, 0x1, 0x0, 0x0, 0x0,
+       0x0, 0x9, 0x1, 0x0, 0x0, 0x0, 0x0, 0xf, 0x1, 0x0, 0x0, 0x0, 0x1,
+       0x11, 0x1, 0x0, 0x0, 0x0, 0x3, 0x14, 0x1, 0x0, 0x0, 0x0, 0x5, 0x16,
+       0x1, 0x0, 0x0, 0x0, 0x7, 0x18, 0x1, 0x0, 0x0, 0x0, 0x9, 0x1a, 0x1,
+       0x0, 0x0, 0x0, 0xb, 0x25, 0x1, 0x0, 0x0, 0x0, 0xd, 0x27, 0x1, 0x0,
+       0x0, 0x0, 0xf, 0x29, 0x1, 0x0, 0x0, 0x0, 0x11, 0x12, 0x5, 0x2f, 0x0,
+       0x0, 0x12, 0x13, 0x5, 0x2f, 0x0, 0x0, 0x13, 0x2, 0x1, 0x0, 0x0, 0x0,
+       0x14, 0x15, 0x5, 0x2f, 0x0, 0x0, 0x15, 0x4, 0x1, 0x0, 0x0, 0x0, 0x16,
+       0x17, 0x5, 0x2a, 0x0, 0x0, 0x17, 0x6, 0x1, 0x0, 0x0, 0x0, 0x18, 0x19,
+       0x5, 0x21, 0x0, 0x0, 0x19, 0x8, 0x1, 0x0, 0x0, 0x0, 0x1a, 0x1e, 0x3,
+       0xd, 0x6, 0x0, 0x1b, 0x1d, 0x3, 0xb, 0x5, 0x0, 0x1c, 0x1b, 0x1, 0x0,
+       0x0, 0x0, 0x1d, 0x20, 0x1, 0x0, 0x0, 0x0, 0x1e, 0x1c, 0x1, 0x0, 0x0,
+       0x0, 0x1e, 0x1f, 0x1, 0x0, 0x0, 0x0, 0x1f, 0x21, 0x1, 0x0, 0x0, 0x0,
+       0x20, 0x1e, 0x1, 0x0, 0x0, 0x0, 0x21, 0x22, 0x6, 0x4, 0x0, 0x0, 0x22,
+       0xa, 0x1, 0x0, 0x0, 0x0, 0x23, 0x26, 0x3, 0xd, 0x6, 0x0, 0x24, 0x26,
+       0x7, 0x0, 0x0, 0x0, 0x25, 0x23, 0x1, 0x0, 0x0, 0x0, 0x25, 0x24, 0x1,
+       0x0, 0x0, 0x0, 0x26, 0xc, 0x1, 0x0, 0x0, 0x0, 0x27, 0x28, 0x7, 0x1,
+       0x0, 0x0, 0x28, 0xe, 0x1, 0x0, 0x0, 0x0, 0x29, 0x2d, 0x5, 0x27, 0x0,
+       0x0, 0x2a, 0x2c, 0x9, 0x0, 0x0, 0x0, 0x2b, 0x2a, 0x1, 0x0, 0x0, 0x0,
+       0x2c, 0x2f, 0x1, 0x0, 0x0, 0x0, 0x2d, 0x2e, 0x1, 0x0, 0x0, 0x0, 0x2d,
+       0x2b, 0x1, 0x0, 0x0, 0x0, 0x2e, 0x30, 0x1, 0x0, 0x0, 0x0, 0x2f, 0x2d,
+       0x1, 0x0, 0x0, 0x0, 0x30, 0x31, 0x5, 0x27, 0x0, 0x0, 0x31, 0x10,
+       0x1, 0x0, 0x0, 0x0, 0x4, 0x0, 0x1e, 0x25, 0x2d, 0x1, 0x1, 0x4, 0x0,
+  };
+
+  staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));
+
+  atn::ATNDeserializer deserializer;
+  staticData->atn = deserializer.deserialize(staticData->serializedATN);
+
+  size_t count = staticData->atn->getNumberOfDecisions();
+  staticData->decisionToDFA.reserve(count);
+  for (size_t i = 0; i < count; i++) {
+    staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
+  }
+  xpathLexerStaticData = staticData.release();
+}
+
+}
 
 XPathLexer::XPathLexer(CharStream *input) : Lexer(input) {
-  _interpreter = new atn::LexerATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
+  XPathLexer::initialize();
+  _interpreter = new atn::LexerATNSimulator(this, *xpathLexerStaticData->atn, xpathLexerStaticData->decisionToDFA, xpathLexerStaticData->sharedContextCache);
 }
 
 XPathLexer::~XPathLexer() {
@@ -17,46 +131,41 @@ std::string XPathLexer::getGrammarFileName() const {
 }
 
 const std::vector<std::string>& XPathLexer::getRuleNames() const {
-  return _ruleNames;
+  return xpathLexerStaticData->ruleNames;
 }
 
 const std::vector<std::string>& XPathLexer::getChannelNames() const {
-  return _channelNames;
+  return xpathLexerStaticData->channelNames;
 }
 
 const std::vector<std::string>& XPathLexer::getModeNames() const {
-  return _modeNames;
-}
-
-const std::vector<std::string>& XPathLexer::getTokenNames() const {
-  return _tokenNames;
+  return xpathLexerStaticData->modeNames;
 }
 
-dfa::Vocabulary& XPathLexer::getVocabulary() const {
-  return _vocabulary;
+const dfa::Vocabulary& XPathLexer::getVocabulary() const {
+  return xpathLexerStaticData->vocabulary;
 }
 
-const std::vector<uint16_t> XPathLexer::getSerializedATN() const {
-  return _serializedATN;
+antlr4::atn::SerializedATNView XPathLexer::getSerializedATN() const {
+  return xpathLexerStaticData->serializedATN;
 }
 
 const atn::ATN& XPathLexer::getATN() const {
-  return _atn;
+  return *xpathLexerStaticData->atn;
 }
 
-
 void XPathLexer::action(RuleContext *context, size_t ruleIndex, size_t actionIndex) {
   switch (ruleIndex) {
-    case 4: IDAction(dynamic_cast<antlr4::RuleContext *>(context), actionIndex); break;
+    case 4: IDAction(antlrcpp::downCast<antlr4::RuleContext *>(context), actionIndex); break;
 
   default:
     break;
   }
 }
 
-void XPathLexer::IDAction(antlr4::RuleContext * /*context*/, size_t actionIndex) {
+void XPathLexer::IDAction(antlr4::RuleContext *context, size_t actionIndex) {
   switch (actionIndex) {
-    case 0: 
+    case 0:
     				if (isupper(getText()[0]))
     				  setType(TOKEN_REF);
     				else
@@ -68,106 +177,6 @@ void XPathLexer::IDAction(antlr4::RuleContext * /*context*/, size_t actionIndex)
   }
 }
 
-
-
-// Static vars and initialization.
-std::vector<dfa::DFA> XPathLexer::_decisionToDFA;
-atn::PredictionContextCache XPathLexer::_sharedContextCache;
-
-// We own the ATN which in turn owns the ATN states.
-atn::ATN XPathLexer::_atn;
-std::vector<uint16_t> XPathLexer::_serializedATN;
-
-std::vector<std::string> XPathLexer::_ruleNames = {
-  "ANYWHERE", "ROOT", "WILDCARD", "BANG", "ID", "NameChar", "NameStartChar", 
-  "STRING"
-};
-
-std::vector<std::string> XPathLexer::_channelNames = {
-  "DEFAULT_TOKEN_CHANNEL", "HIDDEN"
-};
-
-std::vector<std::string> XPathLexer::_modeNames = {
-  "DEFAULT_MODE"
-};
-
-std::vector<std::string> XPathLexer::_literalNames = {
-  "", "", "", "'//'", "'/'", "'*'", "'!'"
-};
-
-std::vector<std::string> XPathLexer::_symbolicNames = {
-  "", "TOKEN_REF", "RULE_REF", "ANYWHERE", "ROOT", "WILDCARD", "BANG", "ID", 
-  "STRING"
-};
-
-dfa::Vocabulary XPathLexer::_vocabulary(_literalNames, _symbolicNames);
-
-std::vector<std::string> XPathLexer::_tokenNames;
-
-XPathLexer::Initializer::Initializer() {
-  // This code could be in a static initializer lambda, but VS doesn't allow access to private class members from there.
-	for (size_t i = 0; i < _symbolicNames.size(); ++i) {
-		std::string name = _vocabulary.getLiteralName(i);
-		if (name.empty()) {
-			name = _vocabulary.getSymbolicName(i);
-		}
-
-		if (name.empty()) {
-			_tokenNames.push_back("<INVALID>");
-		} else {
-      _tokenNames.push_back(name);
-    }
-	}
-
-  _serializedATN = {
-    0x3, 0x430, 0xd6d1, 0x8206, 0xad2d, 0x4417, 0xaef1, 0x8d80, 0xaadd, 
-    0x2, 0xa, 0x34, 0x8, 0x1, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 
-    0x4, 0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 
-    0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x3, 0x2, 0x3, 0x2, 0x3, 
-    0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 
-    0x6, 0x3, 0x6, 0x7, 0x6, 0x1f, 0xa, 0x6, 0xc, 0x6, 0xe, 0x6, 0x22, 0xb, 
-    0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x5, 0x7, 0x28, 0xa, 0x7, 
-    0x3, 0x8, 0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x7, 0x9, 0x2e, 0xa, 0x9, 0xc, 
-    0x9, 0xe, 0x9, 0x31, 0xb, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x2f, 0x2, 0xa, 
-    0x3, 0x5, 0x5, 0x6, 0x7, 0x7, 0x9, 0x8, 0xb, 0x9, 0xd, 0x2, 0xf, 0x2, 
-    0x11, 0xa, 0x3, 0x2, 0x4, 0x7, 0x2, 0x32, 0x3b, 0x61, 0x61, 0xb9, 0xb9, 
-    0x302, 0x371, 0x2041, 0x2042, 0xf, 0x2, 0x43, 0x5c, 0x63, 0x7c, 0xc2, 
-    0xd8, 0xda, 0xf8, 0xfa, 0x301, 0x372, 0x37f, 0x381, 0x2001, 0x200e, 
-    0x200f, 0x2072, 0x2191, 0x2c02, 0x2ff1, 0x3003, 0xd801, 0xf902, 0xfdd1, 
-    0xfdf2, 0x1, 0x34, 0x2, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x5, 0x3, 0x2, 
-    0x2, 0x2, 0x2, 0x7, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9, 0x3, 0x2, 0x2, 0x2, 
-    0x2, 0xb, 0x3, 0x2, 0x2, 0x2, 0x2, 0x11, 0x3, 0x2, 0x2, 0x2, 0x3, 0x13, 
-    0x3, 0x2, 0x2, 0x2, 0x5, 0x16, 0x3, 0x2, 0x2, 0x2, 0x7, 0x18, 0x3, 0x2, 
-    0x2, 0x2, 0x9, 0x1a, 0x3, 0x2, 0x2, 0x2, 0xb, 0x1c, 0x3, 0x2, 0x2, 0x2, 
-    0xd, 0x27, 0x3, 0x2, 0x2, 0x2, 0xf, 0x29, 0x3, 0x2, 0x2, 0x2, 0x11, 
-    0x2b, 0x3, 0x2, 0x2, 0x2, 0x13, 0x14, 0x7, 0x31, 0x2, 0x2, 0x14, 0x15, 
-    0x7, 0x31, 0x2, 0x2, 0x15, 0x4, 0x3, 0x2, 0x2, 0x2, 0x16, 0x17, 0x7, 
-    0x31, 0x2, 0x2, 0x17, 0x6, 0x3, 0x2, 0x2, 0x2, 0x18, 0x19, 0x7, 0x2c, 
-    0x2, 0x2, 0x19, 0x8, 0x3, 0x2, 0x2, 0x2, 0x1a, 0x1b, 0x7, 0x23, 0x2, 
-    0x2, 0x1b, 0xa, 0x3, 0x2, 0x2, 0x2, 0x1c, 0x20, 0x5, 0xf, 0x8, 0x2, 
-    0x1d, 0x1f, 0x5, 0xd, 0x7, 0x2, 0x1e, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x1f, 
-    0x22, 0x3, 0x2, 0x2, 0x2, 0x20, 0x1e, 0x3, 0x2, 0x2, 0x2, 0x20, 0x21, 
-    0x3, 0x2, 0x2, 0x2, 0x21, 0x23, 0x3, 0x2, 0x2, 0x2, 0x22, 0x20, 0x3, 
-    0x2, 0x2, 0x2, 0x23, 0x24, 0x8, 0x6, 0x2, 0x2, 0x24, 0xc, 0x3, 0x2, 
-    0x2, 0x2, 0x25, 0x28, 0x5, 0xf, 0x8, 0x2, 0x26, 0x28, 0x9, 0x2, 0x2, 
-    0x2, 0x27, 0x25, 0x3, 0x2, 0x2, 0x2, 0x27, 0x26, 0x3, 0x2, 0x2, 0x2, 
-    0x28, 0xe, 0x3, 0x2, 0x2, 0x2, 0x29, 0x2a, 0x9, 0x3, 0x2, 0x2, 0x2a, 
-    0x10, 0x3, 0x2, 0x2, 0x2, 0x2b, 0x2f, 0x7, 0x29, 0x2, 0x2, 0x2c, 0x2e, 
-    0xb, 0x2, 0x2, 0x2, 0x2d, 0x2c, 0x3, 0x2, 0x2, 0x2, 0x2e, 0x31, 0x3, 
-    0x2, 0x2, 0x2, 0x2f, 0x30, 0x3, 0x2, 0x2, 0x2, 0x2f, 0x2d, 0x3, 0x2, 
-    0x2, 0x2, 0x30, 0x32, 0x3, 0x2, 0x2, 0x2, 0x31, 0x2f, 0x3, 0x2, 0x2, 
-    0x2, 0x32, 0x33, 0x7, 0x29, 0x2, 0x2, 0x33, 0x12, 0x3, 0x2, 0x2, 0x2, 
-    0x6, 0x2, 0x20, 0x27, 0x2f, 0x3, 0x3, 0x6, 0x2, 
-  };
-
-  atn::ATNDeserializer deserializer;
-  _atn = deserializer.deserialize(_serializedATN);
-
-  size_t count = _atn.getNumberOfDecisions();
-  _decisionToDFA.reserve(count);
-  for (size_t i = 0; i < count; i++) { 
-    _decisionToDFA.emplace_back(_atn.getDecisionState(i), i);
-  }
+void XPathLexer::initialize() {
+  std::call_once(xpathLexerOnceFlag, xpathLexerInitialize);
 }
-
-XPathLexer::Initializer XPathLexer::_init;

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

@@ -1,56 +1,47 @@
-#pragma once
 
+// Generated from XPathLexer.g4 by ANTLR 4.9.3
 
-#include "antlr4-runtime.h"
+#pragma once
 
 
+#include "antlr4-runtime.h"
 
 
 class  XPathLexer : public antlr4::Lexer {
 public:
   enum {
-    TOKEN_REF = 1, RULE_REF = 2, ANYWHERE = 3, ROOT = 4, WILDCARD = 5, BANG = 6, 
+    TOKEN_REF = 1, RULE_REF = 2, ANYWHERE = 3, ROOT = 4, WILDCARD = 5, BANG = 6,
     ID = 7, STRING = 8
   };
 
-  XPathLexer(antlr4::CharStream *input);
-  ~XPathLexer();
+  explicit XPathLexer(antlr4::CharStream *input);
+
+  ~XPathLexer() override;
 
   virtual std::string getGrammarFileName() const override;
+
   virtual const std::vector<std::string>& getRuleNames() const override;
 
   virtual const std::vector<std::string>& getChannelNames() const override;
+
   virtual const std::vector<std::string>& getModeNames() const override;
-  virtual const std::vector<std::string>& getTokenNames() const override; // deprecated, use vocabulary instead
-  virtual antlr4::dfa::Vocabulary& getVocabulary() const override;
 
-  virtual const std::vector<uint16_t> getSerializedATN() const override;
-  virtual const antlr4::atn::ATN& getATN() const override;
+  virtual const antlr4::dfa::Vocabulary& getVocabulary() const override;
 
-  virtual void action(antlr4::RuleContext *context, size_t ruleIndex, size_t actionIndex) override;
-private:
-  static std::vector<antlr4::dfa::DFA> _decisionToDFA;
-  static antlr4::atn::PredictionContextCache _sharedContextCache;
-  static std::vector<std::string> _ruleNames;
-  static std::vector<std::string> _tokenNames;
-  static std::vector<std::string> _channelNames;
-  static std::vector<std::string> _modeNames;
+  virtual antlr4::atn::SerializedATNView getSerializedATN() const override;
 
-  static std::vector<std::string> _literalNames;
-  static std::vector<std::string> _symbolicNames;
-  static antlr4::dfa::Vocabulary _vocabulary;
-  static antlr4::atn::ATN _atn;
-  static std::vector<uint16_t> _serializedATN;
+  virtual const antlr4::atn::ATN& getATN() const override;
 
+  virtual void action(antlr4::RuleContext *context, size_t ruleIndex, size_t actionIndex) override;
 
+  // By default the static state used to implement the lexer is lazily initialized during the first
+  // call to the constructor. You can call this function if you wish to initialize the static state
+  // ahead of time.
+  static void initialize();
+private:
   // Individual action functions triggered by action() above.
   void IDAction(antlr4::RuleContext *context, size_t actionIndex);
 
   // Individual semantic predicate functions triggered by sempred() above.
-
-  struct Initializer {
-    Initializer();
-  };
-  static Initializer _init;
 };
 

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)) {