expressir 1.3.0 → 1.3.1

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/internal/Synchronization.cpp

@@ -0,0 +1,100 @@
+// 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.
+
+#include "internal/Synchronization.h"
+
+using namespace antlr4::internal;
+
+void Mutex::lock() {
+#if ANTLR4CPP_USING_ABSEIL
+  _impl.Lock();
+#else
+  _impl.lock();
+#endif
+}
+
+bool Mutex::try_lock() {
+#if ANTLR4CPP_USING_ABSEIL
+  return _impl.TryLock();
+#else
+  return _impl.try_lock();
+#endif
+}
+
+void Mutex::unlock() {
+#if ANTLR4CPP_USING_ABSEIL
+  _impl.Unlock();
+#else
+  _impl.unlock();
+#endif
+}
+
+void SharedMutex::lock() {
+#if ANTLR4CPP_USING_ABSEIL
+  _impl.WriterLock();
+#else
+  _impl.lock();
+#endif
+}
+
+bool SharedMutex::try_lock() {
+#if ANTLR4CPP_USING_ABSEIL
+  return _impl.WriterTryLock();
+#else
+  return _impl.try_lock();
+#endif
+}
+
+void SharedMutex::unlock() {
+#if ANTLR4CPP_USING_ABSEIL
+  _impl.WriterUnlock();
+#else
+  _impl.unlock();
+#endif
+}
+
+void SharedMutex::lock_shared() {
+#if ANTLR4CPP_USING_ABSEIL
+  _impl.ReaderLock();
+#else
+  _impl.lock_shared();
+#endif
+}
+
+bool SharedMutex::try_lock_shared() {
+#if ANTLR4CPP_USING_ABSEIL
+  return _impl.ReaderTryLock();
+#else
+  return _impl.try_lock_shared();
+#endif
+}
+
+void SharedMutex::unlock_shared() {
+#if ANTLR4CPP_USING_ABSEIL
+  _impl.ReaderUnlock();
+#else
+  _impl.unlock_shared();
+#endif
+}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/internal/Synchronization.h

@@ -0,0 +1,154 @@
+// 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"
+
+#include <mutex>
+#include <shared_mutex>
+#include <utility>
+
+#if ANTLR4CPP_USING_ABSEIL
+#include "absl/base/call_once.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+#define ANTLR4CPP_NO_THREAD_SAFTEY_ANALYSIS ABSL_NO_THREAD_SAFETY_ANALYSIS
+#else
+#define ANTLR4CPP_NO_THREAD_SAFTEY_ANALYSIS
+#endif
+
+// By default ANTLRv4 uses synchronization primitives provided by the C++ standard library. In most
+// deployments this is fine, however in some using custom synchronization primitives may be
+// preferred. This header allows that by optionally supporting some alternative implementations and
+// allowing for more easier patching of other alternatives.
+
+namespace antlr4::internal {
+
+  // Must be compatible with C++ standard library Mutex requirement.
+  class ANTLR4CPP_PUBLIC Mutex final {
+  public:
+    Mutex() = default;
+
+    // No copying or moving, we are as strict as possible to support other implementations.
+    Mutex(const Mutex&) = delete;
+    Mutex(Mutex&&) = delete;
+
+    // No copying or moving, we are as strict as possible to support other implementations.
+    Mutex& operator=(const Mutex&) = delete;
+    Mutex& operator=(Mutex&&) = delete;
+
+    void lock() ANTLR4CPP_NO_THREAD_SAFTEY_ANALYSIS;
+
+    bool try_lock() ANTLR4CPP_NO_THREAD_SAFTEY_ANALYSIS;
+
+    void unlock() ANTLR4CPP_NO_THREAD_SAFTEY_ANALYSIS;
+
+  private:
+#if ANTLR4CPP_USING_ABSEIL
+    absl::Mutex _impl;
+#else
+    std::mutex _impl;
+#endif
+  };
+
+  template <typename Mutex>
+  using UniqueLock = std::unique_lock<Mutex>;
+
+  // Must be compatible with C++ standard library SharedMutex requirement.
+  class ANTLR4CPP_PUBLIC SharedMutex final {
+  public:
+    SharedMutex() = default;
+
+    // No copying or moving, we are as strict as possible to support other implementations.
+    SharedMutex(const SharedMutex&) = delete;
+    SharedMutex(SharedMutex&&) = delete;
+
+    // No copying or moving, we are as strict as possible to support other implementations.
+    SharedMutex& operator=(const SharedMutex&) = delete;
+    SharedMutex& operator=(SharedMutex&&) = delete;
+
+    void lock() ANTLR4CPP_NO_THREAD_SAFTEY_ANALYSIS;
+
+    bool try_lock() ANTLR4CPP_NO_THREAD_SAFTEY_ANALYSIS;
+
+    void unlock() ANTLR4CPP_NO_THREAD_SAFTEY_ANALYSIS;
+
+    void lock_shared() ANTLR4CPP_NO_THREAD_SAFTEY_ANALYSIS;
+
+    bool try_lock_shared() ANTLR4CPP_NO_THREAD_SAFTEY_ANALYSIS;
+
+    void unlock_shared() ANTLR4CPP_NO_THREAD_SAFTEY_ANALYSIS;
+
+  private:
+#if ANTLR4CPP_USING_ABSEIL
+    absl::Mutex _impl;
+#else
+    std::shared_mutex _impl;
+#endif
+  };
+
+  template <typename Mutex>
+  using SharedLock = std::shared_lock<Mutex>;
+
+  class OnceFlag;
+
+  template <typename Callable, typename... Args>
+  void call_once(OnceFlag &onceFlag, Callable &&callable, Args&&... args);
+
+  // Must be compatible with std::once_flag.
+  class ANTLR4CPP_PUBLIC OnceFlag final {
+  public:
+    constexpr OnceFlag() = default;
+
+    // No copying or moving, we are as strict as possible to support other implementations.
+    OnceFlag(const OnceFlag&) = delete;
+    OnceFlag(OnceFlag&&) = delete;
+
+    // No copying or moving, we are as strict as possible to support other implementations.
+    OnceFlag& operator=(const OnceFlag&) = delete;
+    OnceFlag& operator=(OnceFlag&&) = delete;
+
+  private:
+    template <typename Callable, typename... Args>
+    friend void call_once(OnceFlag &onceFlag, Callable &&callable, Args&&... args);
+
+#if ANTLR4CPP_USING_ABSEIL
+    absl::once_flag _impl;
+#else
+    std::once_flag _impl;
+#endif
+  };
+
+  template <typename Callable, typename... Args>
+  void call_once(OnceFlag &onceFlag, Callable &&callable, Args&&... args) {
+#if ANTLR4CPP_USING_ABSEIL
+    absl::call_once(onceFlag._impl, std::forward<Callable>(callable), std::forward<Args>(args)...);
+#else
+    std::call_once(onceFlag._impl, std::forward<Callable>(callable), std::forward<Args>(args)...);
+#endif
+  }
+
+}  // namespace antlr4::internal

data/ext/{express-parser → express_parser}/antlr4-upstream/runtime/Cpp/runtime/src/misc/IntervalSet.cpp

@@ -37,7 +37,7 @@ IntervalSet& IntervalSet::operator=(const IntervalSet& other) {
 }
 
 IntervalSet& IntervalSet::operator=(IntervalSet&& other) {
-  _intervals = move(other._intervals);
+  _intervals = std::move(other._intervals);
   return *this;
 }
 

data/ext/{express-parser → express_parser}/antlr4-upstream/runtime/Cpp/runtime/src/misc/MurmurHash.cpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+/* 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.
  */
@@ -63,23 +63,6 @@ size_t MurmurHash::update(size_t hash, size_t value) {
   return hash;
 }
 
-size_t MurmurHash::update(size_t hash, const void *data, size_t size) {
-  size_t value;
-  const uint8_t *bytes = static_cast<const uint8_t*>(data);
-  while (size >= sizeof(size_t)) {
-    std::memcpy(&value, bytes, sizeof(size_t));
-    hash = update(hash, value);
-    bytes += sizeof(size_t);
-    size -= sizeof(size_t);
-  }
-  if (size != 0) {
-    value = 0;
-    std::memcpy(&value, bytes, size);
-    hash = update(hash, value);
-  }
-  return hash;
-}
-
 size_t MurmurHash::finish(size_t hash, size_t entryCount) {
   hash ^= entryCount * 8;
   hash ^= hash >> 33;
@@ -118,3 +101,20 @@ size_t MurmurHash::finish(size_t hash, size_t entryCount) {
 #else
 #error "Expected sizeof(size_t) to be 4 or 8."
 #endif
+
+size_t MurmurHash::update(size_t hash, const void *data, size_t size) {
+  size_t value;
+  const uint8_t *bytes = static_cast<const uint8_t*>(data);
+  while (size >= sizeof(size_t)) {
+    std::memcpy(&value, bytes, sizeof(size_t));
+    hash = update(hash, value);
+    bytes += sizeof(size_t);
+    size -= sizeof(size_t);
+  }
+  if (size != 0) {
+    value = 0;
+    std::memcpy(&value, bytes, size);
+    hash = update(hash, value);
+  }
+  return hash;
+}

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/xpath/XPathLexer.cpp

@@ -0,0 +1,180 @@
+
+// Generated from XPathLexer.g4 by ANTLR 4.13.0
+
+
+#include "XPathLexer.h"
+
+
+using namespace antlr4;
+
+
+
+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;
+};
+
+::antlr4::internal::OnceFlag xpathlexerLexerOnceFlag;
+#if ANTLR4_USE_THREAD_LOCAL_CACHE
+static thread_local
+#endif
+XPathLexerStaticData *xpathlexerLexerStaticData = nullptr;
+
+void xpathlexerLexerInitialize() {
+#if ANTLR4_USE_THREAD_LOCAL_CACHE
+  if (xpathlexerLexerStaticData != nullptr) {
+    return;
+  }
+#else
+  assert(xpathlexerLexerStaticData == nullptr);
+#endif
+  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[] = {
+  	4,0,8,50,6,-1,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,
+  	2,7,7,7,1,0,1,0,1,0,1,1,1,1,1,2,1,2,1,3,1,3,1,4,1,4,5,4,29,8,4,10,4,12,
+  	4,32,9,4,1,4,1,4,1,5,1,5,3,5,38,8,5,1,6,1,6,1,7,1,7,5,7,44,8,7,10,7,12,
+  	7,47,9,7,1,7,1,7,1,45,0,8,1,3,3,4,5,5,7,6,9,7,11,0,13,0,15,8,1,0,2,5,
+  	0,48,57,95,95,183,183,768,879,8255,8256,13,0,65,90,97,122,192,214,216,
+  	246,248,767,880,893,895,8191,8204,8205,8304,8591,11264,12271,12289,55295,
+  	63744,64975,65008,65535,50,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,7,1,
+  	0,0,0,0,9,1,0,0,0,0,15,1,0,0,0,1,17,1,0,0,0,3,20,1,0,0,0,5,22,1,0,0,0,
+  	7,24,1,0,0,0,9,26,1,0,0,0,11,37,1,0,0,0,13,39,1,0,0,0,15,41,1,0,0,0,17,
+  	18,5,47,0,0,18,19,5,47,0,0,19,2,1,0,0,0,20,21,5,47,0,0,21,4,1,0,0,0,22,
+  	23,5,42,0,0,23,6,1,0,0,0,24,25,5,33,0,0,25,8,1,0,0,0,26,30,3,13,6,0,27,
+  	29,3,11,5,0,28,27,1,0,0,0,29,32,1,0,0,0,30,28,1,0,0,0,30,31,1,0,0,0,31,
+  	33,1,0,0,0,32,30,1,0,0,0,33,34,6,4,0,0,34,10,1,0,0,0,35,38,3,13,6,0,36,
+  	38,7,0,0,0,37,35,1,0,0,0,37,36,1,0,0,0,38,12,1,0,0,0,39,40,7,1,0,0,40,
+  	14,1,0,0,0,41,45,5,39,0,0,42,44,9,0,0,0,43,42,1,0,0,0,44,47,1,0,0,0,45,
+  	46,1,0,0,0,45,43,1,0,0,0,46,48,1,0,0,0,47,45,1,0,0,0,48,49,5,39,0,0,49,
+  	16,1,0,0,0,4,0,30,37,45,1,1,4,0
+  };
+  staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));
+
+  antlr4::atn::ATNDeserializer deserializer;
+  staticData->atn = deserializer.deserialize(staticData->serializedATN);
+
+  const 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);
+  }
+  xpathlexerLexerStaticData = staticData.release();
+}
+
+}
+
+XPathLexer::XPathLexer(CharStream *input) : Lexer(input) {
+  XPathLexer::initialize();
+  _interpreter = new atn::LexerATNSimulator(this, *xpathlexerLexerStaticData->atn, xpathlexerLexerStaticData->decisionToDFA, xpathlexerLexerStaticData->sharedContextCache);
+}
+
+XPathLexer::~XPathLexer() {
+  delete _interpreter;
+}
+
+std::string XPathLexer::getGrammarFileName() const {
+  return "XPathLexer.g4";
+}
+
+const std::vector<std::string>& XPathLexer::getRuleNames() const {
+  return xpathlexerLexerStaticData->ruleNames;
+}
+
+const std::vector<std::string>& XPathLexer::getChannelNames() const {
+  return xpathlexerLexerStaticData->channelNames;
+}
+
+const std::vector<std::string>& XPathLexer::getModeNames() const {
+  return xpathlexerLexerStaticData->modeNames;
+}
+
+const dfa::Vocabulary& XPathLexer::getVocabulary() const {
+  return xpathlexerLexerStaticData->vocabulary;
+}
+
+antlr4::atn::SerializedATNView XPathLexer::getSerializedATN() const {
+  return xpathlexerLexerStaticData->serializedATN;
+}
+
+const atn::ATN& XPathLexer::getATN() const {
+  return *xpathlexerLexerStaticData->atn;
+}
+
+
+void XPathLexer::action(RuleContext *context, size_t ruleIndex, size_t actionIndex) {
+  switch (ruleIndex) {
+    case 4: IDAction(antlrcpp::downCast<antlr4::RuleContext *>(context), actionIndex); break;
+
+  default:
+    break;
+  }
+}
+
+void XPathLexer::IDAction(antlr4::RuleContext *context, size_t actionIndex) {
+  switch (actionIndex) {
+    case 0: 
+    				if (isupper(getText()[0]))
+    				  setType(TOKEN_REF);
+    				else
+    				  setType(RULE_REF);
+    				 break;
+
+  default:
+    break;
+  }
+}
+
+
+
+void XPathLexer::initialize() {
+#if ANTLR4_USE_THREAD_LOCAL_CACHE
+  xpathlexerLexerInitialize();
+#else
+  ::antlr4::internal::call_once(xpathlexerLexerOnceFlag, xpathlexerLexerInitialize);
+#endif
+}

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

@@ -1,5 +1,5 @@
 
-// Generated from XPathLexer.g4 by ANTLR 4.9.3
+// Generated from XPathLexer.g4 by ANTLR 4.13.0
 
 #pragma once
 
@@ -7,10 +7,12 @@
 #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
   };
 
@@ -18,30 +20,34 @@ public:
 
   ~XPathLexer() override;
 
-  virtual std::string getGrammarFileName() const override;
 
-  virtual const std::vector<std::string>& getRuleNames() const override;
+  std::string getGrammarFileName() const override;
+
+  const std::vector<std::string>& getRuleNames() const override;
 
-  virtual const std::vector<std::string>& getChannelNames() const override;
+  const std::vector<std::string>& getChannelNames() const override;
 
-  virtual const std::vector<std::string>& getModeNames() const override;
+  const std::vector<std::string>& getModeNames() const override;
 
-  virtual const antlr4::dfa::Vocabulary& getVocabulary() const override;
+  const antlr4::dfa::Vocabulary& getVocabulary() const override;
 
-  virtual antlr4::atn::SerializedATNView getSerializedATN() const override;
+  antlr4::atn::SerializedATNView getSerializedATN() const override;
 
-  virtual const antlr4::atn::ATN& getATN() const override;
+  const antlr4::atn::ATN& getATN() const override;
 
-  virtual void action(antlr4::RuleContext *context, size_t ruleIndex, size_t actionIndex) override;
+  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.
+
 };
 

data/ext/{express-parser → express_parser}/express_parser.cpp

@@ -299,13 +299,13 @@ public:
   Object getStart() {
     auto token = ((ParserRuleContext*) orig) -> getStart();
 
-    return detail::To_Ruby<Token*>().convert(token);
+    return detail::To_Ruby<TokenProxy>().convert(TokenProxy(token));
   }
 
   Object getStop() {
     auto token = ((ParserRuleContext*) orig) -> getStop();
 
-    return detail::To_Ruby<Token*>().convert(token);
+    return detail::To_Ruby<TokenProxy>().convert(TokenProxy(token));
   }
 
   Array getChildren() {
@@ -16242,7 +16242,7 @@ public:
     auto result = visit(proxy -> getOriginal());
     try {
       return std::any_cast<Object>(result);
-    } catch(std::bad_cast) {
+    } catch(std::bad_any_cast) {
       return Qnil;
     }
   }
@@ -16251,7 +16251,7 @@ public:
     auto result = visitChildren(proxy -> getOriginal());
     try {
       return std::any_cast<Object>(result);
-    } catch(std::bad_cast) {
+    } catch(std::bad_any_cast) {
       return Qnil;
     }
   }
@@ -18160,12 +18160,12 @@ class ParserProxyExt : public Object {
       return detail::To_Ruby<SyntaxContextProxy>().convert(proxy);
     }
 
-    Array getTokens() {
-      Array a;
+    Object getTokens() {
+      std::vector<TokenProxy> tk;
       for (auto token : tokens -> getTokens()) {
-        a.push(new TokenProxy(token));
+        tk.push_back(TokenProxy(token));
       }
-      return a;
+      return detail::To_Ruby<std::vector<TokenProxy>>().convert(tk);
     }
 
     Object visit(VisitorProxy* visitor) {
@@ -18176,8 +18176,8 @@ class ParserProxyExt : public Object {
 
       try {
         return std::any_cast<Object>(result);
-      } catch(std::bad_cast) {
-       return Qnil;
+      } catch(std::bad_any_cast) {
+        return Qnil;
       }
     }
 
@@ -18418,8 +18418,8 @@ void Init_express_parser() {
   rb_cParser = define_class_under<ParserProxy>(rb_mExpressParser, "Parser")
     .define_singleton_function("parse", &ParserProxy::parse)
     .define_singleton_function("parse_file", &ParserProxy::parseFile)
-    .define_method("syntax", &ParserProxy::syntax, Return().keepAlive())
-    .define_method("visit", &ParserProxy::visit, Return().keepAlive());
+    .define_method("syntax", &ParserProxy::syntax)
+    .define_method("visit", &ParserProxy::visit);
 
   rb_cTokenExt = define_class_under<TokenProxy>(rb_mExpressParser, "TokenExt")
     .define_method("text", &TokenProxy::getText)
@@ -18428,9 +18428,11 @@ void Init_express_parser() {
 
   rb_cParserExt = define_class_under<ParserProxyExt>(rb_mExpressParser, "ParserExt")
     .define_constructor(Constructor<ParserProxyExt, string>())
-    .define_method("syntax", &ParserProxyExt::syntax, Return().keepAlive())
-    .define_method("tokens", &ParserProxyExt::getTokens)
-    .define_method("visit", &ParserProxyExt::visit, Return().keepAlive());
+    .define_method("syntax", &ParserProxyExt::syntax)
+    .define_method("tokens", &ParserProxyExt::getTokens, Return().keepAlive())
+    .define_method("visit", &ParserProxyExt::visit);
+
+  define_vector<std::vector<TokenProxy>>("TokenVector");
 
   rb_cAttributeRefContext = define_class_under<AttributeRefContextProxy, ContextProxy>(rb_mExpressParser, "AttributeRefContext")
     .define_method("attribute_id", &AttributeRefContextProxy::attributeId);

data/ext/{express-parser → express_parser}/extconf.rb

@@ -11,6 +11,7 @@ src_paths = [
   antlr4_src.to_s,
   "#{antlr4_src}/atn",
   "#{antlr4_src}/dfa",
+  "#{antlr4_src}/internal",
   "#{antlr4_src}/misc",
   "#{antlr4_src}/support",
   "#{antlr4_src}/tree",

data/lib/expressir/express/parser.rb

@@ -39,7 +39,6 @@ module Expressir
       # so in this class we keep those C++ structure marked for GC so they are not freed
         @parser = ::ExpressParser::ParserExt.new(file.to_s)
         @parse_tree = @parser.syntax()
-
         @visitor = Visitor.new(@parser.tokens, include_source: include_source)
         @repository = @visitor.visit(@parse_tree)