asn_parser 1.0.0 → 1.0.5

data/ext/asn1_parser/antlr4-upstream/runtime/Cpp/runtime/src/FlatHashSet.h

@@ -0,0 +1,57 @@
+// 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 "antlr4-common.h"
+
+#if ANTLR4CPP_USING_ABSEIL
+#include "absl/container/flat_hash_set.h"
+#else
+#include <unordered_set>
+#endif
+
+// By default ANTLRv4 uses containers provided by the C++ standard library. In most deployments this
+// is fine, however in some using custom containers may be preferred. This header allows that by
+// optionally supporting some alternative implementations and allowing for more easier patching of
+// other alternatives.
+
+namespace antlr4 {
+
+#if ANTLR4CPP_USING_ABSEIL
+  template <typename Key,
+            typename Hash = typename absl::flat_hash_set<Key>::hasher,
+            typename Equal = typename absl::flat_hash_set<Key>::key_equal,
+            typename Allocator = typename absl::flat_hash_set<Key>::allocator_type>
+  using FlatHashSet = absl::flat_hash_set<Key, Hash, Equal, Allocator>;
+#else
+  template <typename Key,
+            typename Hash = std::hash<Key>,
+            typename Equal = std::equal_to<Key>,
+            typename Allocator = std::allocator<Key>>
+  using FlatHashSet = std::unordered_set<Key, Hash, Equal, Allocator>;
+#endif
+
+} // namespace antlr4

data/ext/{asn_parser → asn1_parser}/antlr4-upstream/runtime/Cpp/runtime/src/Parser.cpp

@@ -20,6 +20,7 @@
 #include "Exceptions.h"
 #include "ANTLRErrorListener.h"
 #include "tree/pattern/ParseTreePattern.h"
+#include "internal/Synchronization.h"
 
 #include "atn/ProfilingATNSimulator.h"
 #include "atn/ParseInfo.h"
@@ -28,6 +29,7 @@
 
 using namespace antlr4;
 using namespace antlr4::atn;
+using namespace antlr4::internal;
 using namespace antlrcpp;
 
 namespace {
@@ -573,7 +575,7 @@ std::vector<std::string> Parser::getRuleInvocationStack(RuleContext *p) {
 std::vector<std::string> Parser::getDFAStrings() {
   atn::ParserATNSimulator *simulator = getInterpreter<atn::ParserATNSimulator>();
   if (!simulator->decisionToDFA.empty()) {
-    std::lock_guard<std::mutex> lck(_mutex);
+    UniqueLock<Mutex> lck(_mutex);
 
     std::vector<std::string> s;
     for (size_t d = 0; d < simulator->decisionToDFA.size(); d++) {
@@ -588,7 +590,7 @@ std::vector<std::string> Parser::getDFAStrings() {
 void Parser::dumpDFA() {
   atn::ParserATNSimulator *simulator = getInterpreter<atn::ParserATNSimulator>();
   if (!simulator->decisionToDFA.empty()) {
-    std::lock_guard<std::mutex> lck(_mutex);
+    UniqueLock<Mutex> lck(_mutex);
     bool seenOne = false;
     for (size_t d = 0; d < simulator->decisionToDFA.size(); d++) {
       dfa::DFA &dfa = simulator->decisionToDFA[d];

data/ext/{asn_parser → asn1_parser}/antlr4-upstream/runtime/Cpp/runtime/src/Recognizer.cpp

@@ -18,6 +18,7 @@
 
 using namespace antlr4;
 using namespace antlr4::atn;
+using namespace antlr4::internal;
 
 std::map<const dfa::Vocabulary*, std::map<std::string_view, size_t>> Recognizer::_tokenTypeMapCache;
 std::map<std::vector<std::string>, std::map<std::string, size_t>> Recognizer::_ruleIndexMapCache;
@@ -33,7 +34,7 @@ Recognizer::~Recognizer() {
 std::map<std::string_view, size_t> Recognizer::getTokenTypeMap() {
   const dfa::Vocabulary& vocabulary = getVocabulary();
 
-  std::lock_guard<std::mutex> lck(_mutex);
+  UniqueLock<Mutex> lck(_mutex);
   std::map<std::string_view, size_t> result;
   auto iterator = _tokenTypeMapCache.find(&vocabulary);
   if (iterator != _tokenTypeMapCache.end()) {
@@ -63,7 +64,7 @@ std::map<std::string, size_t> Recognizer::getRuleIndexMap() {
     throw "The current recognizer does not provide a list of rule names.";
   }
 
-  std::lock_guard<std::mutex> lck(_mutex);
+  UniqueLock<Mutex> lck(_mutex);
   std::map<std::string, size_t> result;
   auto iterator = _ruleIndexMapCache.find(ruleNames);
   if (iterator != _ruleIndexMapCache.end()) {

data/ext/{asn_parser → asn1_parser}/antlr4-upstream/runtime/Cpp/runtime/src/Recognizer.h

@@ -8,6 +8,7 @@
 #include "ProxyErrorListener.h"
 #include "support/Casts.h"
 #include "atn/SerializedATNView.h"
+#include "internal/Synchronization.h"
 
 namespace antlr4 {
 
@@ -142,7 +143,7 @@ namespace antlr4 {
     atn::ATNSimulator *_interpreter; // Set and deleted in descendants (or the profiler).
 
     // Mutex to manage synchronized access for multithreading.
-    std::mutex _mutex;
+    internal::Mutex _mutex;
 
   private:
     static std::map<const dfa::Vocabulary*, std::map<std::string_view, size_t>> _tokenTypeMapCache;

data/ext/{asn_parser → asn1_parser}/antlr4-upstream/runtime/Cpp/runtime/src/TokenStreamRewriter.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.
  */
@@ -313,6 +313,10 @@ std::string TokenStreamRewriter::getText(const std::string &programName, const I
 std::unordered_map<size_t, TokenStreamRewriter::RewriteOperation*> TokenStreamRewriter::reduceToSingleOperationPerIndex(
   std::vector<TokenStreamRewriter::RewriteOperation*> &rewrites) {
 
+  // Reset the instructionIndex
+  for (size_t i = 0; i < rewrites.size(); ++i) {
+    rewrites[i]->instructionIndex = i;
+  }
 
   // WALK REPLACES
   for (size_t i = 0; i < rewrites.size(); ++i) {
@@ -327,14 +331,14 @@ std::unordered_map<size_t, TokenStreamRewriter::RewriteOperation*> TokenStreamRe
       if (iop->index == rop->index) {
         // E.g., insert before 2, delete 2..2; update replace
         // text to include insert before, kill insert
-        delete rewrites[iop->instructionIndex];
-        rewrites[iop->instructionIndex] = nullptr;
         rop->text = iop->text + (!rop->text.empty() ? rop->text : "");
+        rewrites[iop->instructionIndex] = nullptr;
+        delete iop;
       }
       else if (iop->index > rop->index && iop->index <= rop->lastIndex) {
         // delete insert as it's a no-op.
-        delete rewrites[iop->instructionIndex];
         rewrites[iop->instructionIndex] = nullptr;
+        delete iop;
       }
     }
     // Drop any prior replaces contained within
@@ -342,8 +346,8 @@ std::unordered_map<size_t, TokenStreamRewriter::RewriteOperation*> TokenStreamRe
     for (auto *prevRop : prevReplaces) {
       if (prevRop->index >= rop->index && prevRop->lastIndex <= rop->lastIndex) {
         // delete replace as it's a no-op.
-        delete rewrites[prevRop->instructionIndex];
         rewrites[prevRop->instructionIndex] = nullptr;
+        delete prevRop;
         continue;
       }
       // throw exception unless disjoint or identical
@@ -351,11 +355,10 @@ std::unordered_map<size_t, TokenStreamRewriter::RewriteOperation*> TokenStreamRe
       // Delete special case of replace (text==null):
       // D.i-j.u D.x-y.v    | boundaries overlap    combine to max(min)..max(right)
       if (prevRop->text.empty() && rop->text.empty() && !disjoint) {
-        delete rewrites[prevRop->instructionIndex];
-        rewrites[prevRop->instructionIndex] = nullptr; // kill first delete
         rop->index = std::min(prevRop->index, rop->index);
         rop->lastIndex = std::max(prevRop->lastIndex, rop->lastIndex);
-        std::cout << "new rop " << rop << std::endl;
+        rewrites[prevRop->instructionIndex] = nullptr; // kill first delete
+        delete prevRop;
       }
       else if (!disjoint) {
         throw IllegalArgumentException("replace op boundaries of " + rop->toString() +
@@ -379,8 +382,8 @@ std::unordered_map<size_t, TokenStreamRewriter::RewriteOperation*> TokenStreamRe
                                           // whole token buffer so no lazy eval issue with any templates
         iop->text = catOpText(&iop->text, &prevIop->text);
         // delete redundant prior insert
-        delete rewrites[prevIop->instructionIndex];
         rewrites[prevIop->instructionIndex] = nullptr;
+        delete prevIop;
       }
     }
     // look for replaces where iop.index is in range; error

data/ext/{asn_parser → asn1_parser}/antlr4-upstream/runtime/Cpp/runtime/src/Version.h

@@ -28,8 +28,8 @@
 #include "antlr4-common.h"
 
 #define ANTLRCPP_VERSION_MAJOR 4
-#define ANTLRCPP_VERSION_MINOR 10
-#define ANTLRCPP_VERSION_PATCH 1
+#define ANTLRCPP_VERSION_MINOR 13
+#define ANTLRCPP_VERSION_PATCH 2
 
 #define ANTLRCPP_MAKE_VERSION(major, minor, patch) ((major) * 100000 + (minor) * 1000 + (patch))
 

data/ext/{asn_parser → asn1_parser}/antlr4-upstream/runtime/Cpp/runtime/src/antlr4-common.h

@@ -21,9 +21,7 @@
 #include <limits>
 #include <map>
 #include <memory>
-#include <mutex>
 #include <set>
-#include <shared_mutex>
 #include <sstream>
 #include <stack>
 #include <string>
@@ -86,6 +84,11 @@
 #define ANTLR4CPP_INTERNAL_STRINGIFY(x) #x
 #define ANTLR4CPP_STRINGIFY(x) ANTLR4CPP_INTERNAL_STRINGIFY(x)
 
+// We use everything from the C++ standard library by default.
+#ifndef ANTLR4CPP_USING_ABSEIL
+#define ANTLR4CPP_USING_ABSEIL 0
+#endif
+
 #include "support/Declarations.h"
 
 // We have to undefine this symbol as ANTLR will use this name for own members and even

data/ext/{asn_parser → asn1_parser}/antlr4-upstream/runtime/Cpp/runtime/src/antlr4-runtime.h

@@ -165,5 +165,4 @@
 #include "tree/xpath/XPathTokenElement.h"
 #include "tree/xpath/XPathWildcardAnywhereElement.h"
 #include "tree/xpath/XPathWildcardElement.h"
-
-
+#include "internal/Synchronization.h"

data/ext/{asn_parser → asn1_parser}/antlr4-upstream/runtime/Cpp/runtime/src/atn/ATN.cpp

@@ -18,6 +18,7 @@
 
 using namespace antlr4;
 using namespace antlr4::atn;
+using namespace antlr4::internal;
 using namespace antlrcpp;
 
 ATN::ATN() : ATN(ATNType::LEXER, 0) {}
@@ -38,7 +39,7 @@ misc::IntervalSet ATN::nextTokens(ATNState *s, RuleContext *ctx) const {
 
 misc::IntervalSet const& ATN::nextTokens(ATNState *s) const {
   if (!s->_nextTokenUpdated) {
-    std::unique_lock<std::mutex> lock(_mutex);
+    UniqueLock<Mutex> lock(_mutex);
     if (!s->_nextTokenUpdated) {
       s->_nextTokenWithinRule = nextTokens(s, nullptr);
       s->_nextTokenUpdated = true;

data/ext/{asn_parser → asn1_parser}/antlr4-upstream/runtime/Cpp/runtime/src/atn/ATN.h

@@ -6,6 +6,7 @@
 #pragma once
 
 #include "RuleContext.h"
+#include "internal/Synchronization.h"
 
 // GCC generates a warning when forward-declaring ATN if ATN has already been
 // declared due to the attributes added by ANTLR4CPP_PUBLIC.
@@ -123,9 +124,9 @@ namespace atn {
     friend class LexerATNSimulator;
     friend class ParserATNSimulator;
 
-    mutable std::mutex _mutex;
-    mutable std::shared_mutex _stateMutex;
-    mutable std::shared_mutex _edgeMutex;
+    mutable internal::Mutex _mutex;
+    mutable internal::SharedMutex _stateMutex;
+    mutable internal::SharedMutex _edgeMutex;
   };
 
 } // namespace atn

data/ext/{asn_parser → asn1_parser}/antlr4-upstream/runtime/Cpp/runtime/src/atn/ATNConfig.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.
  */
@@ -23,7 +23,7 @@ inline constexpr size_t SUPPRESS_PRECEDENCE_FILTER = 0x40000000;
 }
 
 ATNConfig::ATNConfig(ATNState *state, size_t alt, Ref<const PredictionContext> context)
-    : ATNConfig(state, alt, std::move(context), 0, SemanticContext::NONE) {}
+    : ATNConfig(state, alt, std::move(context), 0, SemanticContext::Empty::Instance) {}
 
 ATNConfig::ATNConfig(ATNState *state, size_t alt, Ref<const PredictionContext> context, Ref<const SemanticContext> semanticContext)
     : ATNConfig(state, alt, std::move(context), 0, std::move(semanticContext)) {}
@@ -94,8 +94,8 @@ std::string ATNConfig::toString(bool showAlt) const {
   if (context) {
     ss << ",[" << context->toString() << "]";
   }
-  if (semanticContext != nullptr && semanticContext != SemanticContext::NONE) {
-    ss << ",[" << semanticContext->toString() << "]";
+  if (semanticContext != nullptr && semanticContext != SemanticContext::Empty::Instance) {
+    ss << "," << semanticContext->toString();
   }
   if (getOuterContextDepth() > 0) {
     ss << ",up=" << getOuterContextDepth();

data/ext/{asn_parser → asn1_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/{asn_parser → asn1_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/{asn_parser → asn1_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 std::unique_ptr<const ATNDeserializationOptions> defaultOptions = std::make_unique<const ATNDeserializationOptions>();
+  return *defaultOptions;
 }
 
 void ATNDeserializationOptions::makeReadOnly() {

data/ext/{asn_parser → asn1_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/{asn_parser → asn1_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/{asn_parser → asn1_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/asn1_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/{asn_parser → asn1_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/{asn_parser → asn1_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;
   }