expressir 1.2.3 → 1.2.6

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

@@ -12,10 +12,11 @@
 #include "atn/RuleTransition.h"
 #include "atn/ATN.h"
 #include "atn/ATNState.h"
+#include "support/StringUtils.h"
+#include "support/Casts.h"
 #include "Parser.h"
 #include "CommonToken.h"
 #include "Vocabulary.h"
-#include "support/StringUtils.h"
 
 #include "DefaultErrorStrategy.h"
 
@@ -106,10 +107,10 @@ void DefaultErrorStrategy::sync(Parser *recognizer) {
   }
 
   switch (s->getStateType()) {
-    case atn::ATNState::BLOCK_START:
-    case atn::ATNState::STAR_BLOCK_START:
-    case atn::ATNState::PLUS_BLOCK_START:
-    case atn::ATNState::STAR_LOOP_ENTRY:
+    case atn::ATNStateType::BLOCK_START:
+    case atn::ATNStateType::STAR_BLOCK_START:
+    case atn::ATNStateType::PLUS_BLOCK_START:
+    case atn::ATNStateType::STAR_LOOP_ENTRY:
       // report error and recover if possible
       if (singleTokenDeletion(recognizer) != nullptr) {
         return;
@@ -117,8 +118,8 @@ void DefaultErrorStrategy::sync(Parser *recognizer) {
 
       throw InputMismatchException(recognizer);
 
-    case atn::ATNState::PLUS_LOOP_BACK:
-    case atn::ATNState::STAR_LOOP_BACK: {
+    case atn::ATNStateType::PLUS_LOOP_BACK:
+    case atn::ATNStateType::STAR_LOOP_BACK: {
       reportUnwantedToken(recognizer);
       misc::IntervalSet expecting = recognizer->getExpectedTokens();
       misc::IntervalSet whatFollowsLoopIterationOrRule = expecting.Or(getErrorRecoverySet(recognizer));
@@ -292,11 +293,13 @@ size_t DefaultErrorStrategy::getSymbolType(Token *symbol) {
 }
 
 std::string DefaultErrorStrategy::escapeWSAndQuote(const std::string &s) const {
-  std::string result = s;
-  antlrcpp::replaceAll(result, "\n", "\\n");
-  antlrcpp::replaceAll(result, "\r","\\r");
-  antlrcpp::replaceAll(result, "\t","\\t");
-  return "'" + result + "'";
+  std::string result;
+  result.reserve(s.size() + 2);
+  result.push_back('\'');
+  antlrcpp::escapeWhitespace(result, s);
+  result.push_back('\'');
+  result.shrink_to_fit();
+  return result;
 }
 
 misc::IntervalSet DefaultErrorStrategy::getErrorRecoverySet(Parser *recognizer) {
@@ -306,7 +309,7 @@ misc::IntervalSet DefaultErrorStrategy::getErrorRecoverySet(Parser *recognizer)
   while (ctx->invokingState != ATNState::INVALID_STATE_NUMBER) {
     // compute what follows who invoked us
     atn::ATNState *invokingState = atn.states[ctx->invokingState];
-    atn::RuleTransition *rt = dynamic_cast<atn::RuleTransition*>(invokingState->transitions[0]);
+    const atn::RuleTransition *rt = downCast<const atn::RuleTransition*>(invokingState->transitions[0].get());
     misc::IntervalSet follow = atn.nextTokens(rt->followState);
     recoverSet.addAll(follow);
 

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

@@ -10,7 +10,7 @@ using namespace antlr4;
 RuntimeException::RuntimeException(const std::string &msg) : std::exception(), _message(msg) {
 }
 
-const char* RuntimeException::what() const NOEXCEPT {
+const char* RuntimeException::what() const noexcept {
   return _message.c_str();
 }
 
@@ -19,7 +19,7 @@ const char* RuntimeException::what() const NOEXCEPT {
 IOException::IOException(const std::string &msg) : std::exception(), _message(msg) {
 }
 
-const char* IOException::what() const NOEXCEPT {
+const char* IOException::what() const noexcept {
   return _message.c_str();
 }
 

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

@@ -16,7 +16,7 @@ namespace antlr4 {
   public:
     RuntimeException(const std::string &msg = "");
 
-    virtual const char* what() const NOEXCEPT override;
+    virtual const char* what() const noexcept override;
   };
 
   class ANTLR4CPP_PUBLIC IllegalStateException : public RuntimeException {
@@ -77,7 +77,7 @@ namespace antlr4 {
   public:
     IOException(const std::string &msg = "");
 
-    virtual const char* what() const NOEXCEPT override;
+    virtual const char* what() const noexcept override;
   };
 
   class ANTLR4CPP_PUBLIC CancellationException : public IllegalStateException {

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

@@ -8,6 +8,7 @@
 #include "atn/PredicateTransition.h"
 #include "atn/ATN.h"
 #include "atn/ATNState.h"
+#include "support/Casts.h"
 #include "support/CPPUtils.h"
 
 #include "FailedPredicateException.h"
@@ -26,10 +27,10 @@ FailedPredicateException::FailedPredicateException(Parser *recognizer, const std
                          recognizer->getInputStream(), recognizer->getContext(), recognizer->getCurrentToken()) {
 
   atn::ATNState *s = recognizer->getInterpreter<atn::ATNSimulator>()->atn.states[recognizer->getState()];
-  atn::Transition *transition = s->transitions[0];
-  if (is<atn::PredicateTransition*>(transition)) {
-    _ruleIndex = static_cast<atn::PredicateTransition *>(transition)->ruleIndex;
-    _predicateIndex = static_cast<atn::PredicateTransition *>(transition)->predIndex;
+  const atn::Transition *transition = s->transitions[0].get();
+  if (transition->getTransitionType() == atn::TransitionType::PREDICATE) {
+    _ruleIndex = downCast<const atn::PredicateTransition&>(*transition).getRuleIndex();
+    _predicateIndex = downCast<const atn::PredicateTransition&>(*transition).getPredIndex();
   } else {
     _ruleIndex = 0;
     _predicateIndex = 0;

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

@@ -15,7 +15,7 @@ namespace antlr4 {
   /// prediction.
   class ANTLR4CPP_PUBLIC FailedPredicateException : public RecognitionException {
   public:
-    FailedPredicateException(Parser *recognizer);
+    explicit FailedPredicateException(Parser *recognizer);
     FailedPredicateException(Parser *recognizer, const std::string &predicate);
     FailedPredicateException(Parser *recognizer, const std::string &predicate, const std::string &message);
 

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

@@ -27,7 +27,7 @@ namespace antlr4 {
   /// </summary>
   class ANTLR4CPP_PUBLIC IntStream {
   public:
-    static const size_t EOF = static_cast<size_t>(-1); // std::numeric_limits<size_t>::max(); doesn't work in VS 2013
+    static constexpr size_t EOF = std::numeric_limits<size_t>::max();
 
     /// The value returned by <seealso cref="#LA LA()"/> when the end of the stream is
     /// reached.

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

@@ -11,7 +11,6 @@
 #include "ANTLRErrorListener.h"
 #include "support/CPPUtils.h"
 #include "CommonToken.h"
-#include "support/StringUtils.h"
 
 #include "Lexer.h"
 
@@ -136,7 +135,7 @@ size_t Lexer::popMode() {
 }
 
 
-Ref<TokenFactory<CommonToken>> Lexer::getTokenFactory() {
+TokenFactory<CommonToken>* Lexer::getTokenFactory() {
   return _factory;
 }
 
@@ -284,7 +283,7 @@ size_t Lexer::getNumberOfSyntaxErrors() {
 void Lexer::InitializeInstanceFields() {
   _syntaxErrors = 0;
   token = nullptr;
-  _factory = CommonTokenFactory::DEFAULT;
+  _factory = CommonTokenFactory::DEFAULT.get();
   tokenStartCharIndex = INVALID_INDEX;
   tokenStartLine = 0;
   tokenStartCharPositionInLine = 0;

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

@@ -18,20 +18,20 @@ 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 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 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;
+    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;
 
     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 +100,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/LexerInterpreter.cpp

@@ -6,7 +6,6 @@
 #include "atn/ATNType.h"
 #include "atn/LexerATNSimulator.h"
 #include "dfa/DFA.h"
-#include "atn/EmptyPredictionContext.h"
 #include "Exceptions.h"
 #include "Vocabulary.h"
 
@@ -14,12 +13,6 @@
 
 using namespace antlr4;
 
-LexerInterpreter::LexerInterpreter(const std::string &grammarFileName, const std::vector<std::string> &tokenNames,
-  const std::vector<std::string> &ruleNames, const std::vector<std::string> &channelNames, const std::vector<std::string> &modeNames,
-  const atn::ATN &atn, CharStream *input)
-  : LexerInterpreter(grammarFileName, dfa::Vocabulary::fromTokenNames(tokenNames), ruleNames, channelNames, modeNames, atn, input) {
-}
-
 LexerInterpreter::LexerInterpreter(const std::string &grammarFileName, const dfa::Vocabulary &vocabulary,
   const std::vector<std::string> &ruleNames, const std::vector<std::string> &channelNames, const std::vector<std::string> &modeNames,
   const atn::ATN &atn, CharStream *input)
@@ -31,10 +24,6 @@ LexerInterpreter::LexerInterpreter(const std::string &grammarFileName, const dfa
     throw IllegalArgumentException("The ATN must be a lexer ATN.");
   }
 
-  for (size_t i = 0; i < atn.maxTokenType; i++) {
-    _tokenNames.push_back(vocabulary.getDisplayName(i));
-  }
-
   for (size_t i = 0; i < atn.getNumberOfDecisions(); ++i) {
     _decisionToDFA.push_back(dfa::DFA(_atn.getDecisionState(i), i));
   }
@@ -54,10 +43,6 @@ std::string LexerInterpreter::getGrammarFileName() const {
   return _grammarFileName;
 }
 
-const std::vector<std::string>& LexerInterpreter::getTokenNames() const {
-  return _tokenNames;
-}
-
 const std::vector<std::string>& LexerInterpreter::getRuleNames() const {
   return _ruleNames;
 }

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

@@ -7,16 +7,13 @@
 
 #include "Lexer.h"
 #include "atn/PredictionContext.h"
+#include "atn/PredictionContextCache.h"
 #include "Vocabulary.h"
 
 namespace antlr4 {
 
   class ANTLR4CPP_PUBLIC LexerInterpreter : public Lexer {
   public:
-    // @deprecated
-    LexerInterpreter(const std::string &grammarFileName, const std::vector<std::string> &tokenNames,
-                     const std::vector<std::string> &ruleNames, const std::vector<std::string> &channelNames,
-                     const std::vector<std::string> &modeNames, const atn::ATN &atn, CharStream *input);
     LexerInterpreter(const std::string &grammarFileName, const dfa::Vocabulary &vocabulary,
                      const std::vector<std::string> &ruleNames, const std::vector<std::string> &channelNames,
                      const std::vector<std::string> &modeNames, const atn::ATN &atn, CharStream *input);
@@ -25,7 +22,6 @@ namespace antlr4 {
 
     virtual const atn::ATN& getATN() const override;
     virtual std::string getGrammarFileName() const override;
-    virtual const std::vector<std::string>& getTokenNames() 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;
@@ -36,8 +32,6 @@ namespace antlr4 {
     const std::string _grammarFileName;
     const atn::ATN &_atn;
 
-    // @deprecated
-    std::vector<std::string> _tokenNames;
     const std::vector<std::string> &_ruleNames;
     const std::vector<std::string> &_channelNames;
     const std::vector<std::string> &_modeNames;

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

@@ -28,10 +28,25 @@
 
 using namespace antlr4;
 using namespace antlr4::atn;
-
 using namespace antlrcpp;
 
-std::map<std::vector<uint16_t>, atn::ATN> Parser::bypassAltsAtnCache;
+namespace {
+
+struct BypassAltsAtnCache final {
+  std::shared_mutex mutex;
+  /// This field maps from the serialized ATN string to the deserialized <seealso cref="ATN"/> with
+  /// bypass alternatives.
+  ///
+  /// <seealso cref= ATNDeserializationOptions#isGenerateRuleBypassTransitions() </seealso>
+  std::map<std::vector<int32_t>, std::unique_ptr<const atn::ATN>, std::less<>> map;
+};
+
+BypassAltsAtnCache* getBypassAltsAtnCache() {
+  static BypassAltsAtnCache* const instance = new BypassAltsAtnCache();
+  return instance;
+}
+
+}
 
 Parser::TraceListener::TraceListener(Parser *outerInstance_) : outerInstance(outerInstance_) {
 }
@@ -190,7 +205,7 @@ void Parser::removeParseListeners() {
 }
 
 void Parser::triggerEnterRuleEvent() {
-  for (auto listener : _parseListeners) {
+  for (auto *listener : _parseListeners) {
     listener->enterEveryRule(_ctx);
     _ctx->enterRule(listener);
   }
@@ -208,31 +223,36 @@ size_t Parser::getNumberOfSyntaxErrors() {
   return _syntaxErrors;
 }
 
-Ref<TokenFactory<CommonToken>> Parser::getTokenFactory() {
+TokenFactory<CommonToken>* Parser::getTokenFactory() {
   return _input->getTokenSource()->getTokenFactory();
 }
 
-
 const atn::ATN& Parser::getATNWithBypassAlts() {
-  std::vector<uint16_t> serializedAtn = getSerializedATN();
+  auto serializedAtn = getSerializedATN();
   if (serializedAtn.empty()) {
     throw UnsupportedOperationException("The current parser does not support an ATN with bypass alternatives.");
   }
-
-  std::lock_guard<std::mutex> lck(_mutex);
-
   // XXX: using the entire serialized ATN as key into the map is a big resource waste.
   //      How large can that thing become?
-  if (bypassAltsAtnCache.find(serializedAtn) == bypassAltsAtnCache.end())
+  auto *cache = getBypassAltsAtnCache();
   {
-    atn::ATNDeserializationOptions deserializationOptions;
-    deserializationOptions.setGenerateRuleBypassTransitions(true);
-
-    atn::ATNDeserializer deserializer(deserializationOptions);
-    bypassAltsAtnCache[serializedAtn] = deserializer.deserialize(serializedAtn);
+    std::shared_lock<std::shared_mutex> lock(cache->mutex);
+    auto existing = cache->map.find(serializedAtn);
+    if (existing != cache->map.end()) {
+      return *existing->second;
+    }
   }
 
-  return bypassAltsAtnCache[serializedAtn];
+  std::unique_lock<std::shared_mutex> lock(cache->mutex);
+  auto existing = cache->map.find(serializedAtn);
+  if (existing != cache->map.end()) {
+    return *existing->second;
+  }
+  atn::ATNDeserializationOptions deserializationOptions;
+  deserializationOptions.setGenerateRuleBypassTransitions(true);
+  atn::ATNDeserializer deserializer(deserializationOptions);
+  auto atn = deserializer.deserialize(serializedAtn);
+  return *cache->map.insert(std::make_pair(std::vector<int32_t>(serializedAtn.begin(), serializedAtn.end()), std::move(atn))).first->second;
 }
 
 tree::pattern::ParseTreePattern Parser::compileParseTreePattern(const std::string &pattern, int patternRuleIndex) {
@@ -307,14 +327,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);
         }
       }
@@ -328,8 +348,7 @@ void Parser::addContextToParseTree() {
   if (_ctx->parent == nullptr)
     return;
 
-  ParserRuleContext *parent = dynamic_cast<ParserRuleContext *>(_ctx->parent);
-  parent->addChild(_ctx);
+  downCast<ParserRuleContext*>(_ctx->parent)->addChild(_ctx);
 }
 
 void Parser::enterRule(ParserRuleContext *localctx, size_t state, size_t /*ruleIndex*/) {
@@ -357,7 +376,7 @@ void Parser::exitRule() {
     triggerExitRuleEvent();
   }
   setState(_ctx->invokingState);
-  _ctx = dynamic_cast<ParserRuleContext *>(_ctx->parent);
+  _ctx = downCast<ParserRuleContext*>(_ctx->parent);
 }
 
 void Parser::enterOuterAlt(ParserRuleContext *localctx, size_t altNum) {
@@ -367,7 +386,7 @@ void Parser::enterOuterAlt(ParserRuleContext *localctx, size_t altNum) {
   // that is previous child of parse tree
   if (_buildParseTrees && _ctx != localctx) {
     if (_ctx->parent != nullptr) {
-      ParserRuleContext *parent = dynamic_cast<ParserRuleContext *>(_ctx->parent);
+      ParserRuleContext *parent = downCast<ParserRuleContext*>(_ctx->parent);
       parent->removeLastChild();
       parent->addChild(localctx);
     }
@@ -423,7 +442,7 @@ void Parser::unrollRecursionContexts(ParserRuleContext *parentctx) {
   if (_parseListeners.size() > 0) {
     while (_ctx != parentctx) {
       triggerExitRuleEvent();
-      _ctx = dynamic_cast<ParserRuleContext *>(_ctx->parent);
+      _ctx = downCast<ParserRuleContext*>(_ctx->parent);
     }
   } else {
     _ctx = parentctx;
@@ -446,7 +465,7 @@ ParserRuleContext* Parser::getInvokingContext(size_t ruleIndex) {
     }
     if (p->parent == nullptr)
       break;
-    p = dynamic_cast<ParserRuleContext *>(p->parent);
+    p = downCast<ParserRuleContext*>(p->parent);
   }
   return nullptr;
 }
@@ -484,13 +503,13 @@ bool Parser::isExpectedToken(size_t symbol) {
 
   while (ctx && ctx->invokingState != ATNState::INVALID_STATE_NUMBER && following.contains(Token::EPSILON)) {
     atn::ATNState *invokingState = atn.states[ctx->invokingState];
-    atn::RuleTransition *rt = static_cast<atn::RuleTransition*>(invokingState->transitions[0]);
+    const atn::RuleTransition *rt = static_cast<const atn::RuleTransition*>(invokingState->transitions[0].get());
     following = atn.nextTokens(rt->followState);
     if (following.contains(symbol)) {
       return true;
     }
 
-    ctx = dynamic_cast<ParserRuleContext *>(ctx->parent);
+    ctx = downCast<ParserRuleContext*>(ctx->parent);
   }
 
   if (following.contains(Token::EPSILON) && symbol == EOF) {
@@ -543,9 +562,10 @@ std::vector<std::string> Parser::getRuleInvocationStack(RuleContext *p) {
     } else {
       stack.push_back(ruleNames[ruleIndex]);
     }
-    if (p->parent == nullptr)
+    if (!RuleContext::is(run->parent)) {
       break;
-    run = dynamic_cast<RuleContext *>(run->parent);
+    }
+    run = downCast<RuleContext*>(run->parent);
   }
   return stack;
 }
@@ -589,12 +609,12 @@ std::string Parser::getSourceName() {
 }
 
 atn::ParseInfo Parser::getParseInfo() const {
-  atn::ProfilingATNSimulator *interp = getInterpreter<atn::ProfilingATNSimulator>();
-  return atn::ParseInfo(interp);
+  atn::ParserATNSimulator *simulator = getInterpreter<atn::ParserATNSimulator>();
+  return atn::ParseInfo(dynamic_cast<atn::ProfilingATNSimulator*>(simulator));
 }
 
 void Parser::setProfile(bool profile) {
-  atn::ParserATNSimulator *interp = getInterpreter<atn::ProfilingATNSimulator>();
+  atn::ParserATNSimulator *interp = getInterpreter<atn::ParserATNSimulator>();
   atn::PredictionMode saveMode = interp != nullptr ? interp->getPredictionMode() : atn::PredictionMode::LL;
   if (profile) {
     if (!is<atn::ProfilingATNSimulator *>(interp)) {

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>
@@ -448,12 +448,6 @@ namespace antlr4 {
     tree::ParseTreeTracker _tracker;
 
   private:
-    /// This field maps from the serialized ATN string to the deserialized <seealso cref="ATN"/> with
-    /// bypass alternatives.
-    ///
-    /// <seealso cref= ATNDeserializationOptions#isGenerateRuleBypassTransitions() </seealso>
-    static std::map<std::vector<uint16_t>, atn::ATN> bypassAltsAtnCache;
-
     /// When setTrace(true) is called, a reference to the
     /// TraceListener is stored here so it can be easily removed in a
     /// later call to setTrace(false). The listener itself is