expressir 1.2.4 → 1.2.7

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

@@ -9,6 +9,8 @@
 #include "dfa/DFAState.h"
 #include "atn/ATNSimulator.h"
 #include "atn/PredictionContext.h"
+#include "atn/PredictionContextMergeCache.h"
+#include "atn/ParserATNSimulatorOptions.h"
 #include "SemanticContext.h"
 #include "atn/ATNConfig.h"
 
@@ -251,14 +253,18 @@ namespace atn {
     ParserATNSimulator(Parser *parser, const ATN &atn, std::vector<dfa::DFA> &decisionToDFA,
                        PredictionContextCache &sharedContextCache);
 
+    ParserATNSimulator(Parser *parser, const ATN &atn, std::vector<dfa::DFA> &decisionToDFA,
+                       PredictionContextCache &sharedContextCache,
+                       const ParserATNSimulatorOptions &options);
+
     virtual void reset() override;
     virtual void clearDFA() override;
     virtual size_t adaptivePredict(TokenStream *input, size_t decision, ParserRuleContext *outerContext);
-    
+
     static const bool TURN_OFF_LR_LOOP_ENTRY_BRANCH_OPT;
 
     std::vector<dfa::DFA> &decisionToDFA;
-    
+
     /** Implements first-edge (loop entry) elimination as an optimization
      *  during closure operations.  See antlr/antlr4#1398.
      *
@@ -348,14 +354,14 @@ namespace atn {
     bool canDropLoopEntryEdgeInLeftRecursiveRule(ATNConfig *config) const;
     virtual std::string getRuleName(size_t index);
 
-    virtual Ref<ATNConfig> precedenceTransition(Ref<ATNConfig> const& config, PrecedencePredicateTransition *pt,
+    virtual Ref<ATNConfig> precedenceTransition(Ref<ATNConfig> const& config, const PrecedencePredicateTransition *pt,
                                                 bool collectPredicates, bool inContext, bool fullCtx);
 
     void setPredictionMode(PredictionMode newMode);
     PredictionMode getPredictionMode();
 
     Parser* getParser();
-    
+
     virtual std::string getTokenName(size_t t);
 
     virtual std::string getLookaheadName(TokenStream *input);
@@ -366,7 +372,7 @@ namespace atn {
     ///  "dead" code for a bit.
     /// </summary>
     virtual void dumpDeadEndConfigs(NoViableAltException &nvae);
-    
+
   protected:
     Parser *const parser;
 
@@ -380,13 +386,14 @@ namespace atn {
     /// also be examined during cache lookup.
     /// </summary>
     PredictionContextMergeCache mergeCache;
+    size_t _mergeCacheCounter = 0;
 
     // LAME globals to avoid parameters!!!!! I need these down deep in predTransition
     TokenStream *_input;
     size_t _startIndex;
     ParserRuleContext *_outerContext;
     dfa::DFA *_dfa; // Reference into the decisionToDFA vector.
-    
+
     /// <summary>
     /// Performs ATN simulation to compute a predicted alternative based
     ///  upon the remaining input, but also updates the DFA cache to avoid
@@ -646,13 +653,13 @@ namespace atn {
      */
     std::unique_ptr<ATNConfigSet> applyPrecedenceFilter(ATNConfigSet *configs);
 
-    virtual ATNState *getReachableTarget(Transition *trans, size_t ttype);
+    virtual ATNState *getReachableTarget(const Transition *trans, size_t ttype);
 
-    virtual std::vector<Ref<SemanticContext>> getPredsForAmbigAlts(const antlrcpp::BitSet &ambigAlts,
+    virtual std::vector<Ref<const SemanticContext>> getPredsForAmbigAlts(const antlrcpp::BitSet &ambigAlts,
                                                                    ATNConfigSet *configs, size_t nalts);
 
-    virtual std::vector<dfa::DFAState::PredPrediction*> getPredicatePredictions(const antlrcpp::BitSet &ambigAlts,
-                                                                                std::vector<Ref<SemanticContext>> const& altToPred);
+    std::vector<dfa::DFAState::PredPrediction> getPredicatePredictions(const antlrcpp::BitSet &ambigAlts,
+                                                                       const std::vector<Ref<const SemanticContext>> &altToPred);
 
     /**
      * This method is used to improve the localization of error messages by
@@ -724,8 +731,8 @@ namespace atn {
     ///  then we stop at the first predicate that evaluates to true. This
     ///  includes pairs with null predicates.
     /// </summary>
-    virtual antlrcpp::BitSet evalSemanticContext(std::vector<dfa::DFAState::PredPrediction*> predPredictions,
-                                                 ParserRuleContext *outerContext, bool complete);
+    antlrcpp::BitSet evalSemanticContext(const std::vector<dfa::DFAState::PredPrediction> &predPredictions,
+                                         ParserRuleContext *outerContext, bool complete);
 
     /**
      * Evaluate a semantic context within a specific parser context.
@@ -757,7 +764,7 @@ namespace atn {
      *
      * @since 4.3
      */
-    virtual bool evalSemanticContext(Ref<SemanticContext> const& pred, ParserRuleContext *parserCallStack,
+    virtual bool evalSemanticContext(Ref<const SemanticContext> const& pred, ParserRuleContext *parserCallStack,
                                      size_t alt, bool fullCtx);
 
     /* TODO: If we are doing predicates, there is no point in pursuing
@@ -771,19 +778,19 @@ namespace atn {
 
     virtual void closureCheckingStopState(Ref<ATNConfig> const& config, ATNConfigSet *configs, ATNConfig::Set &closureBusy,
                                           bool collectPredicates, bool fullCtx, int depth, bool treatEofAsEpsilon);
-    
+
     /// Do the actual work of walking epsilon edges.
     virtual void closure_(Ref<ATNConfig> const& config, ATNConfigSet *configs, ATNConfig::Set &closureBusy,
                           bool collectPredicates, bool fullCtx, int depth, bool treatEofAsEpsilon);
-    
-    virtual Ref<ATNConfig> getEpsilonTarget(Ref<ATNConfig> const& config, Transition *t, bool collectPredicates,
+
+    virtual Ref<ATNConfig> getEpsilonTarget(Ref<ATNConfig> const& config, const Transition *t, bool collectPredicates,
                                             bool inContext, bool fullCtx, bool treatEofAsEpsilon);
-    virtual Ref<ATNConfig> actionTransition(Ref<ATNConfig> const& config, ActionTransition *t);
+    virtual Ref<ATNConfig> actionTransition(Ref<ATNConfig> const& config, const ActionTransition *t);
 
-    virtual Ref<ATNConfig> predTransition(Ref<ATNConfig> const& config, PredicateTransition *pt, bool collectPredicates,
+    virtual Ref<ATNConfig> predTransition(Ref<ATNConfig> const& config, const PredicateTransition *pt, bool collectPredicates,
                                           bool inContext, bool fullCtx);
 
-    virtual Ref<ATNConfig> ruleTransition(Ref<ATNConfig> const& config, RuleTransition *t);
+    virtual Ref<ATNConfig> ruleTransition(Ref<ATNConfig> const& config, const RuleTransition *t);
 
     /**
      * Gets a {@link BitSet} containing the alternatives in {@code configs}

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

@@ -0,0 +1,50 @@
+// 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 "atn/PredictionContextMergeCacheOptions.h"
+
+namespace antlr4 {
+namespace atn {
+
+  class ANTLR4CPP_PUBLIC ParserATNSimulatorOptions final {
+  public:
+    ParserATNSimulatorOptions& setPredictionContextMergeCacheOptions(
+        PredictionContextMergeCacheOptions predictionContextMergeCacheOptions) {
+      _predictionContextMergeCacheOptions = std::move(predictionContextMergeCacheOptions);
+      return *this;
+    }
+
+    const PredictionContextMergeCacheOptions& getPredictionContextMergeCacheOptions() const {
+      return _predictionContextMergeCacheOptions;
+    }
+
+  private:
+    PredictionContextMergeCacheOptions _predictionContextMergeCacheOptions;
+  };
+
+}  // namespace atn
+}  // namespace antlr4

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

@@ -16,9 +16,13 @@ namespace atn {
   /// real decision-making note for {@code A+}.
   class ANTLR4CPP_PUBLIC PlusBlockStartState final : public BlockStartState {
   public:
+    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::PLUS_BLOCK_START; }
+
+    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
+
     PlusLoopbackState *loopBackState = nullptr;
 
-    virtual size_t getStateType() override;
+    PlusBlockStartState() : BlockStartState(ATNStateType::PLUS_BLOCK_START) {}
   };
 
 } // namespace atn

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

@@ -13,9 +13,12 @@ namespace atn {
   /// Decision state for {@code A+} and {@code (A|B)+}. It has two transitions:
   /// one to the loop back to start of the block and one to exit.
   class ANTLR4CPP_PUBLIC PlusLoopbackState final : public DecisionState {
-
   public:
-    virtual size_t getStateType() override;
+    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::PLUS_LOOP_BACK; }
+
+    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
+
+    PlusLoopbackState() : DecisionState(ATNStateType::PLUS_LOOP_BACK) {}
   };
 
 } // namespace atn

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

@@ -8,12 +8,7 @@
 using namespace antlr4::atn;
 
 PrecedencePredicateTransition::PrecedencePredicateTransition(ATNState *target, int precedence)
-  : AbstractPredicateTransition(target), precedence(precedence) {
-}
-
-Transition::SerializationType PrecedencePredicateTransition::getSerializationType() const {
-  return PRECEDENCE;
-}
+  : Transition(TransitionType::PRECEDENCE, target), _predicate(std::make_shared<SemanticContext::PrecedencePredicate>(precedence)) {}
 
 bool PrecedencePredicateTransition::isEpsilon() const {
   return true;
@@ -23,10 +18,6 @@ bool PrecedencePredicateTransition::matches(size_t /*symbol*/, size_t /*minVocab
   return false;
 }
 
-Ref<SemanticContext::PrecedencePredicate> PrecedencePredicateTransition::getPredicate() const {
-  return std::make_shared<SemanticContext::PrecedencePredicate>(precedence);
-}
-
 std::string PrecedencePredicateTransition::toString() const {
-  return "PRECEDENCE " + Transition::toString() + " { precedence: " + std::to_string(precedence) + " }";
+  return "PRECEDENCE " + Transition::toString() + " { precedence: " + std::to_string(getPrecedence()) + " }";
 }

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

@@ -5,24 +5,30 @@
 
 #pragma once
 
-#include "atn/AbstractPredicateTransition.h"
-#include "SemanticContext.h"
+#include "atn/Transition.h"
+#include "atn/SemanticContext.h"
 
 namespace antlr4 {
 namespace atn {
 
-  class ANTLR4CPP_PUBLIC PrecedencePredicateTransition final : public AbstractPredicateTransition {
+  class ANTLR4CPP_PUBLIC PrecedencePredicateTransition final : public Transition {
   public:
-    const int precedence;
+    static bool is(const Transition &transition) { return transition.getTransitionType() == TransitionType::PRECEDENCE; }
+
+    static bool is(const Transition *transition) { return transition != nullptr && is(*transition); }
 
     PrecedencePredicateTransition(ATNState *target, int precedence);
 
-    virtual SerializationType getSerializationType() const override;
-    virtual bool isEpsilon() const override;
-    virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;
-    Ref<SemanticContext::PrecedencePredicate> getPredicate() const;
-    virtual std::string toString() const override;
+    int getPrecedence() const { return _predicate->precedence; }
+
+    bool isEpsilon() const override;
+    bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;
+    std::string toString() const override;
+
+    const Ref<const SemanticContext::PrecedencePredicate>& getPredicate() const { return _predicate; }
 
+  private:
+    const std::shared_ptr<const SemanticContext::PrecedencePredicate> _predicate;
   };
 
 } // namespace atn

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

@@ -11,7 +11,7 @@ using namespace antlr4;
 using namespace antlr4::atn;
 
 PredicateEvalInfo::PredicateEvalInfo(size_t decision, TokenStream *input, size_t startIndex, size_t stopIndex,
-  Ref<SemanticContext> const& semctx, bool evalResult, size_t predictedAlt, bool fullCtx)
+  Ref<const SemanticContext> semctx, bool evalResult, size_t predictedAlt, bool fullCtx)
   : DecisionEventInfo(decision, nullptr, input, startIndex, stopIndex, fullCtx),
-    semctx(semctx), predictedAlt(predictedAlt), evalResult(evalResult) {
+    semctx(std::move(semctx)), predictedAlt(predictedAlt), evalResult(evalResult) {
 }

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

@@ -20,7 +20,7 @@ namespace atn {
   class ANTLR4CPP_PUBLIC PredicateEvalInfo : public DecisionEventInfo {
   public:
     /// The semantic context which was evaluated.
-    const Ref<SemanticContext> semctx;
+    const Ref<const SemanticContext> semctx;
 
     /// <summary>
     /// The alternative number for the decision which is guarded by the semantic
@@ -55,7 +55,7 @@ namespace atn {
     /// <seealso cref= ParserATNSimulator#evalSemanticContext(SemanticContext, ParserRuleContext, int, boolean) </seealso>
     /// <seealso cref= SemanticContext#eval(Recognizer, RuleContext) </seealso>
     PredicateEvalInfo(size_t decision, TokenStream *input, size_t startIndex, size_t stopIndex,
-                      Ref<SemanticContext> const& semctx, bool evalResult, size_t predictedAlt, bool fullCtx);
+                      Ref<const SemanticContext> semctx, bool evalResult, size_t predictedAlt, bool fullCtx);
   };
 
 } // namespace atn

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

@@ -7,12 +7,8 @@
 
 using namespace antlr4::atn;
 
-PredicateTransition::PredicateTransition(ATNState *target, size_t ruleIndex, size_t predIndex, bool isCtxDependent) : AbstractPredicateTransition(target), ruleIndex(ruleIndex), predIndex(predIndex), isCtxDependent(isCtxDependent) {
-}
-
-Transition::SerializationType PredicateTransition::getSerializationType() const {
-  return PREDICATE;
-}
+PredicateTransition::PredicateTransition(ATNState *target, size_t ruleIndex, size_t predIndex, bool isCtxDependent)
+    : Transition(TransitionType::PREDICATE, target), _predicate(std::make_shared<SemanticContext::Predicate>(ruleIndex, predIndex, isCtxDependent)) {}
 
 bool PredicateTransition::isEpsilon() const {
   return true;
@@ -22,13 +18,7 @@ bool PredicateTransition::matches(size_t /*symbol*/, size_t /*minVocabSymbol*/,
   return false;
 }
 
-Ref<SemanticContext::Predicate> PredicateTransition::getPredicate() const {
-  return std::make_shared<SemanticContext::Predicate>(ruleIndex, predIndex, isCtxDependent);
-}
-
 std::string PredicateTransition::toString() const {
-  return "PREDICATE " + Transition::toString() + " { ruleIndex: " + std::to_string(ruleIndex) +
-    ", predIndex: " + std::to_string(predIndex) + ", isCtxDependent: " + std::to_string(isCtxDependent) + " }";
-
-  // Generate and add a predicate context here?
+  return "PREDICATE " + Transition::toString() + " { ruleIndex: " + std::to_string(getRuleIndex()) +
+    ", predIndex: " + std::to_string(getPredIndex()) + ", isCtxDependent: " + std::to_string(isCtxDependent()) + " }";
 }

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

@@ -5,8 +5,8 @@
 
 #pragma once
 
-#include "atn/AbstractPredicateTransition.h"
-#include "SemanticContext.h"
+#include "atn/Transition.h"
+#include "atn/SemanticContext.h"
 
 namespace antlr4 {
 namespace atn {
@@ -16,23 +16,34 @@ namespace atn {
   ///  In the ATN, labels will always be exactly one predicate, but the DFA
   ///  may have to combine a bunch of them as it collects predicates from
   ///  multiple ATN configurations into a single DFA state.
-  class ANTLR4CPP_PUBLIC PredicateTransition final : public AbstractPredicateTransition {
+  class ANTLR4CPP_PUBLIC PredicateTransition final : public Transition {
   public:
-    const size_t ruleIndex;
-    const size_t predIndex;
-    const bool isCtxDependent; // e.g., $i ref in pred
+    static bool is(const Transition &transition) { return transition.getTransitionType() == TransitionType::PREDICATE; }
+
+    static bool is(const Transition *transition) { return transition != nullptr && is(*transition); }
 
     PredicateTransition(ATNState *target, size_t ruleIndex, size_t predIndex, bool isCtxDependent);
 
-    virtual SerializationType getSerializationType() const override;
+    size_t getRuleIndex() const {
+      return _predicate->ruleIndex;
+    }
+
+    size_t getPredIndex() const {
+      return _predicate->predIndex;
+    }
 
-    virtual bool isEpsilon() const override;
-    virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;
+    bool isCtxDependent() const {
+      return _predicate->isCtxDependent;
+    }
 
-    Ref<SemanticContext::Predicate> getPredicate() const;
+    bool isEpsilon() const override;
+    bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;
+    std::string toString() const override;
 
-    virtual std::string toString() const override;
+    const Ref<const SemanticContext::Predicate>& getPredicate() const { return _predicate; }
 
+  private:
+    const std::shared_ptr<const SemanticContext::Predicate> _predicate;
   };
 
 } // namespace atn