expressir 1.4.3 → 2.1.0

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

@@ -1,157 +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 <cassert>
-
-#include "antlr4-common.h"
-#include "atn/SemanticContext.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// <summary>
-  /// A tuple: (ATN state, predicted alt, syntactic, semantic context).
-  ///  The syntactic context is a graph-structured stack node whose
-  ///  path(s) to the root is the rule invocation(s)
-  ///  chain used to arrive at the state.  The semantic context is
-  ///  the tree of semantic predicates encountered before reaching
-  ///  an ATN state.
-  /// </summary>
-  class ANTLR4CPP_PUBLIC ATNConfig {
-  public:
-    struct Hasher
-    {
-      size_t operator()(Ref<ATNConfig> const& k) const {
-        return k->hashCode();
-      }
-
-      size_t operator()(ATNConfig const& k) const {
-        return k.hashCode();
-      }
-    };
-
-    struct Comparer {
-      bool operator()(Ref<ATNConfig> const& lhs, Ref<ATNConfig> const& rhs) const {
-        return (lhs == rhs) || (*lhs == *rhs);
-      }
-
-      bool operator()(ATNConfig const& lhs, ATNConfig const& rhs) const {
-        return (&lhs == &rhs) || (lhs == rhs);
-      }
-    };
-
-    using Set = std::unordered_set<Ref<ATNConfig>, Hasher, Comparer>;
-
-    /// The ATN state associated with this configuration.
-    ATNState *state = nullptr;
-
-    /// What alt (or lexer rule) is predicted by this configuration.
-    const size_t alt = 0;
-
-    /// The stack of invoking states leading to the rule/states associated
-    /// with this config.  We track only those contexts pushed during
-    /// execution of the ATN simulator.
-    ///
-    /// Can be shared between multiple ANTConfig instances.
-    Ref<const PredictionContext> context;
-
-    /**
-     * We cannot execute predicates dependent upon local context unless
-     * we know for sure we are in the correct context. Because there is
-     * no way to do this efficiently, we simply cannot evaluate
-     * dependent predicates unless we are in the rule that initially
-     * invokes the ATN simulator.
-     *
-     * <p>
-     * closure() tracks the depth of how far we dip into the outer context:
-     * depth > 0.  Note that it may not be totally accurate depth since I
-     * don't ever decrement. TODO: make it a boolean then</p>
-     *
-     * <p>
-     * For memory efficiency, the {@link #isPrecedenceFilterSuppressed} method
-     * is also backed by this field. Since the field is publicly accessible, the
-     * highest bit which would not cause the value to become negative is used to
-     * store this field. This choice minimizes the risk that code which only
-     * compares this value to 0 would be affected by the new purpose of the
-     * flag. It also ensures the performance of the existing {@link ATNConfig}
-     * constructors as well as certain operations like
-     * {@link ATNConfigSet#add(ATNConfig, DoubleKeyMap)} method are
-     * <em>completely</em> unaffected by the change.</p>
-     */
-    size_t reachesIntoOuterContext = 0;
-
-    /// Can be shared between multiple ATNConfig instances.
-    Ref<const SemanticContext> semanticContext;
-
-    ATNConfig(ATNState *state, size_t alt, Ref<const PredictionContext> context);
-    ATNConfig(ATNState *state, size_t alt, Ref<const PredictionContext> context, Ref<const SemanticContext> semanticContext);
-
-    ATNConfig(ATNConfig const& other, Ref<const SemanticContext> semanticContext);
-    ATNConfig(ATNConfig const& other, ATNState *state);
-    ATNConfig(ATNConfig const& other, ATNState *state, Ref<const SemanticContext> semanticContext);
-    ATNConfig(ATNConfig const& other, ATNState *state, Ref<const PredictionContext> context);
-    ATNConfig(ATNConfig const& other, ATNState *state, Ref<const PredictionContext> context, Ref<const SemanticContext> semanticContext);
-
-    ATNConfig(ATNConfig const&) = default;
-
-    ATNConfig(ATNConfig&&) = default;
-
-    virtual ~ATNConfig() = default;
-
-    virtual size_t hashCode() const;
-
-    /**
-     * This method gets the value of the {@link #reachesIntoOuterContext} field
-     * as it existed prior to the introduction of the
-     * {@link #isPrecedenceFilterSuppressed} method.
-     */
-    size_t getOuterContextDepth() const;
-    bool isPrecedenceFilterSuppressed() const;
-    void setPrecedenceFilterSuppressed(bool value);
-
-    /// An ATN configuration is equal to another if both have
-    /// the same state, they predict the same alternative, and
-    /// syntactic/semantic contexts are the same.
-    bool operator==(const ATNConfig &other) const;
-    bool operator!=(const ATNConfig &other) const;
-
-    virtual std::string toString() const;
-    std::string toString(bool showAlt) const;
-
-  private:
-    ATNConfig(ATNState *state, size_t alt, Ref<const PredictionContext> context, size_t reachesIntoOuterContext, Ref<const SemanticContext> semanticContext);
-  };
-
-} // namespace atn
-} // namespace antlr4
-
-
-// Hash function for ATNConfig.
-
-namespace std {
-  using antlr4::atn::ATNConfig;
-
-  template <> struct hash<ATNConfig>
-  {
-    size_t operator() (const ATNConfig &x) const
-    {
-      return x.hashCode();
-    }
-  };
-
-  template <> struct hash<std::vector<Ref<ATNConfig>>>
-  {
-    size_t operator() (const std::vector<Ref<ATNConfig>> &vector) const
-    {
-      std::size_t seed = 0;
-      for (const auto &config : vector) {
-        seed ^= config->hashCode() + 0x9e3779b9 + (seed << 6) + (seed >> 2);
-      }
-      return seed;
-    }
-  };
-}

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

@@ -1,233 +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.
- */
-
-#include "atn/PredictionContext.h"
-#include "atn/ATNConfig.h"
-#include "atn/ATNSimulator.h"
-#include "Exceptions.h"
-#include "atn/SemanticContext.h"
-#include "support/Arrays.h"
-
-#include "atn/ATNConfigSet.h"
-
-using namespace antlr4::atn;
-using namespace antlrcpp;
-
-namespace {
-
-}
-
-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");
-  }
-  if (config->semanticContext != SemanticContext::Empty::Instance) {
-    hasSemanticContext = true;
-  }
-  if (config->getOuterContextDepth() > 0) {
-    dipsIntoOuterContext = true;
-  }
-
-  auto existing = _configLookup.find(config.get());
-  if (existing == _configLookup.end()) {
-    _configLookup.insert(config.get());
-    _cachedHashCode = 0;
-    configs.push_back(config); // track order here
-
-    return true;
-  }
-
-  // a previous (s,i,pi,_), merge with it and save result
-  bool rootIsWildcard = !fullCtx;
-  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);
-
-  // make sure to preserve the precedence filter suppression during the merge
-  if (config->isPrecedenceFilterSuppressed()) {
-    (*existing)->setPrecedenceFilterSuppressed(true);
-  }
-
-  (*existing)->context = std::move(merged); // replace context; no need to alt mapping
-
-  return true;
-}
-
-bool ATNConfigSet::addAll(const ATNConfigSet &other) {
-  for (const auto &c : other.configs) {
-    add(c);
-  }
-  return false;
-}
-
-std::vector<ATNState*> ATNConfigSet::getStates() const {
-  std::vector<ATNState*> states;
-  states.reserve(configs.size());
-  for (const auto &c : configs) {
-    states.push_back(c->state);
-  }
-  return states;
-}
-
-/**
- * Gets the complete set of represented alternatives for the configuration
- * set.
- *
- * @return the set of represented alternatives in this configuration set
- *
- * @since 4.3
- */
-
-BitSet ATNConfigSet::getAlts() const {
-  BitSet alts;
-  for (const auto &config : configs) {
-    alts.set(config->alt);
-  }
-  return alts;
-}
-
-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::Empty::Instance) {
-      preds.push_back(c->semanticContext);
-    }
-  }
-  return preds;
-}
-
-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 (const auto &config : configs) {
-    config->context = interpreter->getCachedContext(config->context);
-  }
-}
-
-bool ATNConfigSet::equals(const ATNConfigSet &other) const {
-  if (&other == this) {
-    return true;
-  }
-
-  if (configs.size() != other.configs.size())
-    return false;
-
-  if (fullCtx != other.fullCtx || uniqueAlt != other.uniqueAlt ||
-      conflictingAlts != other.conflictingAlts || hasSemanticContext != other.hasSemanticContext ||
-      dipsIntoOuterContext != other.dipsIntoOuterContext) // includes stack context
-    return false;
-
-  return Arrays::equals(configs, other.configs);
-}
-
-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;
-}
-
-size_t ATNConfigSet::size() const {
-  return configs.size();
-}
-
-bool ATNConfigSet::isEmpty() const {
-  return configs.empty();
-}
-
-void ATNConfigSet::clear() {
-  if (_readonly) {
-    throw IllegalStateException("This set is readonly");
-  }
-  configs.clear();
-  _cachedHashCode = 0;
-  _configLookup.clear();
-}
-
-bool ATNConfigSet::isReadonly() const {
-  return _readonly;
-}
-
-void ATNConfigSet::setReadonly(bool readonly) {
-  _readonly = readonly;
-  LookupContainer(0, ATNConfigHasher{this}, ATNConfigComparer{this}).swap(_configLookup);
-}
-
-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?"true":"false");
-  }
-  if (uniqueAlt != ATN::INVALID_ALT_NUMBER) {
-    ss << ",uniqueAlt=" << uniqueAlt;
-  }
-
-  if (conflictingAlts.count() > 0) {
-    ss << ",conflictingAlts=";
-    ss << conflictingAlts.toString();
-  }
-
-  if (dipsIntoOuterContext) {
-    ss << ",dipsIntoOuterContext";
-  }
-  return ss.str();
-}
-
-size_t ATNConfigSet::hashCode(const ATNConfig &other) const {
-  size_t hashCode = 7;
-  hashCode = 31 * hashCode + other.state->stateNumber;
-  hashCode = 31 * hashCode + other.alt;
-  hashCode = 31 * hashCode + other.semanticContext->hashCode();
-  return hashCode;
-}
-
-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

@@ -1,157 +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 <cassert>
-
-#include "support/BitSet.h"
-#include "atn/PredictionContext.h"
-#include "atn/ATNConfig.h"
-#include "FlatHashSet.h"
-
-namespace antlr4 {
-namespace atn {
-
-  /// Specialized set that can track info about the set, with support for combining similar configurations using a
-  /// graph-structured stack.
-  class ANTLR4CPP_PUBLIC ATNConfigSet {
-  public:
-    /// Track the elements as they are added to the set; supports get(i)
-    std::vector<Ref<ATNConfig>> configs;
-
-    // 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 = 0;
-
-    /** Currently this is only used when we detect SLL conflict; this does
-     *  not necessarily represent the ambiguous alternatives. In fact,
-     *  I should also point out that this seems to include predicated alternatives
-     *  that have predicates that evaluate to false. Computed in computeTargetState().
-     */
-    antlrcpp::BitSet conflictingAlts;
-
-    // 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 = 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 = true;
-
-    ATNConfigSet();
-
-    ATNConfigSet(const ATNConfigSet &other);
-
-    ATNConfigSet(ATNConfigSet&&) = delete;
-
-    explicit ATNConfigSet(bool fullCtx);
-
-    virtual ~ATNConfigSet() = default;
-
-    bool add(const Ref<ATNConfig> &config);
-
-    /// <summary>
-    /// Adding a new config means merging contexts with existing configs for
-    /// {@code (s, i, pi, _)}, where {@code s} is the
-    /// <seealso cref="ATNConfig#state"/>, {@code i} is the <seealso cref="ATNConfig#alt"/>, and
-    /// {@code pi} is the <seealso cref="ATNConfig#semanticContext"/>. We use
-    /// {@code (s,i,pi)} as key.
-    /// <p/>
-    /// This method updates <seealso cref="#dipsIntoOuterContext"/> and
-    /// <seealso cref="#hasSemanticContext"/> when necessary.
-    /// </summary>
-    bool add(const Ref<ATNConfig> &config, PredictionContextMergeCache *mergeCache);
-
-    bool addAll(const ATNConfigSet &other);
-
-    std::vector<ATNState*> getStates() const;
-
-    /**
-     * Gets the complete set of represented alternatives for the configuration
-     * set.
-     *
-     * @return the set of represented alternatives in this configuration set
-     *
-     * @since 4.3
-     */
-    antlrcpp::BitSet getAlts() const;
-    std::vector<Ref<const SemanticContext>> getPredicates() const;
-
-    const Ref<ATNConfig>& get(size_t i) const;
-
-    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;
-
-      size_t operator()(const ATNConfig *other) const {
-        assert(other != nullptr);
-        return atnConfigSet->hashCode(*other);
-      }
-    };
-
-    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;
-
-    /// 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 = false;
-
-    virtual size_t hashCode(const ATNConfig &atnConfig) const;
-
-    virtual bool equals(const ATNConfig &lhs, const ATNConfig &rhs) const;
-
-    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.
-    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

@@ -1,39 +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.
- */
-
-#include "atn/ATNDeserializationOptions.h"
-#include "Exceptions.h"
-
-using namespace antlr4;
-using namespace antlr4::atn;
-
-ATNDeserializationOptions::ATNDeserializationOptions(ATNDeserializationOptions *options)
-    : _readOnly(false), _verifyATN(options->_verifyATN),
-      _generateRuleBypassTransitions(options->_generateRuleBypassTransitions) {}
-
-const ATNDeserializationOptions& ATNDeserializationOptions::getDefaultOptions() {
-  static const ATNDeserializationOptions* const defaultOptions = new ATNDeserializationOptions();
-  return *defaultOptions;
-}
-
-void ATNDeserializationOptions::makeReadOnly() {
-  _readOnly = true;
-}
-
-void ATNDeserializationOptions::setVerifyATN(bool verify) {
-  throwIfReadOnly();
-  _verifyATN = verify;
-}
-
-void ATNDeserializationOptions::setGenerateRuleBypassTransitions(bool generate) {
-  throwIfReadOnly();
-  _generateRuleBypassTransitions = generate;
-}
-
-void ATNDeserializationOptions::throwIfReadOnly() const {
-  if (isReadOnly()) {
-    throw IllegalStateException("ATNDeserializationOptions is read only.");
-  }
-}

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

@@ -1,48 +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 "antlr4-common.h"
-
-namespace antlr4 {
-namespace atn {
-
-class ANTLR4CPP_PUBLIC ATNDeserializationOptions final {
-public:
-  ATNDeserializationOptions()
-    : _readOnly(false), _verifyATN(true), _generateRuleBypassTransitions(false) {}
-
-  // TODO: Is this useful? If so we should mark it as explicit, otherwise remove it.
-  ATNDeserializationOptions(ATNDeserializationOptions *options);
-
-  ATNDeserializationOptions(const ATNDeserializationOptions&) = default;
-
-  ATNDeserializationOptions& operator=(const ATNDeserializationOptions&) = default;
-
-  static const ATNDeserializationOptions& getDefaultOptions();
-
-  bool isReadOnly() const { return _readOnly; }
-
-  void makeReadOnly();
-
-  bool isVerifyATN() const { return _verifyATN; }
-
-  void setVerifyATN(bool verify);
-
-  bool isGenerateRuleBypassTransitions() const { return _generateRuleBypassTransitions; }
-
-  void setGenerateRuleBypassTransitions(bool generate);
-
-private:
-  void throwIfReadOnly() const;
-
-  bool _readOnly;
-  bool _verifyATN;
-  bool _generateRuleBypassTransitions;
-};
-
-} // namespace atn
-} // namespace antlr4