expressir 1.2.4 → 1.2.5

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

@@ -0,0 +1,71 @@
+// 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 <cstddef>
+#include <cstdint>
+#include <limits>
+
+#include "antlr4-common.h"
+
+namespace antlr4 {
+namespace atn {
+
+  class ANTLR4CPP_PUBLIC PredictionContextMergeCacheOptions final {
+  public:
+    PredictionContextMergeCacheOptions() = default;
+
+    size_t getMaxSize() const { return _maxSize; }
+
+    bool hasMaxSize() const { return getMaxSize() != std::numeric_limits<size_t>::max(); }
+
+    PredictionContextMergeCacheOptions& setMaxSize(size_t maxSize) {
+      _maxSize = maxSize;
+      return *this;
+    }
+
+    size_t getClearEveryN() const {
+      return _clearEveryN;
+    }
+
+    bool hasClearEveryN() const { return getClearEveryN() != 0; }
+
+    PredictionContextMergeCacheOptions& setClearEveryN(uint64_t clearEveryN) {
+      _clearEveryN = clearEveryN;
+      return *this;
+    }
+
+    PredictionContextMergeCacheOptions& neverClear() {
+      return setClearEveryN(0);
+    }
+
+  private:
+    size_t _maxSize = std::numeric_limits<size_t>::max();
+    uint64_t _clearEveryN = 1;
+  };
+
+}  // namespace atn
+}  // namespace antlr4

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

@@ -0,0 +1,21 @@
+/* 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 atn {
+
+  enum class PredictionContextType : size_t {
+    SINGLETON = 1,
+    ARRAY = 2,
+  };
+
+} // namespace atn
+} // namespace antlr4

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

@@ -62,7 +62,7 @@ bool PredictionModeClass::hasSLLConflictTerminatingPrediction(PredictionMode mod
     // dup configs, tossing out semantic predicates
     ATNConfigSet dup(true);
     for (auto &config : configs->configs) {
-      Ref<ATNConfig> c = std::make_shared<ATNConfig>(config, SemanticContext::NONE);
+      Ref<ATNConfig> c = std::make_shared<ATNConfig>(*config, SemanticContext::NONE);
       dup.add(c);
     }
     std::vector<antlrcpp::BitSet> altsets = getConflictingAltSubsets(&dup);
@@ -73,8 +73,8 @@ bool PredictionModeClass::hasSLLConflictTerminatingPrediction(PredictionMode mod
 }
 
 bool PredictionModeClass::hasConfigInRuleStopState(ATNConfigSet *configs) {
-  for (auto &c : configs->configs) {
-    if (is<RuleStopState *>(c->state)) {
+  for (const auto &config : configs->configs) {
+    if (RuleStopState::is(config->state)) {
       return true;
     }
   }
@@ -83,8 +83,8 @@ bool PredictionModeClass::hasConfigInRuleStopState(ATNConfigSet *configs) {
 }
 
 bool PredictionModeClass::allConfigsInRuleStopStates(ATNConfigSet *configs) {
-  for (auto &config : configs->configs) {
-    if (!is<RuleStopState*>(config->state)) {
+  for (const auto &config : configs->configs) {
+    if (!RuleStopState::is(config->state)) {
       return false;
     }
   }
@@ -142,7 +142,7 @@ size_t PredictionModeClass::getUniqueAlt(const std::vector<antlrcpp::BitSet>& al
 
 antlrcpp::BitSet PredictionModeClass::getAlts(const std::vector<antlrcpp::BitSet>& altsets) {
   antlrcpp::BitSet all;
-  for (antlrcpp::BitSet alts : altsets) {
+  for (const auto &alts : altsets) {
     all |= alts;
   }
 
@@ -151,43 +151,44 @@ antlrcpp::BitSet PredictionModeClass::getAlts(const std::vector<antlrcpp::BitSet
 
 antlrcpp::BitSet PredictionModeClass::getAlts(ATNConfigSet *configs) {
   antlrcpp::BitSet alts;
-  for (auto &config : configs->configs) {
+  for (const auto &config : configs->configs) {
     alts.set(config->alt);
   }
   return alts;
 }
 
 std::vector<antlrcpp::BitSet> PredictionModeClass::getConflictingAltSubsets(ATNConfigSet *configs) {
-  std::unordered_map<ATNConfig *, antlrcpp::BitSet, AltAndContextConfigHasher, AltAndContextConfigComparer> configToAlts;
+  std::unordered_map<ATNConfig*, antlrcpp::BitSet, AltAndContextConfigHasher, AltAndContextConfigComparer> configToAlts;
   for (auto &config : configs->configs) {
     configToAlts[config.get()].set(config->alt);
   }
   std::vector<antlrcpp::BitSet> values;
-  for (auto it : configToAlts) {
-    values.push_back(it.second);
+  values.reserve(configToAlts.size());
+  for (const auto &pair : configToAlts) {
+    values.push_back(pair.second);
   }
   return values;
 }
 
-std::map<ATNState*, antlrcpp::BitSet> PredictionModeClass::getStateToAltMap(ATNConfigSet *configs) {
-  std::map<ATNState*, antlrcpp::BitSet> m;
-  for (auto &c : configs->configs) {
+std::unordered_map<ATNState*, antlrcpp::BitSet> PredictionModeClass::getStateToAltMap(ATNConfigSet *configs) {
+  std::unordered_map<ATNState*, antlrcpp::BitSet> m;
+  for (const auto &c : configs->configs) {
     m[c->state].set(c->alt);
   }
   return m;
 }
 
 bool PredictionModeClass::hasStateAssociatedWithOneAlt(ATNConfigSet *configs) {
-  std::map<ATNState*, antlrcpp::BitSet> x = getStateToAltMap(configs);
-  for (std::map<ATNState*, antlrcpp::BitSet>::iterator it = x.begin(); it != x.end(); it++){
-    if (it->second.count() == 1) return true;
+  auto x = getStateToAltMap(configs);
+  for (const auto &pair : x){
+    if (pair.second.count() == 1) return true;
   }
   return false;
 }
 
 size_t PredictionModeClass::getSingleViableAlt(const std::vector<antlrcpp::BitSet>& altsets) {
   antlrcpp::BitSet viableAlts;
-  for (antlrcpp::BitSet alts : altsets) {
+  for (const auto &alts : altsets) {
     size_t minAlt = alts.nextSetBit(0);
 
     viableAlts.set(minAlt);

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

@@ -425,7 +425,7 @@ namespace atn {
     /// cref="ATNConfig#alt alt"/>
     /// </pre>
     /// </summary>
-    static std::map<ATNState*, antlrcpp::BitSet> getStateToAltMap(ATNConfigSet *configs);
+    static std::unordered_map<ATNState*, antlrcpp::BitSet> getStateToAltMap(ATNConfigSet *configs);
 
     static bool hasStateAssociatedWithOneAlt(ATNConfigSet *configs);
 

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

@@ -112,10 +112,10 @@ std::unique_ptr<ATNConfigSet> ProfilingATNSimulator::computeReachSet(ATNConfigSe
   return reachConfigs;
 }
 
-bool ProfilingATNSimulator::evalSemanticContext(Ref<SemanticContext> const& pred, ParserRuleContext *parserCallStack,
+bool ProfilingATNSimulator::evalSemanticContext(Ref<const SemanticContext> const& pred, ParserRuleContext *parserCallStack,
                                                 size_t alt, bool fullCtx) {
   bool result = ParserATNSimulator::evalSemanticContext(pred, parserCallStack, alt, fullCtx);
-  if (!(std::dynamic_pointer_cast<SemanticContext::PrecedencePredicate>(pred) != nullptr)) {
+  if (!(std::dynamic_pointer_cast<const SemanticContext::PrecedencePredicate>(pred) != nullptr)) {
     bool fullContext = _llStopIndex >= 0;
     int stopIndex = fullContext ? _llStopIndex : _sllStopIndex;
     _decisions[_currentDecision].predicateEvals.push_back(

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

@@ -13,7 +13,7 @@ namespace atn {
 
   class ANTLR4CPP_PUBLIC ProfilingATNSimulator : public ParserATNSimulator {
   public:
-    ProfilingATNSimulator(Parser *parser);
+    explicit ProfilingATNSimulator(Parser *parser);
 
     virtual size_t adaptivePredict(TokenStream *input, size_t decision, ParserRuleContext *outerContext) override;
 
@@ -46,7 +46,7 @@ namespace atn {
     virtual dfa::DFAState* getExistingTargetState(dfa::DFAState *previousD, size_t t) override;
     virtual dfa::DFAState* computeTargetState(dfa::DFA &dfa, dfa::DFAState *previousD, size_t t) override;
     virtual std::unique_ptr<ATNConfigSet> computeReachSet(ATNConfigSet *closure, size_t t, bool fullCtx) override;
-    virtual bool evalSemanticContext(Ref<SemanticContext> const& pred, ParserRuleContext *parserCallStack,
+    virtual bool evalSemanticContext(Ref<const SemanticContext> const& pred, ParserRuleContext *parserCallStack,
                                      size_t alt, bool fullCtx) override;
     virtual void reportAttemptingFullContext(dfa::DFA &dfa, const antlrcpp::BitSet &conflictingAlts, ATNConfigSet *configs,
                                              size_t startIndex, size_t stopIndex) override;

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

@@ -10,11 +10,7 @@
 using namespace antlr4;
 using namespace antlr4::atn;
 
-RangeTransition::RangeTransition(ATNState *target, size_t from, size_t to) : Transition(target), from(from), to(to) {
-}
-
-Transition::SerializationType RangeTransition::getSerializationType() const {
-  return RANGE;
+RangeTransition::RangeTransition(ATNState *target, size_t from, size_t to) : Transition(TransitionType::RANGE, target), from(from), to(to) {
 }
 
 misc::IntervalSet RangeTransition::label() const {

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

@@ -12,13 +12,15 @@ namespace atn {
 
   class ANTLR4CPP_PUBLIC RangeTransition final : public Transition {
   public:
+    static bool is(const Transition &transition) { return transition.getTransitionType() == TransitionType::RANGE; }
+
+    static bool is(const Transition *transition) { return transition != nullptr && is(*transition); }
+
     const size_t from;
     const size_t to;
 
     RangeTransition(ATNState *target, size_t from, size_t to);
 
-    virtual SerializationType getSerializationType() const override;
-
     virtual misc::IntervalSet label() const override;
     virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;
 

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

@@ -12,13 +12,14 @@ namespace atn {
 
   class ANTLR4CPP_PUBLIC RuleStartState final : public ATNState {
   public:
-    RuleStartState();
+    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::RULE_START; }
+
+    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
 
     RuleStopState *stopState = nullptr;
     bool isLeftRecursiveRule = false;
 
-    virtual size_t getStateType() override;
-
+    RuleStartState() : ATNState(ATNStateType::RULE_START) {}
   };
 
 } // namespace atn

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

@@ -15,10 +15,12 @@ namespace atn {
   /// references to all calls to this rule to compute FOLLOW sets for
   /// error handling.
   class ANTLR4CPP_PUBLIC RuleStopState final : public ATNState {
-
   public:
-    virtual size_t getStateType() override;
+    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::RULE_STOP; }
+
+    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
 
+    RuleStopState() : ATNState(ATNStateType::RULE_STOP) {}
   };
 
 } // namespace atn

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

@@ -13,14 +13,10 @@ RuleTransition::RuleTransition(RuleStartState *ruleStart, size_t ruleIndex, ATNS
 }
 
 RuleTransition::RuleTransition(RuleStartState *ruleStart, size_t ruleIndex, int precedence, ATNState *followState)
-  : Transition(ruleStart), ruleIndex(ruleIndex), precedence(precedence) {
+  : Transition(TransitionType::RULE, ruleStart), ruleIndex(ruleIndex), precedence(precedence) {
   this->followState = followState;
 }
 
-Transition::SerializationType RuleTransition::getSerializationType() const {
-  return RULE;
-}
-
 bool RuleTransition::isEpsilon() const {
   return true;
 }

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

@@ -10,8 +10,12 @@
 namespace antlr4 {
 namespace atn {
 
-  class ANTLR4CPP_PUBLIC RuleTransition : public Transition {
+  class ANTLR4CPP_PUBLIC RuleTransition final : public Transition {
   public:
+    static bool is(const Transition &transition) { return transition.getTransitionType() == TransitionType::RULE; }
+
+    static bool is(const Transition *transition) { return transition != nullptr && is(*transition); }
+
     /// Ptr to the rule definition object for this rule ref.
     const size_t ruleIndex; // no Rule object at runtime
 
@@ -28,8 +32,6 @@ namespace atn {
     RuleTransition(RuleTransition const&) = delete;
     RuleTransition& operator=(RuleTransition const&) = delete;
 
-    virtual SerializationType getSerializationType() const override;
-
     virtual bool isEpsilon() const override;
     virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;