python3-parser 1.0.0

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

@@ -0,0 +1,98 @@
+/* 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 "Exceptions.h"
+
+namespace antlr4 {
+
+  /// The root of the ANTLR exception hierarchy. In general, ANTLR tracks just
+  /// 3 kinds of errors: prediction errors, failed predicate errors, and
+  /// mismatched input errors. In each case, the parser knows where it is
+  /// in the input, where it is in the ATN, the rule invocation stack,
+  /// and what kind of problem occurred.
+  class ANTLR4CPP_PUBLIC RecognitionException : public RuntimeException {
+  private:
+    /// The Recognizer where this exception originated.
+    Recognizer *_recognizer;
+    IntStream *_input;
+    ParserRuleContext *_ctx;
+
+    /// The current Token when an error occurred. Since not all streams
+    /// support accessing symbols by index, we have to track the Token
+    /// instance itself.
+    Token *_offendingToken;
+
+    size_t _offendingState;
+
+  public:
+    RecognitionException(Recognizer *recognizer, IntStream *input, ParserRuleContext *ctx,
+                         Token *offendingToken = nullptr);
+    RecognitionException(const std::string &message, Recognizer *recognizer, IntStream *input,
+                         ParserRuleContext *ctx, Token *offendingToken = nullptr);
+    RecognitionException(RecognitionException const&) = default;
+    ~RecognitionException();
+    RecognitionException& operator=(RecognitionException const&) = default;
+
+    /// Get the ATN state number the parser was in at the time the error
+    /// occurred. For NoViableAltException and
+    /// LexerNoViableAltException exceptions, this is the
+    /// DecisionState number. For others, it is the state whose outgoing
+    /// edge we couldn't match.
+    ///
+    /// If the state number is not known, this method returns -1.
+    virtual size_t getOffendingState() const;
+
+  protected:
+    void setOffendingState(size_t offendingState);
+
+    /// Gets the set of input symbols which could potentially follow the
+    /// previously matched symbol at the time this exception was thrown.
+    ///
+    /// If the set of expected tokens is not known and could not be computed,
+    /// this method returns an empty set.
+    ///
+    /// @returns The set of token types that could potentially follow the current
+    /// state in the ATN, or an empty set if the information is not available.
+  public:
+    virtual misc::IntervalSet getExpectedTokens() const;
+
+    /// <summary>
+    /// Gets the <seealso cref="RuleContext"/> at the time this exception was thrown.
+    /// <p/>
+    /// If the context is not available, this method returns {@code null}.
+    /// </summary>
+    /// <returns> The <seealso cref="RuleContext"/> at the time this exception was thrown.
+    /// If the context is not available, this method returns {@code null}. </returns>
+    virtual RuleContext* getCtx() const;
+
+    /// <summary>
+    /// Gets the input stream which is the symbol source for the recognizer where
+    /// this exception was thrown.
+    /// <p/>
+    /// If the input stream is not available, this method returns {@code null}.
+    /// </summary>
+    /// <returns> The input stream which is the symbol source for the recognizer
+    /// where this exception was thrown, or {@code null} if the stream is not
+    /// available. </returns>
+    virtual IntStream* getInputStream() const;
+
+    virtual Token* getOffendingToken() const;
+
+    /// <summary>
+    /// Gets the <seealso cref="Recognizer"/> where this exception occurred.
+    /// <p/>
+    /// If the recognizer is not available, this method returns {@code null}.
+    /// </summary>
+    /// <returns> The recognizer where this exception occurred, or {@code null} if
+    /// the recognizer is not available. </returns>
+    virtual Recognizer* getRecognizer() const;
+
+  private:
+    void InitializeInstanceFields();
+  };
+
+} // namespace antlr4

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

@@ -0,0 +1,167 @@
+/* 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 "ConsoleErrorListener.h"
+#include "RecognitionException.h"
+#include "support/CPPUtils.h"
+#include "support/StringUtils.h"
+#include "Token.h"
+#include "atn/ATN.h"
+#include "atn/ATNSimulator.h"
+#include "support/CPPUtils.h"
+
+#include "Vocabulary.h"
+
+#include "Recognizer.h"
+
+using namespace antlr4;
+using namespace antlr4::atn;
+
+std::map<const dfa::Vocabulary*, std::map<std::string, size_t>> Recognizer::_tokenTypeMapCache;
+std::map<std::vector<std::string>, std::map<std::string, size_t>> Recognizer::_ruleIndexMapCache;
+
+Recognizer::Recognizer() {
+  InitializeInstanceFields();
+  _proxListener.addErrorListener(&ConsoleErrorListener::INSTANCE);
+}
+
+Recognizer::~Recognizer() {
+}
+
+dfa::Vocabulary const& Recognizer::getVocabulary() const {
+  static dfa::Vocabulary vocabulary = dfa::Vocabulary::fromTokenNames(getTokenNames());
+  return vocabulary;
+}
+
+std::map<std::string, size_t> Recognizer::getTokenTypeMap() {
+  const dfa::Vocabulary& vocabulary = getVocabulary();
+
+  std::lock_guard<std::mutex> lck(_mutex);
+  std::map<std::string, size_t> result;
+  auto iterator = _tokenTypeMapCache.find(&vocabulary);
+  if (iterator != _tokenTypeMapCache.end()) {
+    result = iterator->second;
+  } else {
+    for (size_t i = 0; i <= getATN().maxTokenType; ++i) {
+      std::string literalName = vocabulary.getLiteralName(i);
+      if (!literalName.empty()) {
+        result[literalName] = i;
+      }
+
+      std::string symbolicName = vocabulary.getSymbolicName(i);
+      if (!symbolicName.empty()) {
+        result[symbolicName] = i;
+      }
+				}
+    result["EOF"] = EOF;
+    _tokenTypeMapCache[&vocabulary] = result;
+  }
+
+  return result;
+}
+
+std::map<std::string, size_t> Recognizer::getRuleIndexMap() {
+  const std::vector<std::string>& ruleNames = getRuleNames();
+  if (ruleNames.empty()) {
+    throw "The current recognizer does not provide a list of rule names.";
+  }
+
+  std::lock_guard<std::mutex> lck(_mutex);
+  std::map<std::string, size_t> result;
+  auto iterator = _ruleIndexMapCache.find(ruleNames);
+  if (iterator != _ruleIndexMapCache.end()) {
+    result = iterator->second;
+  } else {
+    result = antlrcpp::toMap(ruleNames);
+    _ruleIndexMapCache[ruleNames] = result;
+  }
+  return result;
+}
+
+size_t Recognizer::getTokenType(const std::string &tokenName) {
+  const std::map<std::string, size_t> &map = getTokenTypeMap();
+  auto iterator = map.find(tokenName);
+  if (iterator == map.end())
+    return Token::INVALID_TYPE;
+
+  return iterator->second;
+}
+
+void Recognizer::setInterpreter(atn::ATNSimulator *interpreter) {
+  // Usually the interpreter is set by the descendant (lexer or parser (simulator), but can also be exchanged
+  // by the profiling ATN simulator.
+  delete _interpreter;
+  _interpreter = interpreter;
+}
+
+std::string Recognizer::getErrorHeader(RecognitionException *e) {
+  // We're having issues with cross header dependencies, these two classes will need to be
+  // rewritten to remove that.
+  size_t line = e->getOffendingToken()->getLine();
+  size_t charPositionInLine = e->getOffendingToken()->getCharPositionInLine();
+  return std::string("line ") + std::to_string(line) + ":" + std::to_string(charPositionInLine);
+
+}
+
+std::string Recognizer::getTokenErrorDisplay(Token *t) {
+  if (t == nullptr) {
+    return "<no Token>";
+  }
+  std::string s = t->getText();
+  if (s == "") {
+    if (t->getType() == EOF) {
+      s = "<EOF>";
+    } else {
+      s = std::string("<") + std::to_string(t->getType()) + std::string(">");
+    }
+  }
+
+  antlrcpp::replaceAll(s, "\n", "\\n");
+  antlrcpp::replaceAll(s, "\r","\\r");
+  antlrcpp::replaceAll(s, "\t", "\\t");
+
+  return "'" + s + "'";
+}
+
+void Recognizer::addErrorListener(ANTLRErrorListener *listener) {
+  _proxListener.addErrorListener(listener);
+}
+
+void Recognizer::removeErrorListener(ANTLRErrorListener *listener) {
+  _proxListener.removeErrorListener(listener);
+}
+
+void Recognizer::removeErrorListeners() {
+  _proxListener.removeErrorListeners();
+}
+
+ProxyErrorListener& Recognizer::getErrorListenerDispatch() {
+  return _proxListener;
+}
+
+bool Recognizer::sempred(RuleContext * /*localctx*/, size_t /*ruleIndex*/, size_t /*actionIndex*/) {
+  return true;
+}
+
+bool Recognizer::precpred(RuleContext * /*localctx*/, int /*precedence*/) {
+  return true;
+}
+
+void Recognizer::action(RuleContext * /*localctx*/, size_t /*ruleIndex*/, size_t /*actionIndex*/) {
+}
+
+size_t Recognizer::getState() const {
+  return _stateNumber;
+}
+
+void Recognizer::setState(size_t atnState) {
+  _stateNumber = atnState;
+}
+
+void Recognizer::InitializeInstanceFields() {
+  _stateNumber = ATNState::INVALID_STATE_NUMBER;
+  _interpreter = nullptr;
+}
+

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

@@ -0,0 +1,164 @@
+/* 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 "ProxyErrorListener.h"
+
+namespace antlr4 {
+
+  class ANTLR4CPP_PUBLIC Recognizer {
+  public:
+    static const size_t EOF = static_cast<size_t>(-1); // std::numeric_limits<size_t>::max(); doesn't work in VS 2013.
+
+    Recognizer();
+    Recognizer(Recognizer const&) = delete;
+    virtual ~Recognizer();
+
+    Recognizer& operator=(Recognizer const&) = delete;
+
+    /** Used to print out token names like ID during debugging and
+     *  error reporting.  The generated parsers implement a method
+     *  that overrides this to point to their String[] tokenNames.
+     *
+     * @deprecated Use {@link #getVocabulary()} instead.
+     */
+    virtual std::vector<std::string> const& getTokenNames() const = 0;
+    virtual std::vector<std::string> const& getRuleNames() const = 0;
+
+    /**
+     * Get the vocabulary used by the recognizer.
+     *
+     * @return A {@link Vocabulary} instance providing information about the
+     * vocabulary used by the grammar.
+     */
+    virtual dfa::Vocabulary const& getVocabulary() const;
+
+    /// <summary>
+    /// Get a map from token names to token types.
+    /// <p/>
+    /// Used for XPath and tree pattern compilation.
+    /// </summary>
+    virtual std::map<std::string, size_t> getTokenTypeMap();
+
+    /// <summary>
+    /// Get a map from rule names to rule indexes.
+    /// <p/>
+    /// Used for XPath and tree pattern compilation.
+    /// </summary>
+    virtual std::map<std::string, size_t> getRuleIndexMap();
+
+    virtual size_t getTokenType(const std::string &tokenName);
+
+    /// <summary>
+    /// If this recognizer was generated, it will have a serialized ATN
+    /// representation of the grammar.
+    /// <p/>
+    /// For interpreters, we don't know their serialized ATN despite having
+    /// created the interpreter from it.
+    /// </summary>
+    virtual const std::vector<uint16_t> getSerializedATN() const {
+      throw "there is no serialized ATN";
+    }
+
+    /// <summary>
+    /// For debugging and other purposes, might want the grammar name.
+    ///  Have ANTLR generate an implementation for this method.
+    /// </summary>
+    virtual std::string getGrammarFileName() const = 0;
+
+    /// Get the ATN interpreter (in fact one of it's descendants) used by the recognizer for prediction.
+    /// @returns The ATN interpreter used by the recognizer for prediction.
+    template <class T>
+    T* getInterpreter() const {
+      return dynamic_cast<T *>(_interpreter);
+    }
+
+    /**
+     * Set the ATN interpreter used by the recognizer for prediction.
+     *
+     * @param interpreter The ATN interpreter used by the recognizer for
+     * prediction.
+     */
+    void setInterpreter(atn::ATNSimulator *interpreter);
+
+    /// What is the error header, normally line/character position information?
+    virtual std::string getErrorHeader(RecognitionException *e);
+
+    /** How should a token be displayed in an error message? The default
+     *  is to display just the text, but during development you might
+     *  want to have a lot of information spit out.  Override in that case
+     *  to use t.toString() (which, for CommonToken, dumps everything about
+     *  the token). This is better than forcing you to override a method in
+     *  your token objects because you don't have to go modify your lexer
+     *  so that it creates a new Java type.
+     *
+     * @deprecated This method is not called by the ANTLR 4 Runtime. Specific
+     * implementations of {@link ANTLRErrorStrategy} may provide a similar
+     * feature when necessary. For example, see
+     * {@link DefaultErrorStrategy#getTokenErrorDisplay}.
+     */
+    virtual std::string getTokenErrorDisplay(Token *t);
+
+    /// <exception cref="NullPointerException"> if {@code listener} is {@code null}. </exception>
+    virtual void addErrorListener(ANTLRErrorListener *listener);
+
+    virtual void removeErrorListener(ANTLRErrorListener *listener);
+
+    virtual void removeErrorListeners();
+
+    virtual ProxyErrorListener& getErrorListenerDispatch();
+
+    // subclass needs to override these if there are sempreds or actions
+    // that the ATN interp needs to execute
+    virtual bool sempred(RuleContext *localctx, size_t ruleIndex, size_t actionIndex);
+
+    virtual bool precpred(RuleContext *localctx, int precedence);
+
+    virtual void action(RuleContext *localctx, size_t ruleIndex, size_t actionIndex);
+
+    virtual size_t getState() const ;
+
+    // Get the ATN used by the recognizer for prediction.
+    virtual const atn::ATN& getATN() const = 0;
+
+    /// <summary>
+    /// Indicate that the recognizer has changed internal state that is
+    ///  consistent with the ATN state passed in.  This way we always know
+    ///  where we are in the ATN as the parser goes along. The rule
+    ///  context objects form a stack that lets us see the stack of
+    ///  invoking rules. Combine this and we have complete ATN
+    ///  configuration information.
+    /// </summary>
+    void setState(size_t atnState);
+
+    virtual IntStream* getInputStream() = 0;
+
+    virtual void setInputStream(IntStream *input) = 0;
+
+    virtual Ref<TokenFactory<CommonToken>> getTokenFactory() = 0;
+
+    template<typename T1>
+    void setTokenFactory(TokenFactory<T1> *input);
+
+  protected:
+    atn::ATNSimulator *_interpreter; // Set and deleted in descendants (or the profiler).
+
+    // Mutex to manage synchronized access for multithreading.
+    std::mutex _mutex;
+
+  private:
+    static std::map<const dfa::Vocabulary*, std::map<std::string, size_t>> _tokenTypeMapCache;
+    static std::map<std::vector<std::string>, std::map<std::string, size_t>> _ruleIndexMapCache;
+
+    ProxyErrorListener _proxListener; // Manages a collection of listeners.
+
+    size_t _stateNumber;
+
+    void InitializeInstanceFields();
+
+  };
+
+} // namespace antlr4

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

@@ -0,0 +1,143 @@
+/* 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 "tree/Trees.h"
+#include "misc/Interval.h"
+#include "Parser.h"
+#include "atn/ATN.h"
+#include "atn/ATNState.h"
+#include "tree/ParseTreeVisitor.h"
+
+#include "RuleContext.h"
+
+using namespace antlr4;
+using namespace antlr4::atn;
+
+RuleContext::RuleContext() {
+  InitializeInstanceFields();
+}
+
+RuleContext::RuleContext(RuleContext *parent_, size_t invokingState_) {
+  InitializeInstanceFields();
+  this->parent = parent_;
+  this->invokingState = invokingState_;
+}
+
+int RuleContext::depth() {
+  int n = 1;
+  RuleContext *p = this;
+  while (true) {
+    if (p->parent == nullptr)
+      break;
+    p = static_cast<RuleContext *>(p->parent);
+    n++;
+  }
+  return n;
+}
+
+bool RuleContext::isEmpty() {
+  return invokingState == ATNState::INVALID_STATE_NUMBER;
+}
+
+misc::Interval RuleContext::getSourceInterval() {
+  return misc::Interval::INVALID;
+}
+
+std::string RuleContext::getText() {
+  if (children.empty()) {
+    return "";
+  }
+
+  std::stringstream ss;
+  for (size_t i = 0; i < children.size(); i++) {
+    ParseTree *tree = children[i];
+    if (tree != nullptr)
+      ss << tree->getText();
+  }
+
+  return ss.str();
+}
+
+size_t RuleContext::getRuleIndex() const {
+  return INVALID_INDEX;
+}
+
+size_t RuleContext::getAltNumber() const {
+  return atn::ATN::INVALID_ALT_NUMBER;
+}
+
+void RuleContext::setAltNumber(size_t /*altNumber*/) {
+}
+
+antlrcpp::Any RuleContext::accept(tree::ParseTreeVisitor *visitor) {
+  return visitor->visitChildren(this);
+}
+
+std::string RuleContext::toStringTree(Parser *recog, bool pretty) {
+  return tree::Trees::toStringTree(this, recog, pretty);
+}
+
+std::string RuleContext::toStringTree(std::vector<std::string> &ruleNames, bool pretty) {
+  return tree::Trees::toStringTree(this, ruleNames, pretty);
+}
+
+std::string RuleContext::toStringTree(bool pretty) {
+  return toStringTree(nullptr, pretty);
+}
+
+
+std::string RuleContext::toString(const std::vector<std::string> &ruleNames) {
+  return toString(ruleNames, nullptr);
+}
+
+
+std::string RuleContext::toString(const std::vector<std::string> &ruleNames, RuleContext *stop) {
+  std::stringstream ss;
+
+  RuleContext *currentParent = this;
+  ss << "[";
+  while (currentParent != stop) {
+    if (ruleNames.empty()) {
+      if (!currentParent->isEmpty()) {
+        ss << currentParent->invokingState;
+      }
+    } else {
+      size_t ruleIndex = currentParent->getRuleIndex();
+
+      std::string ruleName = (ruleIndex < ruleNames.size()) ? ruleNames[ruleIndex] : std::to_string(ruleIndex);
+      ss << ruleName;
+    }
+
+    if (currentParent->parent == nullptr) // No parent anymore.
+      break;
+    currentParent = static_cast<RuleContext *>(currentParent->parent);
+    if (!ruleNames.empty() || !currentParent->isEmpty()) {
+      ss << " ";
+    }
+  }
+
+  ss << "]";
+
+  return ss.str();
+}
+
+std::string RuleContext::toString() {
+  return toString(nullptr);
+}
+
+std::string RuleContext::toString(Recognizer *recog) {
+  return toString(recog, &ParserRuleContext::EMPTY);
+}
+
+std::string RuleContext::toString(Recognizer *recog, RuleContext *stop) {
+  if (recog == nullptr)
+    return toString(std::vector<std::string>(), stop); // Don't use an initializer {} here or we end up calling ourselve recursivly.
+  return toString(recog->getRuleNames(), stop);
+}
+
+void RuleContext::InitializeInstanceFields() {
+  invokingState = INVALID_INDEX;
+}
+