expressir 1.2.4 → 1.2.5

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

@@ -15,26 +15,31 @@
 using namespace antlr4::atn;
 using namespace antlrcpp;
 
-ATNConfigSet::ATNConfigSet(bool fullCtx) : fullCtx(fullCtx) {
-  InitializeInstanceFields();
-}
+namespace {
 
-ATNConfigSet::ATNConfigSet(const Ref<ATNConfigSet> &old) : ATNConfigSet(old->fullCtx) {
-  addAll(old);
-  uniqueAlt = old->uniqueAlt;
-  conflictingAlts = old->conflictingAlts;
-  hasSemanticContext = old->hasSemanticContext;
-  dipsIntoOuterContext = old->dipsIntoOuterContext;
 }
 
-ATNConfigSet::~ATNConfigSet() {
+ATNConfigSet::ATNConfigSet() : ATNConfigSet(true) {}
+
+ATNConfigSet::ATNConfigSet(const ATNConfigSet &other)
+    : fullCtx(other.fullCtx), _configLookup(other._configLookup.bucket_count(), ATNConfigHasher{this}, ATNConfigComparer{this}) {
+  addAll(other);
+  uniqueAlt = other.uniqueAlt;
+  conflictingAlts = other.conflictingAlts;
+  hasSemanticContext = other.hasSemanticContext;
+  dipsIntoOuterContext = other.dipsIntoOuterContext;
 }
 
+ATNConfigSet::ATNConfigSet(bool fullCtx)
+    : fullCtx(fullCtx), _configLookup(0, ATNConfigHasher{this}, ATNConfigComparer{this}) {}
+
 bool ATNConfigSet::add(const Ref<ATNConfig> &config) {
   return add(config, nullptr);
 }
 
 bool ATNConfigSet::add(const Ref<ATNConfig> &config, PredictionContextMergeCache *mergeCache) {
+  assert(config);
+
   if (_readonly) {
     throw IllegalStateException("This set is readonly");
   }
@@ -45,10 +50,9 @@ bool ATNConfigSet::add(const Ref<ATNConfig> &config, PredictionContextMergeCache
     dipsIntoOuterContext = true;
   }
 
-  size_t hash = getHash(config.get());
-  ATNConfig *existing = _configLookup[hash];
-  if (existing == nullptr) {
-    _configLookup[hash] = config.get();
+  auto existing = _configLookup.find(config.get());
+  if (existing == _configLookup.end()) {
+    _configLookup.insert(config.get());
     _cachedHashCode = 0;
     configs.push_back(config); // track order here
 
@@ -57,32 +61,33 @@ bool ATNConfigSet::add(const Ref<ATNConfig> &config, PredictionContextMergeCache
 
   // a previous (s,i,pi,_), merge with it and save result
   bool rootIsWildcard = !fullCtx;
-  Ref<PredictionContext> merged = PredictionContext::merge(existing->context, config->context, rootIsWildcard, mergeCache);
+  Ref<const PredictionContext> merged = PredictionContext::merge((*existing)->context, config->context, rootIsWildcard, mergeCache);
   // no need to check for existing.context, config.context in cache
   // since only way to create new graphs is "call rule" and here. We
   // cache at both places.
-  existing->reachesIntoOuterContext = std::max(existing->reachesIntoOuterContext, config->reachesIntoOuterContext);
+  (*existing)->reachesIntoOuterContext = std::max((*existing)->reachesIntoOuterContext, config->reachesIntoOuterContext);
 
   // make sure to preserve the precedence filter suppression during the merge
   if (config->isPrecedenceFilterSuppressed()) {
-    existing->setPrecedenceFilterSuppressed(true);
+    (*existing)->setPrecedenceFilterSuppressed(true);
   }
 
-  existing->context = merged; // replace context; no need to alt mapping
+  (*existing)->context = std::move(merged); // replace context; no need to alt mapping
 
   return true;
 }
 
-bool ATNConfigSet::addAll(const Ref<ATNConfigSet> &other) {
-  for (auto &c : other->configs) {
+bool ATNConfigSet::addAll(const ATNConfigSet &other) {
+  for (const auto &c : other.configs) {
     add(c);
   }
   return false;
 }
 
-std::vector<ATNState*> ATNConfigSet::getStates() {
+std::vector<ATNState*> ATNConfigSet::getStates() const {
   std::vector<ATNState*> states;
-  for (auto c : configs) {
+  states.reserve(configs.size());
+  for (const auto &c : configs) {
     states.push_back(c->state);
   }
   return states;
@@ -97,17 +102,18 @@ std::vector<ATNState*> ATNConfigSet::getStates() {
  * @since 4.3
  */
 
-BitSet ATNConfigSet::getAlts() {
+BitSet ATNConfigSet::getAlts() const {
   BitSet alts;
-  for (ATNConfig config : configs) {
-    alts.set(config.alt);
+  for (const auto &config : configs) {
+    alts.set(config->alt);
   }
   return alts;
 }
 
-std::vector<Ref<SemanticContext>> ATNConfigSet::getPredicates() {
-  std::vector<Ref<SemanticContext>> preds;
-  for (auto c : configs) {
+std::vector<Ref<const SemanticContext>> ATNConfigSet::getPredicates() const {
+  std::vector<Ref<const SemanticContext>> preds;
+  preds.reserve(configs.size());
+  for (const auto &c : configs) {
     if (c->semanticContext != SemanticContext::NONE) {
       preds.push_back(c->semanticContext);
     }
@@ -115,23 +121,25 @@ std::vector<Ref<SemanticContext>> ATNConfigSet::getPredicates() {
   return preds;
 }
 
-Ref<ATNConfig> ATNConfigSet::get(size_t i) const {
+const Ref<ATNConfig>& ATNConfigSet::get(size_t i) const {
   return configs[i];
 }
 
 void ATNConfigSet::optimizeConfigs(ATNSimulator *interpreter) {
+  assert(interpreter);
+
   if (_readonly) {
     throw IllegalStateException("This set is readonly");
   }
   if (_configLookup.empty())
     return;
 
-  for (auto &config : configs) {
+  for (const auto &config : configs) {
     config->context = interpreter->getCachedContext(config->context);
   }
 }
 
-bool ATNConfigSet::operator == (const ATNConfigSet &other) {
+bool ATNConfigSet::equals(const ATNConfigSet &other) const {
   if (&other == this) {
     return true;
   }
@@ -147,22 +155,23 @@ bool ATNConfigSet::operator == (const ATNConfigSet &other) {
   return Arrays::equals(configs, other.configs);
 }
 
-size_t ATNConfigSet::hashCode() {
-  if (!isReadonly() || _cachedHashCode == 0) {
-    _cachedHashCode = 1;
-    for (auto &i : configs) {
-      _cachedHashCode = 31 * _cachedHashCode + i->hashCode(); // Same as Java's list hashCode impl.
+size_t ATNConfigSet::hashCode() const {
+  size_t cachedHashCode = _cachedHashCode.load(std::memory_order_relaxed);
+  if (!isReadonly() || cachedHashCode == 0) {
+    cachedHashCode = 1;
+    for (const auto &i : configs) {
+      cachedHashCode = 31 * cachedHashCode + i->hashCode(); // Same as Java's list hashCode impl.
     }
+    _cachedHashCode.store(cachedHashCode, std::memory_order_relaxed);
   }
-
-  return _cachedHashCode;
+  return cachedHashCode;
 }
 
-size_t ATNConfigSet::size() {
+size_t ATNConfigSet::size() const {
   return configs.size();
 }
 
-bool ATNConfigSet::isEmpty() {
+bool ATNConfigSet::isEmpty() const {
   return configs.empty();
 }
 
@@ -175,16 +184,16 @@ void ATNConfigSet::clear() {
   _configLookup.clear();
 }
 
-bool ATNConfigSet::isReadonly() {
+bool ATNConfigSet::isReadonly() const {
   return _readonly;
 }
 
 void ATNConfigSet::setReadonly(bool readonly) {
   _readonly = readonly;
-  _configLookup.clear();
+  LookupContainer(0, ATNConfigHasher{this}, ATNConfigComparer{this}).swap(_configLookup);
 }
 
-std::string ATNConfigSet::toString() {
+std::string ATNConfigSet::toString() const {
   std::stringstream ss;
   ss << "[";
   for (size_t i = 0; i < configs.size(); i++) {
@@ -210,19 +219,14 @@ std::string ATNConfigSet::toString() {
   return ss.str();
 }
 
-size_t ATNConfigSet::getHash(ATNConfig *c) {
+size_t ATNConfigSet::hashCode(const ATNConfig &other) const {
   size_t hashCode = 7;
-  hashCode = 31 * hashCode + c->state->stateNumber;
-  hashCode = 31 * hashCode + c->alt;
-  hashCode = 31 * hashCode + c->semanticContext->hashCode();
+  hashCode = 31 * hashCode + other.state->stateNumber;
+  hashCode = 31 * hashCode + other.alt;
+  hashCode = 31 * hashCode + other.semanticContext->hashCode();
   return hashCode;
 }
 
-void ATNConfigSet::InitializeInstanceFields() {
-  uniqueAlt = 0;
-  hasSemanticContext = false;
-  dipsIntoOuterContext = false;
-
-  _readonly = false;
-  _cachedHashCode = 0;
+bool ATNConfigSet::equals(const ATNConfig &lhs, const ATNConfig &rhs) const {
+  return lhs.state->stateNumber == rhs.state->stateNumber && lhs.alt == rhs.alt && *lhs.semanticContext == *rhs.semanticContext;
 }

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

@@ -5,8 +5,11 @@
 
 #pragma once
 
+#include <cassert>
+
 #include "support/BitSet.h"
 #include "atn/PredictionContext.h"
+#include "atn/ATNConfig.h"
 
 namespace antlr4 {
 namespace atn {
@@ -20,7 +23,7 @@ namespace atn {
 
     // TODO: these fields make me pretty uncomfortable but nice to pack up info together, saves recomputation
     // TODO: can we track conflicts as they are added to save scanning configs later?
-    size_t uniqueAlt;
+    size_t uniqueAlt = 0;
 
     /** Currently this is only used when we detect SLL conflict; this does
      *  not necessarily represent the ambiguous alternatives. In fact,
@@ -31,20 +34,25 @@ namespace atn {
 
     // Used in parser and lexer. In lexer, it indicates we hit a pred
     // while computing a closure operation.  Don't make a DFA state from this.
-    bool hasSemanticContext;
-    bool dipsIntoOuterContext;
+    bool hasSemanticContext = false;
+    bool dipsIntoOuterContext = false;
 
     /// Indicates that this configuration set is part of a full context
     /// LL prediction. It will be used to determine how to merge $. With SLL
     /// it's a wildcard whereas it is not for LL context merge.
-    const bool fullCtx;
+    const bool fullCtx = true;
+
+    ATNConfigSet();
+
+    ATNConfigSet(const ATNConfigSet &other);
 
-    ATNConfigSet(bool fullCtx = true);
-    ATNConfigSet(const Ref<ATNConfigSet> &old);
+    ATNConfigSet(ATNConfigSet&&) = delete;
 
-    virtual ~ATNConfigSet();
+    explicit ATNConfigSet(bool fullCtx);
 
-    virtual bool add(const Ref<ATNConfig> &config);
+    virtual ~ATNConfigSet() = default;
+
+    bool add(const Ref<ATNConfig> &config);
 
     /// <summary>
     /// Adding a new config means merging contexts with existing configs for
@@ -56,9 +64,11 @@ namespace atn {
     /// This method updates <seealso cref="#dipsIntoOuterContext"/> and
     /// <seealso cref="#hasSemanticContext"/> when necessary.
     /// </summary>
-    virtual bool add(const Ref<ATNConfig> &config, PredictionContextMergeCache *mergeCache);
+    bool add(const Ref<ATNConfig> &config, PredictionContextMergeCache *mergeCache);
+
+    bool addAll(const ATNConfigSet &other);
 
-    virtual std::vector<ATNState *> getStates();
+    std::vector<ATNState*> getStates() const;
 
     /**
      * Gets the complete set of represented alternatives for the configuration
@@ -68,43 +78,79 @@ namespace atn {
      *
      * @since 4.3
      */
-    antlrcpp::BitSet getAlts();
-    virtual std::vector<Ref<SemanticContext>> getPredicates();
+    antlrcpp::BitSet getAlts() const;
+    std::vector<Ref<const SemanticContext>> getPredicates() const;
+
+    const Ref<ATNConfig>& get(size_t i) const;
 
-    virtual Ref<ATNConfig> get(size_t i) const;
+    void optimizeConfigs(ATNSimulator *interpreter);
 
-    virtual void optimizeConfigs(ATNSimulator *interpreter);
+    size_t size() const;
+    bool isEmpty() const;
+    void clear();
+    bool isReadonly() const;
+    void setReadonly(bool readonly);
+
+    virtual size_t hashCode() const;
+
+    virtual bool equals(const ATNConfigSet &other) const;
+
+    virtual std::string toString() const;
+
+  private:
+    struct ATNConfigHasher final {
+      const ATNConfigSet* atnConfigSet;
 
-    bool addAll(const Ref<ATNConfigSet> &other);
+      size_t operator()(const ATNConfig *other) const {
+        assert(other != nullptr);
+        return atnConfigSet->hashCode(*other);
+      }
+    };
 
-    bool operator == (const ATNConfigSet &other);
-    virtual size_t hashCode();
-    virtual size_t size();
-    virtual bool isEmpty();
-    virtual void clear();
-    virtual bool isReadonly();
-    virtual void setReadonly(bool readonly);
-    virtual std::string toString();
+    struct ATNConfigComparer final {
+      const ATNConfigSet* atnConfigSet;
+
+      bool operator()(const ATNConfig *lhs, const ATNConfig *rhs) const {
+        assert(lhs != nullptr);
+        assert(rhs != nullptr);
+        return atnConfigSet->equals(*lhs, *rhs);
+      }
+    };
+
+    mutable std::atomic<size_t> _cachedHashCode = 0;
 
-  protected:
     /// Indicates that the set of configurations is read-only. Do not
     /// allow any code to manipulate the set; DFA states will point at
     /// the sets and they must not change. This does not protect the other
     /// fields; in particular, conflictingAlts is set after
     /// we've made this readonly.
-    bool _readonly;
+    bool _readonly = false;
 
-    virtual size_t getHash(ATNConfig *c); // Hash differs depending on set type.
+    virtual size_t hashCode(const ATNConfig &atnConfig) const;
 
-  private:
-    size_t _cachedHashCode;
+    virtual bool equals(const ATNConfig &lhs, const ATNConfig &rhs) const;
+
+    using LookupContainer = std::unordered_set<ATNConfig*, ATNConfigHasher, ATNConfigComparer>;
 
     /// All configs but hashed by (s, i, _, pi) not including context. Wiped out
     /// when we go readonly as this set becomes a DFA state.
-    std::unordered_map<size_t, ATNConfig *> _configLookup;
-
-    void InitializeInstanceFields();
+    LookupContainer _configLookup;
   };
 
+  inline bool operator==(const ATNConfigSet &lhs, const ATNConfigSet &rhs) { return lhs.equals(rhs); }
+
+  inline bool operator!=(const ATNConfigSet &lhs, const ATNConfigSet &rhs) { return !operator==(lhs, rhs); }
+
 } // namespace atn
 } // namespace antlr4
+
+namespace std {
+
+template <>
+struct hash<::antlr4::atn::ATNConfigSet> {
+  size_t operator()(const ::antlr4::atn::ATNConfigSet &atnConfigSet) const {
+    return atnConfigSet.hashCode();
+  }
+};
+
+} // namespace std

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

@@ -4,61 +4,51 @@
  */
 
 #include "atn/ATNDeserializationOptions.h"
+#include "Exceptions.h"
 
+#include <memory>
+#include <mutex>
+
+using namespace antlr4;
 using namespace antlr4::atn;
 
-ATNDeserializationOptions ATNDeserializationOptions::defaultOptions;
+namespace {
 
-ATNDeserializationOptions::ATNDeserializationOptions() {
-  InitializeInstanceFields();
-}
+std::once_flag defaultATNDeserializationOptionsOnceFlag;
+std::unique_ptr<ATNDeserializationOptions> defaultATNDeserializationOptions;
 
-ATNDeserializationOptions::ATNDeserializationOptions(ATNDeserializationOptions *options) : ATNDeserializationOptions() {
-  this->verifyATN = options->verifyATN;
-  this->generateRuleBypassTransitions = options->generateRuleBypassTransitions;
+void initializeDefaultATNDeserializationOptions() {
+  defaultATNDeserializationOptions.reset(new ATNDeserializationOptions());
 }
 
-ATNDeserializationOptions::~ATNDeserializationOptions() {
 }
 
-const ATNDeserializationOptions& ATNDeserializationOptions::getDefaultOptions() {
-  return defaultOptions;
-}
+ATNDeserializationOptions::ATNDeserializationOptions(ATNDeserializationOptions *options)
+    : _readOnly(false), _verifyATN(options->_verifyATN),
+      _generateRuleBypassTransitions(options->_generateRuleBypassTransitions) {}
 
-bool ATNDeserializationOptions::isReadOnly() {
-  return readOnly;
+const ATNDeserializationOptions& ATNDeserializationOptions::getDefaultOptions() {
+  std::call_once(defaultATNDeserializationOptionsOnceFlag,
+                 initializeDefaultATNDeserializationOptions);
+  return *defaultATNDeserializationOptions;
 }
 
 void ATNDeserializationOptions::makeReadOnly() {
-  readOnly = true;
-}
-
-bool ATNDeserializationOptions::isVerifyATN() {
-  return verifyATN;
+  _readOnly = true;
 }
 
 void ATNDeserializationOptions::setVerifyATN(bool verify) {
   throwIfReadOnly();
-  verifyATN = verify;
-}
-
-bool ATNDeserializationOptions::isGenerateRuleBypassTransitions() {
-  return generateRuleBypassTransitions;
+  _verifyATN = verify;
 }
 
 void ATNDeserializationOptions::setGenerateRuleBypassTransitions(bool generate) {
   throwIfReadOnly();
-  generateRuleBypassTransitions = generate;
+  _generateRuleBypassTransitions = generate;
 }
 
-void ATNDeserializationOptions::throwIfReadOnly() {
+void ATNDeserializationOptions::throwIfReadOnly() const {
   if (isReadOnly()) {
-    throw "The object is read only.";
+    throw IllegalStateException("ATNDeserializationOptions is read only.");
   }
 }
-
-void ATNDeserializationOptions::InitializeInstanceFields() {
-  readOnly = false;
-  verifyATN = true;
-  generateRuleBypassTransitions = false;
-}

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

@@ -10,41 +10,39 @@
 namespace antlr4 {
 namespace atn {
 
-  class ANTLR4CPP_PUBLIC ATNDeserializationOptions {
-  private:
-    static ATNDeserializationOptions defaultOptions;
+class ANTLR4CPP_PUBLIC ATNDeserializationOptions final {
+public:
+  ATNDeserializationOptions()
+    : _readOnly(false), _verifyATN(true), _generateRuleBypassTransitions(false) {}
 
-    bool readOnly;
-    bool verifyATN;
-    bool generateRuleBypassTransitions;
+  // TODO: Is this useful? If so we should mark it as explicit, otherwise remove it.
+  ATNDeserializationOptions(ATNDeserializationOptions *options);
 
-  public:
-    ATNDeserializationOptions();
-    ATNDeserializationOptions(ATNDeserializationOptions *options);
-    ATNDeserializationOptions(ATNDeserializationOptions const&) = default;
-    virtual ~ATNDeserializationOptions();
-    ATNDeserializationOptions& operator=(ATNDeserializationOptions const&) = default;
+  ATNDeserializationOptions(const ATNDeserializationOptions&) = default;
 
-    static const ATNDeserializationOptions& getDefaultOptions();
+  ATNDeserializationOptions& operator=(const ATNDeserializationOptions&) = default;
 
-    bool isReadOnly();
+  static const ATNDeserializationOptions& getDefaultOptions();
 
-    void makeReadOnly();
+  bool isReadOnly() const { return _readOnly; }
 
-    bool isVerifyATN();
+  void makeReadOnly();
 
-    void setVerifyATN(bool verify);
+  bool isVerifyATN() const { return _verifyATN; }
 
-    bool isGenerateRuleBypassTransitions();
+  void setVerifyATN(bool verify);
 
-    void setGenerateRuleBypassTransitions(bool generate);
+  bool isGenerateRuleBypassTransitions() const { return _generateRuleBypassTransitions; }
 
-  protected:
-    virtual void throwIfReadOnly();
+  void setGenerateRuleBypassTransitions(bool generate);
 
-  private:
-    void InitializeInstanceFields();
-  };
+private:
+  void throwIfReadOnly() const;
+
+  bool _readOnly;
+  bool _verifyATN;
+  bool _generateRuleBypassTransitions;
+};
 
 } // namespace atn
 } // namespace antlr4