expressir 1.3.0 → 1.3.1

data/ext/{express-parser → express_parser}/antlr4-upstream/runtime/Cpp/runtime/src/atn/ATNConfigSet.cpp

@@ -1,4 +1,4 @@
-/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+/* 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.
  */
@@ -43,7 +43,7 @@ bool ATNConfigSet::add(const Ref<ATNConfig> &config, PredictionContextMergeCache
   if (_readonly) {
     throw IllegalStateException("This set is readonly");
   }
-  if (config->semanticContext != SemanticContext::NONE) {
+  if (config->semanticContext != SemanticContext::Empty::Instance) {
     hasSemanticContext = true;
   }
   if (config->getOuterContextDepth() > 0) {
@@ -114,7 +114,7 @@ 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) {
+    if (c->semanticContext != SemanticContext::Empty::Instance) {
       preds.push_back(c->semanticContext);
     }
   }
@@ -197,24 +197,25 @@ std::string ATNConfigSet::toString() const {
   std::stringstream ss;
   ss << "[";
   for (size_t i = 0; i < configs.size(); i++) {
+    if ( i>0 ) ss << ", ";
     ss << configs[i]->toString();
   }
   ss << "]";
 
   if (hasSemanticContext) {
-    ss << ",hasSemanticContext = " <<  hasSemanticContext;
+    ss << ",hasSemanticContext=" << (hasSemanticContext?"true":"false");
   }
   if (uniqueAlt != ATN::INVALID_ALT_NUMBER) {
-    ss << ",uniqueAlt = " << uniqueAlt;
+    ss << ",uniqueAlt=" << uniqueAlt;
   }
 
-  if (conflictingAlts.size() > 0) {
-    ss << ",conflictingAlts = ";
+  if (conflictingAlts.count() > 0) {
+    ss << ",conflictingAlts=";
     ss << conflictingAlts.toString();
   }
 
   if (dipsIntoOuterContext) {
-    ss << ", dipsIntoOuterContext";
+    ss << ",dipsIntoOuterContext";
   }
   return ss.str();
 }

data/ext/{express-parser → express_parser}/antlr4-upstream/runtime/Cpp/runtime/src/atn/ATNConfigSet.h

@@ -10,6 +10,7 @@
 #include "support/BitSet.h"
 #include "atn/PredictionContext.h"
 #include "atn/ATNConfig.h"
+#include "FlatHashSet.h"
 
 namespace antlr4 {
 namespace atn {
@@ -130,7 +131,7 @@ namespace atn {
 
     virtual bool equals(const ATNConfig &lhs, const ATNConfig &rhs) const;
 
-    using LookupContainer = std::unordered_set<ATNConfig*, ATNConfigHasher, ATNConfigComparer>;
+    using LookupContainer = FlatHashSet<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.

data/ext/{express-parser → express_parser}/antlr4-upstream/runtime/Cpp/runtime/src/atn/ATNDeserializationOptions.cpp

@@ -6,31 +6,16 @@
 #include "atn/ATNDeserializationOptions.h"
 #include "Exceptions.h"
 
-#include <memory>
-#include <mutex>
-
 using namespace antlr4;
 using namespace antlr4::atn;
 
-namespace {
-
-std::once_flag defaultATNDeserializationOptionsOnceFlag;
-std::unique_ptr<ATNDeserializationOptions> defaultATNDeserializationOptions;
-
-void initializeDefaultATNDeserializationOptions() {
-  defaultATNDeserializationOptions.reset(new ATNDeserializationOptions());
-}
-
-}
-
 ATNDeserializationOptions::ATNDeserializationOptions(ATNDeserializationOptions *options)
     : _readOnly(false), _verifyATN(options->_verifyATN),
       _generateRuleBypassTransitions(options->_generateRuleBypassTransitions) {}
 
 const ATNDeserializationOptions& ATNDeserializationOptions::getDefaultOptions() {
-  std::call_once(defaultATNDeserializationOptionsOnceFlag,
-                 initializeDefaultATNDeserializationOptions);
-  return *defaultATNDeserializationOptions;
+  static const ATNDeserializationOptions* const defaultOptions = new ATNDeserializationOptions();
+  return *defaultOptions;
 }
 
 void ATNDeserializationOptions::makeReadOnly() {

data/ext/{express-parser → express_parser}/antlr4-upstream/runtime/Cpp/runtime/src/atn/ATNDeserializer.cpp

@@ -53,7 +53,6 @@
 #include "atn/ATNDeserializer.h"
 
 #include <cassert>
-#include <mutex>
 #include <string>
 #include <vector>
 

data/ext/{express-parser → express_parser}/antlr4-upstream/runtime/Cpp/runtime/src/atn/ArrayPredictionContext.cpp

@@ -8,6 +8,7 @@
 #include <cstring>
 
 #include "atn/SingletonPredictionContext.h"
+#include "atn/HashUtils.h"
 #include "misc/MurmurHash.h"
 #include "support/Casts.h"
 
@@ -17,12 +18,13 @@ using namespace antlrcpp;
 
 namespace {
 
-  bool cachedHashCodeEqual(size_t lhs, size_t rhs) {
-    return lhs == rhs || lhs == 0 || rhs == 0;
-  }
-
   bool predictionContextEqual(const Ref<const PredictionContext> &lhs, const Ref<const PredictionContext> &rhs) {
-    return *lhs == *rhs;
+    // parent PredictionContext pointers can be null during full context mode and
+    // the ctxs are in an ArrayPredictionContext.  If both are null, return true
+    // if just one is null, return false. If both are non-null, do comparison.
+    if ( lhs == nullptr ) return rhs == nullptr;
+    if ( rhs == nullptr ) return false; // lhs!=null and rhs==null
+    return *lhs == *rhs;                // both nonnull
   }
 
 }
@@ -75,11 +77,29 @@ bool ArrayPredictionContext::equals(const PredictionContext &other) const {
     return false;
   }
   const auto &array = downCast<const ArrayPredictionContext&>(other);
-  return returnStates.size() == array.returnStates.size() &&
-         parents.size() == array.parents.size() &&
-         cachedHashCodeEqual(cachedHashCode(), array.cachedHashCode()) &&
-         std::memcmp(returnStates.data(), array.returnStates.data(), returnStates.size() * sizeof(decltype(returnStates)::value_type)) == 0 &&
-         std::equal(parents.begin(), parents.end(), array.parents.begin(), predictionContextEqual);
+  const bool sameSize = returnStates.size() == array.returnStates.size() &&
+                        parents.size() == array.parents.size();
+  if ( !sameSize ) {
+      return false;
+  }
+
+  const bool sameHash = cachedHashCodeEqual(cachedHashCode(), array.cachedHashCode());
+  if ( !sameHash ) {
+      return false;
+  }
+
+  const size_t stateSizeBytes = sizeof(decltype(returnStates)::value_type);
+  const bool returnStateArraysEqual =
+          std::memcmp(returnStates.data(), array.returnStates.data(),
+                      returnStates.size() * stateSizeBytes) == 0;
+  if ( !returnStateArraysEqual ) {
+      return false;
+  }
+
+  // stack of contexts is the same
+  const bool parentCtxEqual =
+          std::equal(parents.begin(), parents.end(), array.parents.begin(), predictionContextEqual);
+  return parentCtxEqual;
 }
 
 std::string ArrayPredictionContext::toString() const {

data/ext/{express-parser → express_parser}/antlr4-upstream/runtime/Cpp/runtime/src/atn/DecisionState.cpp

@@ -8,5 +8,5 @@
 using namespace antlr4::atn;
 
 std::string DecisionState::toString() const {
-  return "DECISION " + ATNState::toString();
+  return ATNState::toString();
 }

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/HashUtils.h

@@ -0,0 +1,18 @@
+/* Copyright (c) 2022 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>
+
+namespace antlr4 {
+namespace atn {
+
+  inline bool cachedHashCodeEqual(size_t lhs, size_t rhs) {
+    return lhs == rhs || lhs == 0 || rhs == 0;
+  }
+
+} // namespace atn
+} // namespace antlr4

data/ext/{express-parser → express_parser}/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerATNSimulator.cpp

@@ -16,6 +16,7 @@
 #include "misc/Interval.h"
 #include "dfa/DFA.h"
 #include "Lexer.h"
+#include "internal/Synchronization.h"
 
 #include "dfa/DFAState.h"
 #include "atn/LexerATNConfig.h"
@@ -23,11 +24,16 @@
 
 #include "atn/LexerATNSimulator.h"
 
-#define DEBUG_ATN 0
-#define DEBUG_DFA 0
+#ifndef LEXER_DEBUG_ATN
+#define LEXER_DEBUG_ATN 0
+#endif
+#ifndef LEXER_DEBUG_DFA
+#define LEXER_DEBUG_DFA 0
+#endif
 
 using namespace antlr4;
 using namespace antlr4::atn;
+using namespace antlr4::internal;
 using namespace antlrcpp;
 
 void LexerATNSimulator::SimState::reset() {
@@ -65,7 +71,7 @@ size_t LexerATNSimulator::match(CharStream *input, size_t mode) {
   const dfa::DFA &dfa = _decisionToDFA[mode];
   dfa::DFAState* s0;
   {
-    std::shared_lock<std::shared_mutex> stateLock(atn._stateMutex);
+    SharedLock<SharedMutex> stateLock(atn._stateMutex);
     s0 = dfa.s0;
   }
   if (s0 == nullptr) {
@@ -167,10 +173,10 @@ size_t LexerATNSimulator::execATN(CharStream *input, dfa::DFAState *ds0) {
 
 dfa::DFAState *LexerATNSimulator::getExistingTargetState(dfa::DFAState *s, size_t t) {
   dfa::DFAState* retval = nullptr;
-  std::shared_lock<std::shared_mutex> edgeLock(atn._edgeMutex);
+  SharedLock<SharedMutex> edgeLock(atn._edgeMutex);
   if (t <= MAX_DFA_EDGE) {
     auto iterator = s->edges.find(t - MIN_DFA_EDGE);
-#if DEBUG_ATN == 1
+#if LEXER_DEBUG_ATN == 1
     if (iterator != s->edges.end()) {
       std::cout << std::string("reuse state ") << s->stateNumber << std::string(" edge to ") << iterator->second->stateNumber << std::endl;
     }
@@ -230,7 +236,7 @@ void LexerATNSimulator::getReachableConfigSet(CharStream *input, ATNConfigSet *c
       continue;
     }
 
-#if DEBUG_ATN == 1
+#if LEXER_DEBUG_ATN == 1
       std::cout << "testing " << getTokenName((int)t) << " at " << c->toString(true) << std::endl;
 #endif
 
@@ -261,7 +267,7 @@ void LexerATNSimulator::getReachableConfigSet(CharStream *input, ATNConfigSet *c
 
 void LexerATNSimulator::accept(CharStream *input, const Ref<const LexerActionExecutor> &lexerActionExecutor, size_t /*startIndex*/,
                                size_t index, size_t line, size_t charPos) {
-#if DEBUG_ATN == 1
+#if LEXER_DEBUG_ATN == 1
     std::cout << "ACTION ";
     std::cout << toString(lexerActionExecutor) << std::endl;
 #endif
@@ -298,12 +304,12 @@ std::unique_ptr<ATNConfigSet> LexerATNSimulator::computeStartState(CharStream *i
 
 bool LexerATNSimulator::closure(CharStream *input, const Ref<LexerATNConfig> &config, ATNConfigSet *configs,
                                 bool currentAltReachedAcceptState, bool speculative, bool treatEofAsEpsilon) {
-#if DEBUG_ATN == 1
+#if LEXER_DEBUG_ATN == 1
     std::cout << "closure(" << config->toString(true) << ")" << std::endl;
 #endif
 
   if (config->state != nullptr && config->state->getStateType() == ATNStateType::RULE_STOP) {
-#if DEBUG_ATN == 1
+#if LEXER_DEBUG_ATN == 1
       if (_recog != nullptr) {
         std::cout << "closure at " << _recog->getRuleNames()[config->state->ruleIndex] << " rule stop " << config << std::endl;
       } else {
@@ -390,7 +396,7 @@ Ref<LexerATNConfig> LexerATNSimulator::getEpsilonTarget(CharStream *input, const
        */
       const PredicateTransition *pt = static_cast<const PredicateTransition*>(t);
 
-#if DEBUG_ATN == 1
+#if LEXER_DEBUG_ATN == 1
         std::cout << "EVAL rule " << pt->getRuleIndex() << ":" << pt->getPredIndex() << std::endl;
 #endif
 
@@ -513,7 +519,7 @@ void LexerATNSimulator::addDFAEdge(dfa::DFAState *p, size_t t, dfa::DFAState *q)
     return;
   }
 
-  std::unique_lock<std::shared_mutex> edgeLock(atn._edgeMutex);
+  UniqueLock<SharedMutex> edgeLock(atn._edgeMutex);
   p->edges[t - MIN_DFA_EDGE] = q; // connect
 }
 
@@ -545,7 +551,7 @@ dfa::DFAState *LexerATNSimulator::addDFAState(ATNConfigSet *configs, bool suppre
   dfa::DFA &dfa = _decisionToDFA[_mode];
 
   {
-    std::unique_lock<std::shared_mutex> stateLock(atn._stateMutex);
+    UniqueLock<SharedMutex> stateLock(atn._stateMutex);
     auto [existing, inserted] = dfa.states.insert(proposed);
     if (!inserted) {
       delete proposed;

data/ext/{express-parser → express_parser}/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerActionExecutor.cpp

@@ -5,6 +5,7 @@
 
 #include "misc/MurmurHash.h"
 #include "atn/LexerIndexedCustomAction.h"
+#include "atn/HashUtils.h"
 #include "support/CPPUtils.h"
 #include "support/Arrays.h"
 #include "support/Casts.h"
@@ -18,10 +19,6 @@ using namespace antlrcpp;
 
 namespace {
 
-  bool cachedHashCodeEqual(size_t lhs, size_t rhs) {
-    return lhs == rhs || lhs == 0 || rhs == 0;
-  }
-
   bool lexerActionEqual(const Ref<const LexerAction> &lhs, const Ref<const LexerAction> &rhs) {
     return *lhs == *rhs;
   }

data/ext/{express-parser → express_parser}/antlr4-upstream/runtime/Cpp/runtime/src/atn/LexerIndexedCustomAction.cpp

@@ -3,6 +3,7 @@
  * can be found in the LICENSE.txt file in the project root.
  */
 
+#include "atn/HashUtils.h"
 #include "misc/MurmurHash.h"
 #include "Lexer.h"
 #include "support/CPPUtils.h"
@@ -15,14 +16,6 @@ using namespace antlr4::atn;
 using namespace antlr4::misc;
 using namespace antlrcpp;
 
-namespace {
-
-  bool cachedHashCodeEqual(size_t lhs, size_t rhs) {
-    return lhs == rhs || lhs == 0 || rhs == 0;
-  }
-
-}
-
 LexerIndexedCustomAction::LexerIndexedCustomAction(int offset, Ref<const LexerAction> action)
     : LexerAction(LexerActionType::INDEXED_CUSTOM, true), _action(std::move(action)), _offset(offset) {}