expressir 1.4.2 → 2.0.0

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

@@ -1,225 +0,0 @@
-/* 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 <atomic>
-
-#include "Recognizer.h"
-#include "atn/ATN.h"
-#include "atn/ATNState.h"
-#include "atn/PredictionContextType.h"
-
-namespace antlr4 {
-
-  class RuleContext;
-
-namespace atn {
-
-  class ATN;
-  class ArrayPredictionContext;
-  class SingletonPredictionContext;
-  class PredictionContextCache;
-  class PredictionContextMergeCache;
-
-  class ANTLR4CPP_PUBLIC PredictionContext {
-  public:
-    /// Represents $ in local context prediction, which means wildcard.
-    /// *+x = *.
-    static const Ref<const PredictionContext> EMPTY;
-
-    /// Represents $ in an array in full context mode, when $
-    /// doesn't mean wildcard: $ + x = [$,x]. Here,
-    /// $ = EMPTY_RETURN_STATE.
-    // ml: originally Integer.MAX_VALUE, which would be -1 for us, but this is already used in places where
-    //     -1 is converted to unsigned, so we use a different value here. Any value does the job provided it doesn't
-    //     conflict with real return states.
-    static constexpr size_t EMPTY_RETURN_STATE = std::numeric_limits<size_t>::max() - 9;
-
-    // dispatch
-    static Ref<const PredictionContext> merge(Ref<const PredictionContext> a,
-                                              Ref<const PredictionContext> b,
-                                              bool rootIsWildcard,
-                                              PredictionContextMergeCache *mergeCache);
-
-    /// <summary>
-    /// Merge two <seealso cref="SingletonPredictionContext"/> instances.
-    ///
-    /// <p/>
-    ///
-    /// Stack tops equal, parents merge is same; return left graph.<br/>
-    /// <embed src="images/SingletonMerge_SameRootSamePar.svg" type="image/svg+xml"/>
-    ///
-    /// <p/>
-    ///
-    /// Same stack top, parents differ; merge parents giving array node, then
-    /// remainders of those graphs. A new root node is created to point to the
-    /// merged parents.<br/>
-    /// <embed src="images/SingletonMerge_SameRootDiffPar.svg" type="image/svg+xml"/>
-    ///
-    /// <p/>
-    ///
-    /// Different stack tops pointing to same parent. Make array node for the
-    /// root where both element in the root point to the same (original)
-    /// parent.<br/>
-    /// <embed src="images/SingletonMerge_DiffRootSamePar.svg" type="image/svg+xml"/>
-    ///
-    /// <p/>
-    ///
-    /// Different stack tops pointing to different parents. Make array node for
-    /// the root where each element points to the corresponding original
-    /// parent.<br/>
-    /// <embed src="images/SingletonMerge_DiffRootDiffPar.svg" type="image/svg+xml"/>
-    /// </summary>
-    /// <param name="a"> the first <seealso cref="SingletonPredictionContext"/> </param>
-    /// <param name="b"> the second <seealso cref="SingletonPredictionContext"/> </param>
-    /// <param name="rootIsWildcard"> {@code true} if this is a local-context merge,
-    /// otherwise false to indicate a full-context merge </param>
-    /// <param name="mergeCache"> </param>
-    static Ref<const PredictionContext> mergeSingletons(Ref<const SingletonPredictionContext> a,
-                                                        Ref<const SingletonPredictionContext> b,
-                                                        bool rootIsWildcard,
-                                                        PredictionContextMergeCache *mergeCache);
-
-    /**
-     * Handle case where at least one of {@code a} or {@code b} is
-     * {@link #EMPTY}. In the following diagrams, the symbol {@code $} is used
-     * to represent {@link #EMPTY}.
-     *
-     * <h2>Local-Context Merges</h2>
-     *
-     * <p>These local-context merge operations are used when {@code rootIsWildcard}
-     * is true.</p>
-     *
-     * <p>{@link #EMPTY} is superset of any graph; return {@link #EMPTY}.<br>
-     * <embed src="images/LocalMerge_EmptyRoot.svg" type="image/svg+xml"/></p>
-     *
-     * <p>{@link #EMPTY} and anything is {@code #EMPTY}, so merged parent is
-     * {@code #EMPTY}; return left graph.<br>
-     * <embed src="images/LocalMerge_EmptyParent.svg" type="image/svg+xml"/></p>
-     *
-     * <p>Special case of last merge if local context.<br>
-     * <embed src="images/LocalMerge_DiffRoots.svg" type="image/svg+xml"/></p>
-     *
-     * <h2>Full-Context Merges</h2>
-     *
-     * <p>These full-context merge operations are used when {@code rootIsWildcard}
-     * is false.</p>
-     *
-     * <p><embed src="images/FullMerge_EmptyRoots.svg" type="image/svg+xml"/></p>
-     *
-     * <p>Must keep all contexts; {@link #EMPTY} in array is a special value (and
-     * null parent).<br>
-     * <embed src="images/FullMerge_EmptyRoot.svg" type="image/svg+xml"/></p>
-     *
-     * <p><embed src="images/FullMerge_SameRoot.svg" type="image/svg+xml"/></p>
-     *
-     * @param a the first {@link SingletonPredictionContext}
-     * @param b the second {@link SingletonPredictionContext}
-     * @param rootIsWildcard {@code true} if this is a local-context merge,
-     * otherwise false to indicate a full-context merge
-     */
-    static Ref<const PredictionContext> mergeRoot(Ref<const SingletonPredictionContext> a,
-                                                  Ref<const SingletonPredictionContext> b,
-                                                  bool rootIsWildcard);
-
-    /**
-     * Merge two {@link ArrayPredictionContext} instances.
-     *
-     * <p>Different tops, different parents.<br>
-     * <embed src="images/ArrayMerge_DiffTopDiffPar.svg" type="image/svg+xml"/></p>
-     *
-     * <p>Shared top, same parents.<br>
-     * <embed src="images/ArrayMerge_ShareTopSamePar.svg" type="image/svg+xml"/></p>
-     *
-     * <p>Shared top, different parents.<br>
-     * <embed src="images/ArrayMerge_ShareTopDiffPar.svg" type="image/svg+xml"/></p>
-     *
-     * <p>Shared top, all shared parents.<br>
-     * <embed src="images/ArrayMerge_ShareTopSharePar.svg" type="image/svg+xml"/></p>
-     *
-     * <p>Equal tops, merge parents and reduce top to
-     * {@link SingletonPredictionContext}.<br>
-     * <embed src="images/ArrayMerge_EqualTop.svg" type="image/svg+xml"/></p>
-     */
-    static Ref<const PredictionContext> mergeArrays(Ref<const ArrayPredictionContext> a,
-                                                    Ref<const ArrayPredictionContext> b,
-                                                    bool rootIsWildcard,
-                                                    PredictionContextMergeCache *mergeCache);
-
-    static std::string toDOTString(const Ref<const PredictionContext> &context);
-
-    static Ref<const PredictionContext> getCachedContext(const Ref<const PredictionContext> &context,
-                                                         PredictionContextCache &contextCache);
-
-    static std::vector<Ref<const PredictionContext>> getAllContextNodes(const Ref<const PredictionContext> &context);
-
-    /// Convert a RuleContext tree to a PredictionContext graph.
-    /// Return EMPTY if outerContext is empty.
-    static Ref<const PredictionContext> fromRuleContext(const ATN &atn, RuleContext *outerContext);
-
-    PredictionContext(const PredictionContext&) = delete;
-
-    virtual ~PredictionContext() = default;
-
-    PredictionContext& operator=(const PredictionContext&) = delete;
-    PredictionContext& operator=(PredictionContext&&) = delete;
-
-    PredictionContextType getContextType() const { return _contextType; }
-
-    virtual size_t size() const = 0;
-    virtual const Ref<const PredictionContext>& getParent(size_t index) const = 0;
-    virtual size_t getReturnState(size_t index) const = 0;
-
-    /// This means only the EMPTY (wildcard? not sure) context is in set.
-    virtual bool isEmpty() const = 0;
-    bool hasEmptyPath() const;
-
-    size_t hashCode() const;
-
-    virtual bool equals(const PredictionContext &other) const = 0;
-
-    virtual std::string toString() const = 0;
-
-    std::vector<std::string> toStrings(Recognizer *recognizer, int currentState) const;
-    std::vector<std::string> toStrings(Recognizer *recognizer,
-                                       const Ref<const PredictionContext> &stop,
-                                       int currentState) const;
-
-  protected:
-    explicit PredictionContext(PredictionContextType contextType);
-
-    PredictionContext(PredictionContext&& other);
-
-    virtual size_t hashCodeImpl() const = 0;
-
-    size_t cachedHashCode() const { return _hashCode.load(std::memory_order_relaxed); }
-
-  private:
-    const PredictionContextType _contextType;
-    mutable std::atomic<size_t> _hashCode;
-  };
-
-  inline bool operator==(const PredictionContext &lhs, const PredictionContext &rhs) {
-    return lhs.equals(rhs);
-  }
-
-  inline bool operator!=(const PredictionContext &lhs, const PredictionContext &rhs) {
-    return !operator==(lhs, rhs);
-  }
-
-}  // namespace atn
-}  // namespace antlr4
-
-namespace std {
-
-  template <>
-  struct hash<::antlr4::atn::PredictionContext> {
-    size_t operator()(const ::antlr4::atn::PredictionContext &predictionContext) const {
-      return predictionContext.hashCode();
-    }
-  };
-
-}  // namespace std

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/PredictionContextCache.cpp

@@ -1,56 +0,0 @@
-// 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.
-
-#include "atn/PredictionContextCache.h"
-
-using namespace antlr4::atn;
-
-void PredictionContextCache::put(const Ref<const PredictionContext> &value) {
-  assert(value);
-
-  _data.insert(value);
-}
-
-Ref<const PredictionContext> PredictionContextCache::get(
-    const Ref<const PredictionContext> &value) const {
-  assert(value);
-
-  auto iterator = _data.find(value);
-  if (iterator == _data.end()) {
-    return nullptr;
-  }
-  return *iterator;
-}
-
-size_t PredictionContextCache::PredictionContextHasher::operator()(
-    const Ref<const PredictionContext> &predictionContext) const {
-  return predictionContext->hashCode();
-}
-
-bool PredictionContextCache::PredictionContextComparer::operator()(
-    const Ref<const PredictionContext> &lhs,
-    const Ref<const PredictionContext> &rhs) const {
-  return *lhs == *rhs;
-}

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

@@ -1,63 +0,0 @@
-// 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/PredictionContext.h"
-#include "FlatHashSet.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC PredictionContextCache final {
-  public:
-    PredictionContextCache() = default;
-
-    PredictionContextCache(const PredictionContextCache&) = delete;
-    PredictionContextCache(PredictionContextCache&&) = delete;
-
-    PredictionContextCache& operator=(const PredictionContextCache&) = delete;
-    PredictionContextCache& operator=(PredictionContextCache&&) = delete;
-
-    void put(const Ref<const PredictionContext> &value);
-
-    Ref<const PredictionContext> get(const Ref<const PredictionContext> &value) const;
-
-  private:
-    struct ANTLR4CPP_PUBLIC PredictionContextHasher final {
-      size_t operator()(const Ref<const PredictionContext> &predictionContext) const;
-    };
-
-    struct ANTLR4CPP_PUBLIC PredictionContextComparer final {
-      bool operator()(const Ref<const PredictionContext> &lhs,
-                      const Ref<const PredictionContext> &rhs) const;
-    };
-
-    FlatHashSet<Ref<const PredictionContext>,
-                PredictionContextHasher, PredictionContextComparer> _data;
-  };
-
-}  // namespace atn
-}  // namespace antlr4

data/ext/express_parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/PredictionContextMergeCache.cpp

@@ -1,167 +0,0 @@
-// 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.
-
-#include "atn/PredictionContextMergeCache.h"
-
-#include "misc/MurmurHash.h"
-
-using namespace antlr4::atn;
-using namespace antlr4::misc;
-
-PredictionContextMergeCache::PredictionContextMergeCache(
-    const PredictionContextMergeCacheOptions &options) : _options(options) {}
-
-Ref<const PredictionContext> PredictionContextMergeCache::put(
-    const Ref<const PredictionContext> &key1,
-    const Ref<const PredictionContext> &key2,
-    Ref<const PredictionContext> value) {
-  assert(key1);
-  assert(key2);
-
-  if (getOptions().getMaxSize() == 0) {
-    // Cache is effectively disabled.
-    return value;
-  }
-
-  auto [existing, inserted] = _entries.try_emplace(std::make_pair(key1.get(), key2.get()));
-  if (inserted) {
-    try {
-      existing->second.reset(new Entry());
-    } catch (...) {
-      _entries.erase(existing);
-      throw;
-    }
-    existing->second->key = std::make_pair(key1, key2);
-    existing->second->value = std::move(value);
-    pushToFront(existing->second.get());
-  } else {
-    if (existing->second->value != value) {
-      existing->second->value = std::move(value);
-    }
-    moveToFront(existing->second.get());
-  }
-  compact(existing->second.get());
-  return existing->second->value;
-}
-
-Ref<const PredictionContext> PredictionContextMergeCache::get(
-    const Ref<const PredictionContext> &key1,
-    const Ref<const PredictionContext> &key2) const {
-  assert(key1);
-  assert(key2);
-
-  if (getOptions().getMaxSize() == 0) {
-    // Cache is effectively disabled.
-    return nullptr;
-  }
-
-  auto iterator = _entries.find(std::make_pair(key1.get(), key2.get()));
-  if (iterator == _entries.end()) {
-    return nullptr;
-  }
-  moveToFront(iterator->second.get());
-  return iterator->second->value;
-}
-
-void PredictionContextMergeCache::clear() {
-  Container().swap(_entries);
-  _head = _tail = nullptr;
-  _size = 0;
-}
-
-void PredictionContextMergeCache::moveToFront(Entry *entry) const {
-  if (entry->prev == nullptr) {
-    assert(entry == _head);
-    return;
-  }
-  entry->prev->next = entry->next;
-  if (entry->next != nullptr) {
-    entry->next->prev = entry->prev;
-  } else {
-    assert(entry == _tail);
-    _tail = entry->prev;
-  }
-  entry->prev = nullptr;
-  entry->next = _head;
-  _head->prev = entry;
-  _head = entry;
-  assert(entry->prev == nullptr);
-}
-
-void PredictionContextMergeCache::pushToFront(Entry *entry) {
-  ++_size;
-  entry->prev = nullptr;
-  entry->next = _head;
-  if (_head != nullptr) {
-    _head->prev = entry;
-    _head = entry;
-  } else {
-    assert(entry->next == nullptr);
-    _head = entry;
-    _tail = entry;
-  }
-  assert(entry->prev == nullptr);
-}
-
-void PredictionContextMergeCache::remove(Entry *entry) {
-  if (entry->prev != nullptr) {
-    entry->prev->next = entry->next;
-  } else {
-    assert(entry == _head);
-    _head = entry->next;
-  }
-  if (entry->next != nullptr) {
-    entry->next->prev = entry->prev;
-  } else {
-    assert(entry == _tail);
-    _tail = entry->prev;
-  }
-  --_size;
-  _entries.erase(std::make_pair(entry->key.first.get(), entry->key.second.get()));
-}
-
-void PredictionContextMergeCache::compact(const Entry *preserve) {
-  Entry *entry = _tail;
-  while (entry != nullptr && _size > getOptions().getMaxSize()) {
-    Entry *next = entry->prev;
-    if (entry != preserve) {
-      remove(entry);
-    }
-    entry = next;
-  }
-}
-
-size_t PredictionContextMergeCache::PredictionContextHasher::operator()(
-    const PredictionContextPair &value) const {
-  size_t hash = MurmurHash::initialize();
-  hash = MurmurHash::update(hash, value.first->hashCode());
-  hash = MurmurHash::update(hash, value.second->hashCode());
-  return MurmurHash::finish(hash, 2);
-}
-
-bool PredictionContextMergeCache::PredictionContextComparer::operator()(
-    const PredictionContextPair &lhs, const PredictionContextPair &rhs) const {
-  return *lhs.first == *rhs.first && *lhs.second == *rhs.second;
-}

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

@@ -1,101 +0,0 @@
-// 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 <utility>
-
-#include "atn/PredictionContext.h"
-#include "atn/PredictionContextMergeCacheOptions.h"
-#include "FlatHashMap.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC PredictionContextMergeCache final {
-  public:
-    PredictionContextMergeCache()
-        : PredictionContextMergeCache(PredictionContextMergeCacheOptions()) {}
-
-    explicit PredictionContextMergeCache(const PredictionContextMergeCacheOptions &options);
-
-    PredictionContextMergeCache(const PredictionContextMergeCache&) = delete;
-    PredictionContextMergeCache(PredictionContextMergeCache&&) = delete;
-
-    PredictionContextMergeCache& operator=(const PredictionContextMergeCache&) = delete;
-    PredictionContextMergeCache& operator=(PredictionContextMergeCache&&) = delete;
-
-    Ref<const PredictionContext> put(const Ref<const PredictionContext> &key1,
-                                     const Ref<const PredictionContext> &key2,
-                                     Ref<const PredictionContext> value);
-
-    Ref<const PredictionContext> get(const Ref<const PredictionContext> &key1,
-                                     const Ref<const PredictionContext> &key2) const;
-
-    const PredictionContextMergeCacheOptions& getOptions() const { return _options; }
-
-    void clear();
-
-  private:
-    using PredictionContextPair = std::pair<const PredictionContext*, const PredictionContext*>;
-
-    struct ANTLR4CPP_PUBLIC PredictionContextHasher final {
-      size_t operator()(const PredictionContextPair &value) const;
-    };
-
-    struct ANTLR4CPP_PUBLIC PredictionContextComparer final {
-      bool operator()(const PredictionContextPair &lhs, const PredictionContextPair &rhs) const;
-    };
-
-    struct ANTLR4CPP_PUBLIC Entry final {
-      std::pair<Ref<const PredictionContext>, Ref<const PredictionContext>> key;
-      Ref<const PredictionContext> value;
-      Entry *prev = nullptr;
-      Entry *next = nullptr;
-    };
-
-    void moveToFront(Entry *entry) const;
-
-    void pushToFront(Entry *entry);
-
-    void remove(Entry *entry);
-
-    void compact(const Entry *preserve);
-
-    using Container = FlatHashMap<PredictionContextPair, std::unique_ptr<Entry>,
-                                  PredictionContextHasher, PredictionContextComparer>;
-
-    const PredictionContextMergeCacheOptions _options;
-
-    Container _entries;
-
-    mutable Entry *_head = nullptr;
-    mutable Entry *_tail = nullptr;
-
-    size_t _size = 0;
-  };
-
-}  // namespace atn
-}  // namespace antlr4

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

@@ -1,71 +0,0 @@
-// 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 <cstddef>
-#include <cstdint>
-#include <limits>
-
-#include "antlr4-common.h"
-
-namespace antlr4 {
-namespace atn {
-
-  class ANTLR4CPP_PUBLIC PredictionContextMergeCacheOptions final {
-  public:
-    PredictionContextMergeCacheOptions() = default;
-
-    size_t getMaxSize() const { return _maxSize; }
-
-    bool hasMaxSize() const { return getMaxSize() != std::numeric_limits<size_t>::max(); }
-
-    PredictionContextMergeCacheOptions& setMaxSize(size_t maxSize) {
-      _maxSize = maxSize;
-      return *this;
-    }
-
-    size_t getClearEveryN() const {
-      return _clearEveryN;
-    }
-
-    bool hasClearEveryN() const { return getClearEveryN() != 0; }
-
-    PredictionContextMergeCacheOptions& setClearEveryN(uint64_t clearEveryN) {
-      _clearEveryN = clearEveryN;
-      return *this;
-    }
-
-    PredictionContextMergeCacheOptions& neverClear() {
-      return setClearEveryN(0);
-    }
-
-  private:
-    size_t _maxSize = std::numeric_limits<size_t>::max();
-    uint64_t _clearEveryN = 1;
-  };
-
-}  // namespace atn
-}  // namespace antlr4