python3-parser 1.0.0

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

@@ -0,0 +1,121 @@
+/* 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 "Token.h"
+
+namespace antlr4 {
+
+  /// <summary>
+  /// The interface for defining strategies to deal with syntax errors encountered
+  /// during a parse by ANTLR-generated parsers. We distinguish between three
+  /// different kinds of errors:
+  ///
+  /// <ul>
+  /// <li>The parser could not figure out which path to take in the ATN (none of
+  /// the available alternatives could possibly match)</li>
+  /// <li>The current input does not match what we were looking for</li>
+  /// <li>A predicate evaluated to false</li>
+  /// </ul>
+  ///
+  /// Implementations of this interface report syntax errors by calling
+  /// <seealso cref="Parser#notifyErrorListeners"/>.
+  /// <p/>
+  /// TODO: what to do about lexers
+  /// </summary>
+  class ANTLR4CPP_PUBLIC ANTLRErrorStrategy {
+  public:
+
+    /// <summary>
+    /// Reset the error handler state for the specified {@code recognizer}. </summary>
+    /// <param name="recognizer"> the parser instance </param>
+    virtual ~ANTLRErrorStrategy();
+
+    virtual void reset(Parser *recognizer) = 0;
+
+    /**
+     * This method is called when an unexpected symbol is encountered during an
+     * inline match operation, such as {@link Parser#match}. If the error
+     * strategy successfully recovers from the match failure, this method
+     * returns the {@link Token} instance which should be treated as the
+     * successful result of the match.
+     *
+     * <p>This method handles the consumption of any tokens - the caller should
+     * <b>not</b> call {@link Parser#consume} after a successful recovery.</p>
+     *
+     * <p>Note that the calling code will not report an error if this method
+     * returns successfully. The error strategy implementation is responsible
+     * for calling {@link Parser#notifyErrorListeners} as appropriate.</p>
+     *
+     * @param recognizer the parser instance
+     * @throws RecognitionException if the error strategy was not able to
+     * recover from the unexpected input symbol
+     */
+    virtual Token* recoverInline(Parser *recognizer) = 0;
+
+    /// <summary>
+    /// This method is called to recover from exception {@code e}. This method is
+    /// called after <seealso cref="#reportError"/> by the default exception handler
+    /// generated for a rule method.
+    /// </summary>
+    /// <seealso cref= #reportError
+    /// </seealso>
+    /// <param name="recognizer"> the parser instance </param>
+    /// <param name="e"> the recognition exception to recover from </param>
+    /// <exception cref="RecognitionException"> if the error strategy could not recover from
+    /// the recognition exception </exception>
+    virtual void recover(Parser *recognizer, std::exception_ptr e) = 0;
+
+    /// <summary>
+    /// This method provides the error handler with an opportunity to handle
+    /// syntactic or semantic errors in the input stream before they result in a
+    /// <seealso cref="RecognitionException"/>.
+    /// <p/>
+    /// The generated code currently contains calls to <seealso cref="#sync"/> after
+    /// entering the decision state of a closure block ({@code (...)*} or
+    /// {@code (...)+}).
+    /// <p/>
+    /// For an implementation based on Jim Idle's "magic sync" mechanism, see
+    /// <seealso cref="DefaultErrorStrategy#sync"/>.
+    /// </summary>
+    /// <seealso cref= DefaultErrorStrategy#sync
+    /// </seealso>
+    /// <param name="recognizer"> the parser instance </param>
+    /// <exception cref="RecognitionException"> if an error is detected by the error
+    /// strategy but cannot be automatically recovered at the current state in
+    /// the parsing process </exception>
+    virtual void sync(Parser *recognizer) = 0;
+
+    /// <summary>
+    /// Tests whether or not {@code recognizer} is in the process of recovering
+    /// from an error. In error recovery mode, <seealso cref="Parser#consume"/> adds
+    /// symbols to the parse tree by calling
+    /// {@link Parser#createErrorNode(ParserRuleContext, Token)} then
+    /// {@link ParserRuleContext#addErrorNode(ErrorNode)} instead of
+    /// {@link Parser#createTerminalNode(ParserRuleContext, Token)}.
+    /// </summary>
+    /// <param name="recognizer"> the parser instance </param>
+    /// <returns> {@code true} if the parser is currently recovering from a parse
+    /// error, otherwise {@code false} </returns>
+    virtual bool inErrorRecoveryMode(Parser *recognizer) = 0;
+
+    /// <summary>
+    /// This method is called by when the parser successfully matches an input
+    /// symbol.
+    /// </summary>
+    /// <param name="recognizer"> the parser instance </param>
+    virtual void reportMatch(Parser *recognizer) = 0;
+
+    /// <summary>
+    /// Report any kind of <seealso cref="RecognitionException"/>. This method is called by
+    /// the default exception handler generated for a rule method.
+    /// </summary>
+    /// <param name="recognizer"> the parser instance </param>
+    /// <param name="e"> the recognition exception to report </param>
+    virtual void reportError(Parser *recognizer, const RecognitionException &e) = 0;
+  };
+
+} // namespace antlr4

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

@@ -0,0 +1,34 @@
+/* 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 "support/StringUtils.h"
+
+#include "ANTLRFileStream.h"
+
+using namespace antlr4;
+
+ANTLRFileStream::ANTLRFileStream(const std::string &fileName) {
+  _fileName = fileName;
+  loadFromFile(fileName);
+}
+
+void ANTLRFileStream::loadFromFile(const std::string &fileName) {
+  _fileName = fileName;
+  if (_fileName.empty()) {
+    return;
+  }
+
+#ifdef _MSC_VER
+  std::ifstream stream(antlrcpp::s2ws(fileName), std::ios::binary);
+#else
+  std::ifstream stream(fileName, std::ios::binary);
+#endif
+
+  ANTLRInputStream::load(stream);
+}
+
+std::string ANTLRFileStream::getSourceName() const {
+  return _fileName;
+}

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

@@ -0,0 +1,27 @@
+/* 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 "ANTLRInputStream.h"
+
+namespace antlr4 {
+
+  /// This is an ANTLRInputStream that is loaded from a file all at once
+  /// when you construct the object (or call load()).
+  // TODO: this class needs testing.
+  class ANTLR4CPP_PUBLIC ANTLRFileStream : public ANTLRInputStream {
+  protected:
+    std::string _fileName; // UTF-8 encoded file name.
+
+  public:
+    // Assumes a file name encoded in UTF-8 and file content in the same encoding (with or w/o BOM).
+    ANTLRFileStream(const std::string &fileName);
+
+    virtual void loadFromFile(const std::string &fileName);
+    virtual std::string getSourceName() const override;
+  };
+
+} // namespace antlr4

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

@@ -0,0 +1,155 @@
+/* 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 "Exceptions.h"
+#include "misc/Interval.h"
+#include "IntStream.h"
+
+#include "support/StringUtils.h"
+#include "support/CPPUtils.h"
+
+#include "ANTLRInputStream.h"
+
+using namespace antlr4;
+using namespace antlrcpp;
+
+using misc::Interval;
+
+ANTLRInputStream::ANTLRInputStream(const std::string &input) {
+  InitializeInstanceFields();
+  load(input);
+}
+
+ANTLRInputStream::ANTLRInputStream(const char data_[], size_t numberOfActualCharsInArray)
+  : ANTLRInputStream(std::string(data_, numberOfActualCharsInArray)) {
+}
+
+ANTLRInputStream::ANTLRInputStream(std::istream &stream) {
+  InitializeInstanceFields();
+  load(stream);
+}
+
+void ANTLRInputStream::load(const std::string &input) {
+  // Remove the UTF-8 BOM if present.
+  const char bom[4] = "\xef\xbb\xbf";
+  if (input.compare(0, 3, bom, 3) == 0)
+    _data = antlrcpp::utf8_to_utf32(input.data() + 3, input.data() + input.size());
+  else
+    _data = antlrcpp::utf8_to_utf32(input.data(), input.data() + input.size());
+  p = 0;
+}
+
+void ANTLRInputStream::load(std::istream &stream) {
+  if (!stream.good() || stream.eof()) // No fail, bad or EOF.
+    return;
+
+  _data.clear();
+
+  std::string s((std::istreambuf_iterator<char>(stream)), std::istreambuf_iterator<char>());
+  load(s);
+}
+
+void ANTLRInputStream::reset() {
+  p = 0;
+}
+
+void ANTLRInputStream::consume() {
+  if (p >= _data.size()) {
+    assert(LA(1) == IntStream::EOF);
+    throw IllegalStateException("cannot consume EOF");
+  }
+
+  if (p < _data.size()) {
+    p++;
+  }
+}
+
+size_t ANTLRInputStream::LA(ssize_t i) {
+  if (i == 0) {
+    return 0; // undefined
+  }
+
+  ssize_t position = static_cast<ssize_t>(p);
+  if (i < 0) {
+    i++; // e.g., translate LA(-1) to use offset i=0; then _data[p+0-1]
+    if ((position + i - 1) < 0) {
+      return IntStream::EOF; // invalid; no char before first char
+    }
+  }
+
+  if ((position + i - 1) >= static_cast<ssize_t>(_data.size())) {
+    return IntStream::EOF;
+  }
+
+  return _data[static_cast<size_t>((position + i - 1))];
+}
+
+size_t ANTLRInputStream::LT(ssize_t i) {
+  return LA(i);
+}
+
+size_t ANTLRInputStream::index() {
+  return p;
+}
+
+size_t ANTLRInputStream::size() {
+  return _data.size();
+}
+
+// Mark/release do nothing. We have entire buffer.
+ssize_t ANTLRInputStream::mark() {
+  return -1;
+}
+
+void ANTLRInputStream::release(ssize_t /* marker */) {
+}
+
+void ANTLRInputStream::seek(size_t index) {
+  if (index <= p) {
+    p = index; // just jump; don't update stream state (line, ...)
+    return;
+  }
+  // seek forward, consume until p hits index or n (whichever comes first)
+  index = std::min(index, _data.size());
+  while (p < index) {
+    consume();
+  }
+}
+
+std::string ANTLRInputStream::getText(const Interval &interval) {
+  if (interval.a < 0 || interval.b < 0) {
+    return "";
+  }
+
+  size_t start = static_cast<size_t>(interval.a);
+  size_t stop = static_cast<size_t>(interval.b);
+
+
+  if (stop >= _data.size()) {
+    stop = _data.size() - 1;
+  }
+
+  size_t count = stop - start + 1;
+  if (start >= _data.size()) {
+    return "";
+  }
+
+  return antlrcpp::utf32_to_utf8(_data.substr(start, count));
+}
+
+std::string ANTLRInputStream::getSourceName() const {
+  if (name.empty()) {
+    return IntStream::UNKNOWN_SOURCE_NAME;
+  }
+  return name;
+}
+
+std::string ANTLRInputStream::toString() const {
+  return antlrcpp::utf32_to_utf8(_data);
+}
+
+void ANTLRInputStream::InitializeInstanceFields() {
+  p = 0;
+}

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

@@ -0,0 +1,69 @@
+/* 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 "CharStream.h"
+
+namespace antlr4 {
+
+  // Vacuum all input from a stream and then treat it
+  // like a string. Can also pass in a string or char[] to use.
+  // Input is expected to be encoded in UTF-8 and converted to UTF-32 internally.
+  class ANTLR4CPP_PUBLIC ANTLRInputStream : public CharStream {
+  protected:
+    /// The data being scanned.
+    // UTF-32
+    UTF32String _data;
+
+    /// 0..n-1 index into string of next char </summary>
+    size_t p;
+
+  public:
+    /// What is name or source of this char stream?
+    std::string name;
+
+    ANTLRInputStream(const std::string &input = "");
+    ANTLRInputStream(const char data_[], size_t numberOfActualCharsInArray);
+    ANTLRInputStream(std::istream &stream);
+
+    virtual void load(const std::string &input);
+    virtual void load(std::istream &stream);
+
+    /// Reset the stream so that it's in the same state it was
+    /// when the object was created *except* the data array is not
+    /// touched.
+    virtual void reset();
+    virtual void consume() override;
+    virtual size_t LA(ssize_t i) override;
+    virtual size_t LT(ssize_t i);
+
+    /// <summary>
+    /// Return the current input symbol index 0..n where n indicates the
+    ///  last symbol has been read.  The index is the index of char to
+    ///  be returned from LA(1).
+    /// </summary>
+    virtual size_t index() override;
+    virtual size_t size() override;
+
+    /// <summary>
+    /// mark/release do nothing; we have entire buffer </summary>
+    virtual ssize_t mark() override;
+    virtual void release(ssize_t marker) override;
+
+    /// <summary>
+    /// consume() ahead until p==index; can't just set p=index as we must
+    ///  update line and charPositionInLine. If we seek backwards, just set p
+    /// </summary>
+    virtual void seek(size_t index) override;
+    virtual std::string getText(const misc::Interval &interval) override;
+    virtual std::string getSourceName() const override;
+    virtual std::string toString() const override;
+
+  private:
+    void InitializeInstanceFields();
+  };
+
+} // namespace antlr4

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

@@ -0,0 +1,61 @@
+/* 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 "Exceptions.h"
+#include "ParserRuleContext.h"
+#include "InputMismatchException.h"
+#include "Parser.h"
+
+#include "BailErrorStrategy.h"
+
+using namespace antlr4;
+
+void BailErrorStrategy::recover(Parser *recognizer, std::exception_ptr e) {
+  ParserRuleContext *context = recognizer->getContext();
+  do {
+    context->exception = e;
+    if (context->parent == nullptr)
+      break;
+    context = static_cast<ParserRuleContext *>(context->parent);
+  } while (true);
+
+  try {
+    std::rethrow_exception(e); // Throw the exception to be able to catch and rethrow nested.
+#if defined(_MSC_FULL_VER) && _MSC_FULL_VER < 190023026
+  } catch (RecognitionException &inner) {
+    throw ParseCancellationException(inner.what());
+#else
+  } catch (RecognitionException & /*inner*/) {
+    std::throw_with_nested(ParseCancellationException());
+#endif
+  }
+}
+
+Token* BailErrorStrategy::recoverInline(Parser *recognizer)  {
+  InputMismatchException e(recognizer);
+  std::exception_ptr exception = std::make_exception_ptr(e);
+
+  ParserRuleContext *context = recognizer->getContext();
+  do {
+    context->exception = exception;
+    if (context->parent == nullptr)
+      break;
+    context = static_cast<ParserRuleContext *>(context->parent);
+  } while (true);
+
+  try {
+    throw e;
+#if defined(_MSC_FULL_VER) && _MSC_FULL_VER < 190023026
+  } catch (InputMismatchException &inner) {
+    throw ParseCancellationException(inner.what());
+#else
+  } catch (InputMismatchException & /*inner*/) {
+    std::throw_with_nested(ParseCancellationException());
+#endif
+  }
+}
+
+void BailErrorStrategy::sync(Parser * /*recognizer*/) {
+}