python3-parser 1.0.0

data/ext/python3-parser/antlr4-upstream/runtime/Cpp/runtime/src/atn/ATNConfig.cpp

@@ -0,0 +1,113 @@
+/* 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 "misc/MurmurHash.h"
+#include "atn/PredictionContext.h"
+#include "SemanticContext.h"
+
+#include "atn/ATNConfig.h"
+
+using namespace antlr4::atn;
+
+const size_t ATNConfig::SUPPRESS_PRECEDENCE_FILTER = 0x40000000;
+
+ATNConfig::ATNConfig(ATNState *state_, size_t alt_, Ref<PredictionContext> const& context_)
+  : ATNConfig(state_, alt_, context_, SemanticContext::NONE) {
+}
+
+ATNConfig::ATNConfig(ATNState *state_, size_t alt_, Ref<PredictionContext> const& context_, Ref<SemanticContext> const& semanticContext_)
+  : state(state_), alt(alt_), context(context_), semanticContext(semanticContext_) {
+  reachesIntoOuterContext = 0;
+}
+
+ATNConfig::ATNConfig(Ref<ATNConfig> const& c) : ATNConfig(c, c->state, c->context, c->semanticContext) {
+}
+
+ATNConfig::ATNConfig(Ref<ATNConfig> const& c, ATNState *state_) : ATNConfig(c, state_, c->context, c->semanticContext) {
+}
+
+ATNConfig::ATNConfig(Ref<ATNConfig> const& c, ATNState *state, Ref<SemanticContext> const& semanticContext)
+  : ATNConfig(c, state, c->context, semanticContext) {
+}
+
+ATNConfig::ATNConfig(Ref<ATNConfig> const& c, Ref<SemanticContext> const& semanticContext)
+  : ATNConfig(c, c->state, c->context, semanticContext) {
+}
+
+ATNConfig::ATNConfig(Ref<ATNConfig> const& c, ATNState *state, Ref<PredictionContext> const& context)
+  : ATNConfig(c, state, context, c->semanticContext) {
+}
+
+ATNConfig::ATNConfig(Ref<ATNConfig> const& c, ATNState *state, Ref<PredictionContext> const& context,
+                     Ref<SemanticContext> const& semanticContext)
+  : state(state), alt(c->alt), context(context), reachesIntoOuterContext(c->reachesIntoOuterContext),
+    semanticContext(semanticContext) {
+}
+
+ATNConfig::~ATNConfig() {
+}
+
+size_t ATNConfig::hashCode() const {
+  size_t hashCode = misc::MurmurHash::initialize(7);
+  hashCode = misc::MurmurHash::update(hashCode, state->stateNumber);
+  hashCode = misc::MurmurHash::update(hashCode, alt);
+  hashCode = misc::MurmurHash::update(hashCode, context);
+  hashCode = misc::MurmurHash::update(hashCode, semanticContext);
+  hashCode = misc::MurmurHash::finish(hashCode, 4);
+  return hashCode;
+}
+
+size_t ATNConfig::getOuterContextDepth() const {
+  return reachesIntoOuterContext & ~SUPPRESS_PRECEDENCE_FILTER;
+}
+
+bool ATNConfig::isPrecedenceFilterSuppressed() const {
+  return (reachesIntoOuterContext & SUPPRESS_PRECEDENCE_FILTER) != 0;
+}
+
+void ATNConfig::setPrecedenceFilterSuppressed(bool value) {
+  if (value) {
+    reachesIntoOuterContext |= SUPPRESS_PRECEDENCE_FILTER;
+  } else {
+    reachesIntoOuterContext &= ~SUPPRESS_PRECEDENCE_FILTER;
+  }
+}
+
+bool ATNConfig::operator == (const ATNConfig &other) const {
+  return state->stateNumber == other.state->stateNumber && alt == other.alt &&
+    ((context == other.context) || (*context == *other.context)) &&
+    *semanticContext == *other.semanticContext &&
+    isPrecedenceFilterSuppressed() == other.isPrecedenceFilterSuppressed();
+}
+
+bool ATNConfig::operator != (const ATNConfig &other) const {
+  return !operator==(other);
+}
+
+std::string ATNConfig::toString() {
+  return toString(true);
+}
+
+std::string ATNConfig::toString(bool showAlt) {
+  std::stringstream ss;
+  ss << "(";
+
+  ss << state->toString();
+  if (showAlt) {
+    ss << "," << alt;
+  }
+  if (context) {
+    ss << ",[" << context->toString() << "]";
+  }
+  if (semanticContext != nullptr && semanticContext != SemanticContext::NONE) {
+    ss << "," << semanticContext.get();
+  }
+  if (getOuterContextDepth() > 0) {
+    ss << ",up=" << getOuterContextDepth();
+  }
+  ss << ')';
+
+  return ss.str();
+}

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

@@ -0,0 +1,148 @@
+/* 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
+
+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()(ATNConfig const& k) const {
+        return k.hashCode();
+      }
+    };
+
+    struct Comparer {
+      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;
+
+    /// What alt (or lexer rule) is predicted by this configuration.
+    const size_t alt;
+
+    /// 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<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;
+
+    /// Can be shared between multiple ATNConfig instances.
+    Ref<SemanticContext> semanticContext;
+
+    ATNConfig(ATNState *state, size_t alt, Ref<PredictionContext> const& context);
+    ATNConfig(ATNState *state, size_t alt, Ref<PredictionContext> const& context, Ref<SemanticContext> const& semanticContext);
+
+    ATNConfig(Ref<ATNConfig> const& c); // dup
+    ATNConfig(Ref<ATNConfig> const& c, ATNState *state);
+    ATNConfig(Ref<ATNConfig> const& c, ATNState *state, Ref<SemanticContext> const& semanticContext);
+    ATNConfig(Ref<ATNConfig> const& c, Ref<SemanticContext> const& semanticContext);
+    ATNConfig(Ref<ATNConfig> const& c, ATNState *state, Ref<PredictionContext> const& context);
+    ATNConfig(Ref<ATNConfig> const& c, ATNState *state, Ref<PredictionContext> const& context, Ref<SemanticContext> const& semanticContext);
+
+    ATNConfig(ATNConfig const&) = default;
+    virtual ~ATNConfig();
+
+    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();
+    std::string toString(bool showAlt);
+
+  private:
+    /**
+     * This field stores the bit mask for implementing the
+     * {@link #isPrecedenceFilterSuppressed} property as a bit within the
+     * existing {@link #reachesIntoOuterContext} field.
+     */
+    static const size_t SUPPRESS_PRECEDENCE_FILTER;
+  };
+
+} // 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 (auto &config : vector) {
+        seed ^= config->hashCode() + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+      }
+      return seed;
+    }
+  };
+}

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

@@ -0,0 +1,228 @@
+/* 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;
+
+ATNConfigSet::ATNConfigSet(bool fullCtx) : fullCtx(fullCtx) {
+  InitializeInstanceFields();
+}
+
+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() {
+}
+
+bool ATNConfigSet::add(const Ref<ATNConfig> &config) {
+  return add(config, nullptr);
+}
+
+bool ATNConfigSet::add(const Ref<ATNConfig> &config, PredictionContextMergeCache *mergeCache) {
+  if (_readonly) {
+    throw IllegalStateException("This set is readonly");
+  }
+  if (config->semanticContext != SemanticContext::NONE) {
+    hasSemanticContext = true;
+  }
+  if (config->getOuterContextDepth() > 0) {
+    dipsIntoOuterContext = true;
+  }
+
+  size_t hash = getHash(config.get());
+  ATNConfig *existing = _configLookup[hash];
+  if (existing == nullptr) {
+    _configLookup[hash] = 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<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 = merged; // replace context; no need to alt mapping
+
+  return true;
+}
+
+bool ATNConfigSet::addAll(const Ref<ATNConfigSet> &other) {
+  for (auto &c : other->configs) {
+    add(c);
+  }
+  return false;
+}
+
+std::vector<ATNState*> ATNConfigSet::getStates() {
+  std::vector<ATNState*> states;
+  for (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() {
+  BitSet alts;
+  for (ATNConfig config : configs) {
+    alts.set(config.alt);
+  }
+  return alts;
+}
+
+std::vector<Ref<SemanticContext>> ATNConfigSet::getPredicates() {
+  std::vector<Ref<SemanticContext>> preds;
+  for (auto c : configs) {
+    if (c->semanticContext != SemanticContext::NONE) {
+      preds.push_back(c->semanticContext);
+    }
+  }
+  return preds;
+}
+
+Ref<ATNConfig> ATNConfigSet::get(size_t i) const {
+  return configs[i];
+}
+
+void ATNConfigSet::optimizeConfigs(ATNSimulator *interpreter) {
+  if (_readonly) {
+    throw IllegalStateException("This set is readonly");
+  }
+  if (_configLookup.empty())
+    return;
+
+  for (auto &config : configs) {
+    config->context = interpreter->getCachedContext(config->context);
+  }
+}
+
+bool ATNConfigSet::operator == (const ATNConfigSet &other) {
+  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() {
+  if (!isReadonly() || _cachedHashCode == 0) {
+    _cachedHashCode = 1;
+    for (auto &i : configs) {
+      _cachedHashCode = 31 * _cachedHashCode + i->hashCode(); // Same as Java's list hashCode impl.
+    }
+  }
+
+  return _cachedHashCode;
+}
+
+size_t ATNConfigSet::size() {
+  return configs.size();
+}
+
+bool ATNConfigSet::isEmpty() {
+  return configs.empty();
+}
+
+void ATNConfigSet::clear() {
+  if (_readonly) {
+    throw IllegalStateException("This set is readonly");
+  }
+  configs.clear();
+  _cachedHashCode = 0;
+  _configLookup.clear();
+}
+
+bool ATNConfigSet::isReadonly() {
+  return _readonly;
+}
+
+void ATNConfigSet::setReadonly(bool readonly) {
+  _readonly = readonly;
+  _configLookup.clear();
+}
+
+std::string ATNConfigSet::toString() {
+  std::stringstream ss;
+  ss << "[";
+  for (size_t i = 0; i < configs.size(); i++) {
+    ss << configs[i]->toString();
+  }
+  ss << "]";
+
+  if (hasSemanticContext) {
+    ss << ",hasSemanticContext = " <<  hasSemanticContext;
+  }
+  if (uniqueAlt != ATN::INVALID_ALT_NUMBER) {
+    ss << ",uniqueAlt = " << uniqueAlt;
+  }
+
+  if (conflictingAlts.size() > 0) {
+    ss << ",conflictingAlts = ";
+    ss << conflictingAlts.toString();
+  }
+
+  if (dipsIntoOuterContext) {
+    ss << ", dipsIntoOuterContext";
+  }
+  return ss.str();
+}
+
+size_t ATNConfigSet::getHash(ATNConfig *c) {
+  size_t hashCode = 7;
+  hashCode = 31 * hashCode + c->state->stateNumber;
+  hashCode = 31 * hashCode + c->alt;
+  hashCode = 31 * hashCode + c->semanticContext->hashCode();
+  return hashCode;
+}
+
+void ATNConfigSet::InitializeInstanceFields() {
+  uniqueAlt = 0;
+  hasSemanticContext = false;
+  dipsIntoOuterContext = false;
+
+  _readonly = false;
+  _cachedHashCode = 0;
+}