expressir 1.2.4 → 1.2.5

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

@@ -12,9 +12,13 @@ namespace atn {
 
   class ANTLR4CPP_PUBLIC StarLoopbackState final : public ATNState {
   public:
-    StarLoopEntryState *getLoopEntryState();
+    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::STAR_LOOP_BACK; }
 
-    virtual size_t getStateType() override;
+    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
+
+    StarLoopbackState() : ATNState(ATNStateType::STAR_LOOP_BACK) {}
+
+    StarLoopEntryState *getLoopEntryState() const;
   };
 
 } // namespace atn

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

@@ -12,9 +12,12 @@ namespace atn {
 
   /// The Tokens rule start state linking to each lexer rule start state.
   class ANTLR4CPP_PUBLIC TokensStartState final : public DecisionState {
-
   public:
-    virtual size_t getStateType() override;
+    static bool is(const ATNState &atnState) { return atnState.getStateType() == ATNStateType::TOKEN_START; }
+
+    static bool is(const ATNState *atnState) { return atnState != nullptr && is(*atnState); }
+
+    TokensStartState() : DecisionState(ATNStateType::TOKEN_START) {}
   };
 
 } // namespace atn

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

@@ -10,14 +10,9 @@
 
 using namespace antlr4;
 using namespace antlr4::atn;
-
 using namespace antlrcpp;
 
-const std::vector<std::string> Transition::serializationNames = {
-  "INVALID", "EPSILON", "RANGE", "RULE", "PREDICATE", "ATOM", "ACTION", "SET", "NOT_SET", "WILDCARD", "PRECEDENCE"
-};
-
-Transition::Transition(ATNState *target) {
+Transition::Transition(TransitionType transitionType, ATNState *target) : _transitionType(transitionType) {
   if (target == nullptr) {
     throw NullPointerException("target cannot be null.");
   }
@@ -25,9 +20,6 @@ Transition::Transition(ATNState *target) {
   this->target = target;
 }
 
-Transition::~Transition() {
-}
-
 bool Transition::isEpsilon() const {
   return false;
 }

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

@@ -6,6 +6,7 @@
 #pragma once
 
 #include "misc/IntervalSet.h"
+#include "atn/TransitionType.h"
 
 namespace antlr4 {
 namespace atn {
@@ -25,33 +26,13 @@ namespace atn {
   /// </summary>
   class ANTLR4CPP_PUBLIC Transition {
   public:
-    // constants for serialization
-    enum SerializationType {
-      EPSILON = 1,
-      RANGE = 2,
-      RULE = 3,
-      PREDICATE = 4, // e.g., {isType(input.LT(1))}?
-      ATOM = 5,
-      ACTION = 6,
-      SET = 7, // ~(A|B) or ~atom, wildcard, which convert to next 2
-      NOT_SET = 8,
-      WILDCARD = 9,
-      PRECEDENCE = 10,
-    };
-
-    static const std::vector<std::string> serializationNames;
-
     /// The target of this transition.
     // ml: this is a reference into the ATN.
     ATNState *target;
 
-    virtual ~Transition();
+    virtual ~Transition() = default;
 
-  protected:
-    Transition(ATNState *target);
-
-  public:
-    virtual SerializationType getSerializationType() const = 0;
+    TransitionType getTransitionType() const { return _transitionType; }
 
     /**
      * Determines if the transition is an "epsilon" transition.
@@ -70,7 +51,15 @@ namespace atn {
 
     Transition(Transition const&) = delete;
     Transition& operator=(Transition const&) = delete;
+
+  protected:
+    Transition(TransitionType transitionType, ATNState *target);
+
+  private:
+    const TransitionType _transitionType;
   };
 
+  using ConstTransitionPtr = std::unique_ptr<const Transition>;
+
 } // namespace atn
 } // namespace antlr4

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

@@ -0,0 +1,27 @@
+#include "atn/TransitionType.h"
+
+std::string antlr4::atn::transitionTypeName(TransitionType transitionType) {
+  switch (transitionType) {
+    case TransitionType::EPSILON:
+      return "EPSILON";
+    case TransitionType::RANGE:
+      return "RANGE";
+    case TransitionType::RULE:
+      return "RULE";
+    case TransitionType::PREDICATE:
+      return "PREDICATE";
+    case TransitionType::ATOM:
+      return "ATOM";
+    case TransitionType::ACTION:
+      return "ACTION";
+    case TransitionType::SET:
+      return "SET";
+    case TransitionType::NOT_SET:
+      return "NOT_SET";
+    case TransitionType::WILDCARD:
+      return "WILDCARD";
+    case TransitionType::PRECEDENCE:
+      return "PRECEDENCE";
+  }
+  return "UNKNOWN";
+}

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

@@ -0,0 +1,33 @@
+/* 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 <string>
+
+#include "antlr4-common.h"
+
+namespace antlr4 {
+namespace atn {
+
+  // Constants for transition serialization.
+  enum class TransitionType : size_t {
+    EPSILON = 1,
+    RANGE = 2,
+    RULE = 3,
+    PREDICATE = 4, // e.g., {isType(input.LT(1))}?
+    ATOM = 5,
+    ACTION = 6,
+    SET = 7, // ~(A|B) or ~atom, wildcard, which convert to next 2
+    NOT_SET = 8,
+    WILDCARD = 9,
+    PRECEDENCE = 10,
+  };
+
+  ANTLR4CPP_PUBLIC std::string transitionTypeName(TransitionType transitionType);
+
+} // namespace atn
+} // namespace antlr4

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

@@ -9,11 +9,7 @@
 
 using namespace antlr4::atn;
 
-WildcardTransition::WildcardTransition(ATNState *target) : Transition(target) {
-}
-
-Transition::SerializationType WildcardTransition::getSerializationType() const {
-  return WILDCARD;
+WildcardTransition::WildcardTransition(ATNState *target) : Transition(TransitionType::WILDCARD, target) {
 }
 
 bool WildcardTransition::matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const {

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

@@ -12,9 +12,11 @@ namespace atn {
 
   class ANTLR4CPP_PUBLIC WildcardTransition final : public Transition {
   public:
-    WildcardTransition(ATNState *target);
+    static bool is(const Transition &transition) { return transition.getTransitionType() == TransitionType::WILDCARD; }
 
-    virtual SerializationType getSerializationType() const override;
+    static bool is(const Transition *transition) { return transition != nullptr && is(*transition); }
+
+    explicit WildcardTransition(ATNState *target);
 
     virtual bool matches(size_t symbol, size_t minVocabSymbol, size_t maxVocabSymbol) const override;
 

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

@@ -8,6 +8,7 @@
 #include "support/CPPUtils.h"
 #include "atn/StarLoopEntryState.h"
 #include "atn/ATNConfigSet.h"
+#include "support/Casts.h"
 
 #include "dfa/DFA.h"
 
@@ -22,8 +23,8 @@ DFA::DFA(atn::DecisionState *atnStartState, size_t decision)
   : atnStartState(atnStartState), s0(nullptr), decision(decision) {
 
   _precedenceDfa = false;
-  if (is<atn::StarLoopEntryState *>(atnStartState)) {
-    if (static_cast<atn::StarLoopEntryState *>(atnStartState)->isPrecedenceDecision) {
+  if (atn::StarLoopEntryState::is(atnStartState)) {
+    if (downCast<atn::StarLoopEntryState*>(atnStartState)->isPrecedenceDecision) {
       _precedenceDfa = true;
       s0 = new DFAState(std::unique_ptr<atn::ATNConfigSet>(new atn::ATNConfigSet()));
       s0->isAcceptState = false;
@@ -32,13 +33,12 @@ DFA::DFA(atn::DecisionState *atnStartState, size_t decision)
   }
 }
 
-DFA::DFA(DFA &&other) : atnStartState(other.atnStartState), decision(other.decision) {
+DFA::DFA(DFA &&other) : atnStartState(other.atnStartState), s0(other.s0), decision(other.decision) {
   // Source states are implicitly cleared by the move.
   states = std::move(other.states);
 
   other.atnStartState = nullptr;
   other.decision = 0;
-  s0 = other.s0;
   other.s0 = nullptr;
   _precedenceDfa = other._precedenceDfa;
   other._precedenceDfa = false;
@@ -52,8 +52,9 @@ DFA::~DFA() {
     delete state;
   }
 
-  if (!s0InList)
+  if (!s0InList) {
     delete s0;
+  }
 }
 
 bool DFA::isPrecedenceDfa() const {
@@ -70,7 +71,7 @@ DFAState* DFA::getPrecedenceStartState(int precedence) const {
   return iterator->second;
 }
 
-void DFA::setPrecedenceStartState(int precedence, DFAState *startState, SingleWriteMultipleReadLock &lock) {
+void DFA::setPrecedenceStartState(int precedence, DFAState *startState) {
   if (!isPrecedenceDfa()) {
     throw IllegalStateException("Only precedence DFAs may contain a precedence start state.");
   }
@@ -79,11 +80,7 @@ void DFA::setPrecedenceStartState(int precedence, DFAState *startState, SingleWr
     return;
   }
 
-  {
-    lock.writeLock();
-    s0->edges[precedence] = startState;
-    lock.writeUnlock();
-  }
+  s0->edges[precedence] = startState;
 }
 
 std::vector<DFAState *> DFA::getStates() const {
@@ -98,15 +95,6 @@ std::vector<DFAState *> DFA::getStates() const {
   return result;
 }
 
-std::string DFA::toString(const std::vector<std::string> &tokenNames) {
-  if (s0 == nullptr) {
-    return "";
-  }
-  DFASerializer serializer(this, tokenNames);
-
-  return serializer.toString();
-}
-
 std::string DFA::toString(const Vocabulary &vocabulary) const {
   if (s0 == nullptr) {
     return "";
@@ -116,7 +104,7 @@ std::string DFA::toString(const Vocabulary &vocabulary) const {
   return serializer.toString();
 }
 
-std::string DFA::toLexerString() {
+std::string DFA::toLexerString() const {
   if (s0 == nullptr) {
     return "";
   }

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

@@ -7,29 +7,38 @@
 
 #include "dfa/DFAState.h"
 
-namespace antlrcpp {
-  class SingleWriteMultipleReadLock;
-}
-
 namespace antlr4 {
 namespace dfa {
 
-  class ANTLR4CPP_PUBLIC DFA {
+  class ANTLR4CPP_PUBLIC DFA final {
+  private:
+    struct DFAStateHasher final {
+      size_t operator()(const DFAState *dfaState) const {
+        return dfaState->hashCode();
+      }
+    };
+
+    struct DFAStateComparer final {
+      bool operator()(const DFAState *lhs, const DFAState *rhs) const {
+        return lhs == rhs || *lhs == *rhs;
+      }
+    };
+
   public:
     /// A set of all DFA states. Use a map so we can get old state back.
     /// Set only allows you to see if it's there.
 
     /// From which ATN state did we create this DFA?
     atn::DecisionState *atnStartState;
-    std::unordered_set<DFAState *, DFAState::Hasher, DFAState::Comparer> states; // States are owned by this class.
+    std::unordered_set<DFAState*, DFAStateHasher, DFAStateComparer> states; // States are owned by this class.
     DFAState *s0;
     size_t decision;
 
-    DFA(atn::DecisionState *atnStartState);
+    explicit DFA(atn::DecisionState *atnStartState);
     DFA(atn::DecisionState *atnStartState, size_t decision);
     DFA(const DFA &other) = delete;
     DFA(DFA &&other);
-    virtual ~DFA();
+    ~DFA();
 
     /**
      * Gets whether this DFA is a precedence DFA. Precedence DFAs use a special
@@ -66,18 +75,14 @@ namespace dfa {
      * @throws IllegalStateException if this is not a precedence DFA.
      * @see #isPrecedenceDfa()
      */
-    void setPrecedenceStartState(int precedence, DFAState *startState, antlrcpp::SingleWriteMultipleReadLock &lock);
+    void setPrecedenceStartState(int precedence, DFAState *startState);
 
     /// Return a list of all states in this DFA, ordered by state number.
-    virtual std::vector<DFAState *> getStates() const;
+    std::vector<DFAState *> getStates() const;
 
-    /**
-     * @deprecated Use {@link #toString(Vocabulary)} instead.
-     */
-    virtual std::string toString(const std::vector<std::string>& tokenNames);
     std::string toString(const Vocabulary &vocabulary) const;
 
-    virtual std::string toLexerString();
+    std::string toLexerString() const;
 
   private:
     /**

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

@@ -10,16 +10,9 @@
 
 using namespace antlr4::dfa;
 
-DFASerializer::DFASerializer(const DFA *dfa, const std::vector<std::string>& tokenNames)
-  : DFASerializer(dfa, Vocabulary::fromTokenNames(tokenNames)) {
-}
-
 DFASerializer::DFASerializer(const DFA *dfa, const Vocabulary &vocabulary) : _dfa(dfa), _vocabulary(vocabulary) {
 }
 
-DFASerializer::~DFASerializer() {
-}
-
 std::string DFASerializer::toString() const {
   if (_dfa->s0 == nullptr) {
     return "";
@@ -55,7 +48,7 @@ std::string DFASerializer::getStateString(DFAState *s) const {
     if (!s->predicates.empty()) {
       std::string buf;
       for (size_t i = 0; i < s->predicates.size(); i++) {
-        buf.append(s->predicates[i]->toString());
+        buf.append(s->predicates[i].toString());
       }
       return baseStateStr + "=>" + buf;
     } else {

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

@@ -13,15 +13,15 @@ namespace dfa {
   /// A DFA walker that knows how to dump them to serialized strings.
   class ANTLR4CPP_PUBLIC DFASerializer {
   public:
-    DFASerializer(const DFA *dfa, const std::vector<std::string>& tnames);
     DFASerializer(const DFA *dfa, const Vocabulary &vocabulary);
-    virtual ~DFASerializer();
 
-    virtual std::string toString() const;
+    virtual ~DFASerializer() = default;
+
+    std::string toString() const;
 
   protected:
     virtual std::string getEdgeLabel(size_t i) const;
-    virtual std::string getStateString(DFAState *s) const;
+    std::string getStateString(DFAState *s) const;
 
   private:
     const DFA *_dfa;

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

@@ -13,41 +13,11 @@
 using namespace antlr4::dfa;
 using namespace antlr4::atn;
 
-DFAState::PredPrediction::PredPrediction(const Ref<SemanticContext> &pred, int alt) : pred(pred) {
-  InitializeInstanceFields();
-  this->alt = alt;
-}
-
-DFAState::PredPrediction::~PredPrediction() {
-}
-
-std::string DFAState::PredPrediction::toString() {
+std::string DFAState::PredPrediction::toString() const {
   return std::string("(") + pred->toString() + ", " + std::to_string(alt) + ")";
 }
 
-void DFAState::PredPrediction::InitializeInstanceFields() {
-  alt = 0;
-}
-
-DFAState::DFAState() {
-  InitializeInstanceFields();
-}
-
-DFAState::DFAState(int state) : DFAState() {
-  stateNumber = state;
-}
-
-DFAState::DFAState(std::unique_ptr<ATNConfigSet> configs_) : DFAState() {
-  configs = std::move(configs_);
-}
-
-DFAState::~DFAState() {
-  for (auto *predicate : predicates) {
-    delete predicate;
-  }
-}
-
-std::set<size_t> DFAState::getAltSet() {
+std::set<size_t> DFAState::getAltSet() const {
   std::set<size_t> alts;
   if (configs != nullptr) {
     for (size_t i = 0; i < configs->size(); i++) {
@@ -58,22 +28,18 @@ std::set<size_t> DFAState::getAltSet() {
 }
 
 size_t DFAState::hashCode() const {
-  size_t hash = misc::MurmurHash::initialize(7);
-  hash = misc::MurmurHash::update(hash, configs->hashCode());
-  hash = misc::MurmurHash::finish(hash, 1);
-  return hash;
+  return configs != nullptr ? configs->hashCode() : 0;
 }
 
-bool DFAState::operator == (const DFAState &o) const {
-  // compare set of ATN configurations in this set with other
-  if (this == &o) {
+bool DFAState::equals(const DFAState &other) const {
+  if (this == std::addressof(other)) {
     return true;
   }
-
-  return *configs == *o.configs;
+  return configs == other.configs ||
+         (configs != nullptr && other.configs != nullptr && *configs == *other.configs);
 }
 
-std::string DFAState::toString() {
+std::string DFAState::toString() const {
   std::stringstream ss;
   ss << stateNumber;
   if (configs) {
@@ -83,7 +49,7 @@ std::string DFAState::toString() {
     ss << " => ";
     if (!predicates.empty()) {
       for (size_t i = 0; i < predicates.size(); i++) {
-        ss << predicates[i]->toString();
+        ss << predicates[i].toString();
       }
     } else {
       ss << prediction;
@@ -91,10 +57,3 @@ std::string DFAState::toString() {
   }
   return ss.str();
 }
-
-void DFAState::InitializeInstanceFields() {
-  stateNumber = -1;
-  isAcceptState = false;
-  prediction = 0;
-  requiresFullContext = false;
-}

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

@@ -7,6 +7,8 @@
 
 #include "antlr4-common.h"
 
+#include "atn/ATNConfigSet.h"
+
 namespace antlr4 {
 namespace dfa {
 
@@ -35,23 +37,25 @@ namespace dfa {
   ///  but with different ATN contexts (with same or different alts)
   ///  meaning that state was reached via a different set of rule invocations.
   /// </summary>
-  class ANTLR4CPP_PUBLIC DFAState {
+  class ANTLR4CPP_PUBLIC DFAState final {
   public:
-    class PredPrediction {
+    struct ANTLR4CPP_PUBLIC PredPrediction final {
     public:
-      Ref<atn::SemanticContext> pred; // never null; at least SemanticContext.NONE
+      Ref<const atn::SemanticContext> pred; // never null; at least SemanticContext.NONE
       int alt;
 
-      PredPrediction(const Ref<atn::SemanticContext> &pred, int alt);
-      virtual ~PredPrediction();
+      PredPrediction() = delete;
 
-      virtual std::string toString();
+      PredPrediction(const PredPrediction&) = default;
+      PredPrediction(PredPrediction&&) = default;
 
-    private:
-      void InitializeInstanceFields();
-    };
+      PredPrediction(Ref<const atn::SemanticContext> pred, int alt) : pred(std::move(pred)), alt(alt) {}
 
-    int stateNumber;
+      PredPrediction& operator=(const PredPrediction&) = default;
+      PredPrediction& operator=(PredPrediction&&) = default;
+
+      std::string toString() const;
+    };
 
     std::unique_ptr<atn::ATNConfigSet> configs;
 
@@ -59,24 +63,14 @@ namespace dfa {
     ///  <seealso cref="Token#EOF"/> maps to {@code edges[0]}.
     // ml: this is a sparse list, so we use a map instead of a vector.
     //     Watch out: we no longer have the -1 offset, as it isn't needed anymore.
-    std::unordered_map<size_t, DFAState *> edges;
-
-    bool isAcceptState;
+    std::unordered_map<size_t, DFAState*> edges;
 
     /// if accept state, what ttype do we match or alt do we predict?
     /// This is set to <seealso cref="ATN#INVALID_ALT_NUMBER"/> when <seealso cref="#predicates"/>{@code !=null} or
     /// <seealso cref="#requiresFullContext"/>.
-    size_t prediction;
-
-    Ref<atn::LexerActionExecutor> lexerActionExecutor;
+    size_t prediction = 0;
 
-    /// <summary>
-    /// Indicates that this state was created during SLL prediction that
-    /// discovered a conflict between the configurations in the state. Future
-    /// <seealso cref="ParserATNSimulator#execATN"/> invocations immediately jumped doing
-    /// full context prediction if this field is true.
-    /// </summary>
-    bool requiresFullContext;
+    Ref<const atn::LexerActionExecutor> lexerActionExecutor;
 
     /// <summary>
     /// During SLL parsing, this is a list of predicates associated with the
@@ -91,21 +85,34 @@ namespace dfa {
     /// <p/>
     ///  This list is computed by <seealso cref="ParserATNSimulator#predicateDFAState"/>.
     /// </summary>
-    std::vector<PredPrediction *> predicates;
+    std::vector<PredPrediction> predicates;
+
+    int stateNumber = -1;
+
+    bool isAcceptState = false;
+
+    /// <summary>
+    /// Indicates that this state was created during SLL prediction that
+    /// discovered a conflict between the configurations in the state. Future
+    /// <seealso cref="ParserATNSimulator#execATN"/> invocations immediately jumped doing
+    /// full context prediction if this field is true.
+    /// </summary>
+    bool requiresFullContext = false;
 
     /// Map a predicate to a predicted alternative.
-    DFAState();
-    DFAState(int state);
-    DFAState(std::unique_ptr<atn::ATNConfigSet> configs);
-    virtual ~DFAState();
+    DFAState() = default;
+
+    explicit DFAState(int stateNumber) : stateNumber(stateNumber) {}
+
+    explicit DFAState(std::unique_ptr<atn::ATNConfigSet> configs) : configs(std::move(configs)) {}
 
     /// <summary>
     /// Get the set of all alts mentioned by all ATN configurations in this
     ///  DFA state.
     /// </summary>
-    virtual std::set<size_t> getAltSet();
+    std::set<size_t> getAltSet() const;
 
-    virtual size_t hashCode() const;
+    size_t hashCode() const;
 
     /// Two DFAState instances are equal if their ATN configuration sets
     /// are the same. This method is used to see if a state already exists.
@@ -118,27 +125,29 @@ namespace dfa {
     /// ParserATNSimulator#addDFAState we need to know if any other state
     /// exists that has this exact set of ATN configurations. The
     /// stateNumber is irrelevant.
-    bool operator == (const DFAState &o) const;
+    bool equals(const DFAState &other) const;
 
-    virtual std::string toString();
+    std::string toString() const;
+  };
 
-    struct Hasher
-    {
-      size_t operator()(DFAState *k) const {
-        return k->hashCode();
-      }
-    };
+  inline bool operator==(const DFAState &lhs, const DFAState &rhs) {
+    return lhs.equals(rhs);
+  }
 
-    struct Comparer {
-      bool operator()(DFAState *lhs, DFAState *rhs) const
-      {
-        return *lhs == *rhs;
-      }
-    };
+  inline bool operator!=(const DFAState &lhs, const DFAState &rhs) {
+    return !operator==(lhs, rhs);
+  }
+
+}  // namespace dfa
+}  // namespace antlr4
+
+namespace std {
 
-  private:
-    void InitializeInstanceFields();
+  template <>
+  struct hash<::antlr4::dfa::DFAState> {
+    size_t operator()(const ::antlr4::dfa::DFAState &dfaState) const {
+      return dfaState.hashCode();
+    }
   };
 
-} // namespace atn
-} // namespace antlr4
+}  // namespace std