python3-parser 1.0.0

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

@@ -0,0 +1,78 @@
+/* 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 antlrcpp {
+
+  std::string join(std::vector<std::string> strings, const std::string &separator);
+  std::map<std::string, size_t> toMap(const std::vector<std::string> &keys);
+  std::string escapeWhitespace(std::string str, bool escapeSpaces);
+  std::string toHexString(const int t);
+  std::string arrayToString(const std::vector<std::string> &data);
+  std::string replaceString(const std::string &s, const std::string &from, const std::string &to);
+  std::vector<std::string> split(const std::string &s, const std::string &sep, int count);
+  std::string indent(const std::string &s, const std::string &indentation, bool includingFirst = true);
+
+  // Using RAII + a lambda to implement a "finally" replacement.
+  struct FinalAction {
+    FinalAction(std::function<void ()> f) : _cleanUp { f } {}
+    FinalAction(FinalAction &&other) :
+	_cleanUp(std::move(other._cleanUp)), _enabled(other._enabled) {
+      other._enabled = false; // Don't trigger the lambda after ownership has moved.
+    }
+    ~FinalAction() { if (_enabled) _cleanUp(); }
+
+    void disable() { _enabled = false; }
+  private:
+    std::function<void ()> _cleanUp;
+    bool _enabled {true};
+  };
+
+  ANTLR4CPP_PUBLIC FinalAction finally(std::function<void ()> f);
+
+  // Convenience functions to avoid lengthy dynamic_cast() != nullptr checks in many places.
+  template <typename T1, typename T2>
+  inline bool is(T2 *obj) { // For pointer types.
+    return dynamic_cast<typename std::add_const<T1>::type>(obj) != nullptr;
+  }
+
+  template <typename T1, typename T2>
+  inline bool is(Ref<T2> const& obj) { // For shared pointers.
+    return dynamic_cast<T1 *>(obj.get()) != nullptr;
+  }
+
+  template <typename T>
+  std::string toString(const T &o) {
+    std::stringstream ss;
+    // typeid gives the mangled class name, but that's all what's possible
+    // in a portable way.
+    ss << typeid(o).name() << "@" << std::hex << reinterpret_cast<uintptr_t>(&o);
+    return ss.str();
+  }
+
+  // Get the error text from an exception pointer or the current exception.
+  std::string what(std::exception_ptr eptr = std::current_exception());
+
+  class SingleWriteMultipleReadLock {
+  public:
+    void readLock();
+    void readUnlock();
+    void writeLock();
+    void writeUnlock();
+
+  private:
+    std::condition_variable _readerGate;
+    std::condition_variable _writerGate;
+
+    std::mutex _mutex;
+    size_t _activeReaders = 0;
+    size_t _waitingWriters = 0;
+    size_t _activeWriters = 0;
+  };
+
+} // namespace antlrcpp

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

@@ -0,0 +1,163 @@
+/* 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 {
+  class ANTLRErrorListener;
+  class ANTLRErrorStrategy;
+  class ANTLRFileStream;
+  class ANTLRInputStream;
+  class BailErrorStrategy;
+  class BaseErrorListener;
+  class BufferedTokenStream;
+  class CharStream;
+  class CommonToken;
+  class CommonTokenFactory;
+  class CommonTokenStream;
+  class ConsoleErrorListener;
+  class DefaultErrorStrategy;
+  class DiagnosticErrorListener;
+  class EmptyStackException;
+  class FailedPredicateException;
+  class IllegalArgumentException;
+  class IllegalStateException;
+  class InputMismatchException;
+  class IntStream;
+  class InterpreterRuleContext;
+  class Lexer;
+  class LexerInterpreter;
+  class LexerNoViableAltException;
+  class ListTokenSource;
+  class NoSuchElementException;
+  class NoViableAltException;
+  class NullPointerException;
+  class ParseCancellationException;
+  class Parser;
+  class ParserInterpreter;
+  class ParserRuleContext;
+  class ProxyErrorListener;
+  class RecognitionException;
+  class Recognizer;
+  class RuleContext;
+  class Token;
+  template<typename Symbol> class TokenFactory;
+  class TokenSource;
+  class TokenStream;
+  class TokenStreamRewriter;
+  class UnbufferedCharStream;
+  class UnbufferedTokenStream;
+  class WritableToken;
+
+  namespace misc {
+    class InterpreterDataReader;
+    class Interval;
+    class IntervalSet;
+    class MurmurHash;
+    class Utils;
+    class Predicate;
+  }
+  namespace atn {
+    class ATN;
+    class ATNConfig;
+    class ATNConfigSet;
+    class ATNDeserializationOptions;
+    class ATNDeserializer;
+    class ATNSerializer;
+    class ATNSimulator;
+    class ATNState;
+    enum class ATNType;
+    class AbstractPredicateTransition;
+    class ActionTransition;
+    class ArrayPredictionContext;
+    class AtomTransition;
+    class BasicBlockStartState;
+    class BasicState;
+    class BlockEndState;
+    class BlockStartState;
+    class DecisionState;
+    class EmptyPredictionContext;
+    class EpsilonTransition;
+    class LL1Analyzer;
+    class LexerAction;
+    class LexerActionExecutor;
+    class LexerATNConfig;
+    class LexerATNSimulator;
+    class LexerMoreAction;
+    class LexerPopModeAction;
+    class LexerSkipAction;
+    class LookaheadEventInfo;
+    class LoopEndState;
+    class NotSetTransition;
+    class OrderedATNConfigSet;
+    class ParseInfo;
+    class ParserATNSimulator;
+    class PlusBlockStartState;
+    class PlusLoopbackState;
+    class PrecedencePredicateTransition;
+    class PredicateTransition;
+    class PredictionContext;
+    enum class PredictionMode;
+    class PredictionModeClass;
+    class RangeTransition;
+    class RuleStartState;
+    class RuleStopState;
+    class RuleTransition;
+    class SemanticContext;
+    class SetTransition;
+    class SingletonPredictionContext;
+    class StarBlockStartState;
+    class StarLoopEntryState;
+    class StarLoopbackState;
+    class TokensStartState;
+    class Transition;
+    class WildcardTransition;
+  }
+  namespace dfa {
+    class DFA;
+    class DFASerializer;
+    class DFAState;
+    class LexerDFASerializer;
+    class Vocabulary;
+  }
+  namespace tree {
+    class AbstractParseTreeVisitor;
+    class ErrorNode;
+    class ErrorNodeImpl;
+    class ParseTree;
+    class ParseTreeListener;
+    template<typename T> class ParseTreeProperty;
+    class ParseTreeVisitor;
+    class ParseTreeWalker;
+    class SyntaxTree;
+    class TerminalNode;
+    class TerminalNodeImpl;
+    class Tree;
+    class Trees;
+
+    namespace pattern {
+      class Chunk;
+      class ParseTreeMatch;
+      class ParseTreePattern;
+      class ParseTreePatternMatcher;
+      class RuleTagToken;
+      class TagChunk;
+      class TextChunk;
+      class TokenTagToken;
+    }
+
+    namespace xpath {
+      class XPath;
+      class XPathElement;
+      class XPathLexerErrorListener;
+      class XPathRuleAnywhereElement;
+      class XPathRuleElement;
+      class XPathTokenAnywhereElement;
+      class XPathTokenElement;
+      class XPathWildcardAnywhereElement;
+      class XPathWildcardElement;
+    }
+  }
+}

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

@@ -0,0 +1,36 @@
+/* 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"
+
+namespace antlrcpp {
+
+void replaceAll(std::string& str, std::string const& from, std::string const& to)
+{
+  if (from.empty())
+    return;
+
+  size_t start_pos = 0;
+  while ((start_pos = str.find(from, start_pos)) != std::string::npos) {
+    str.replace(start_pos, from.length(), to);
+    start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'.
+  }
+}
+
+std::string ws2s(std::wstring const& wstr) {
+  std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
+  std::string narrow = converter.to_bytes(wstr);
+
+  return narrow;
+}
+
+std::wstring s2ws(const std::string &str) {
+  std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
+  std::wstring wide = converter.from_bytes(str);
+  
+  return wide;
+}
+
+} // namespace antrlcpp

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

@@ -0,0 +1,54 @@
+/* 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 antlrcpp {
+
+  // For all conversions utf8 <-> utf32.
+  // VS 2015 and VS 2017 have different bugs in std::codecvt_utf8<char32_t> (VS 2013 works fine).
+#if defined(_MSC_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
+  typedef std::wstring_convert<std::codecvt_utf8<__int32>, __int32> UTF32Converter;
+#else
+  typedef std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> UTF32Converter;
+#endif
+  
+  // The conversion functions fails in VS2017, so we explicitly use a workaround.
+  template<typename T>
+  inline std::string utf32_to_utf8(T const& data)
+  {
+    // Don't make the converter static or we have to serialize access to it.
+    thread_local UTF32Converter converter;
+
+    #if defined(_MSC_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
+      auto p = reinterpret_cast<const int32_t *>(data.data());
+      return converter.to_bytes(p, p + data.size());
+    #else
+      return converter.to_bytes(data);
+    #endif
+  }
+
+  inline UTF32String utf8_to_utf32(const char* first, const char* last)
+  {
+    thread_local UTF32Converter converter;
+
+    #if defined(_MSC_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
+      auto r = converter.from_bytes(first, last);
+      i32string s = reinterpret_cast<const int32_t *>(r.data());
+    #else
+      std::u32string s = converter.from_bytes(first, last);
+    #endif
+    
+    return s;
+  }
+
+  void replaceAll(std::string &str, std::string const& from, std::string const& to);
+
+  // string <-> wstring conversion (UTF-16), e.g. for use with Window's wide APIs.
+  ANTLR4CPP_PUBLIC std::string ws2s(std::wstring const& wstr);
+  ANTLR4CPP_PUBLIC std::wstring s2ws(std::string const& str);
+}

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

@@ -0,0 +1,303 @@
+/*
+ The MIT License (MIT)
+
+ Copyright (c) 2014 Graeme Hill (http://graemehill.ca)
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+
+#include "guid.h"
+
+#ifdef GUID_LIBUUID
+#include <uuid/uuid.h>
+#endif
+
+#ifdef GUID_CFUUID
+#include <CoreFoundation/CFUUID.h>
+#endif
+
+#ifdef GUID_WINDOWS
+#include <objbase.h>
+#endif
+
+#ifdef GUID_ANDROID
+#include <jni.h>
+#endif
+
+using namespace std;
+
+// overload << so that it's easy to convert to a string
+ostream &operator<<(ostream &s, const Guid &guid)
+{
+  return s << hex << setfill('0')
+  << setw(2) << (int)guid._bytes[0]
+  << setw(2) << (int)guid._bytes[1]
+  << setw(2) << (int)guid._bytes[2]
+  << setw(2) << (int)guid._bytes[3]
+  << "-"
+  << setw(2) << (int)guid._bytes[4]
+  << setw(2) << (int)guid._bytes[5]
+  << "-"
+  << setw(2) << (int)guid._bytes[6]
+  << setw(2) << (int)guid._bytes[7]
+  << "-"
+  << setw(2) << (int)guid._bytes[8]
+  << setw(2) << (int)guid._bytes[9]
+  << "-"
+  << setw(2) << (int)guid._bytes[10]
+  << setw(2) << (int)guid._bytes[11]
+  << setw(2) << (int)guid._bytes[12]
+  << setw(2) << (int)guid._bytes[13]
+  << setw(2) << (int)guid._bytes[14]
+  << setw(2) << (int)guid._bytes[15];
+}
+
+// create a guid from vector of bytes
+Guid::Guid(const vector<unsigned char> &bytes)
+{
+  _bytes = bytes;
+}
+
+// create a guid from array of bytes
+Guid::Guid(const unsigned char *bytes)
+{
+  _bytes.assign(bytes, bytes + 16);
+}
+
+// create a guid from array of words
+Guid::Guid(const uint16_t *bytes, bool reverse)
+{
+  if (reverse) {
+    for (size_t i = 8; i > 0; --i)
+    {
+      _bytes.push_back(bytes[i - 1] >> 8);
+      _bytes.push_back(bytes[i - 1] & 0xFF);
+    }
+  } else {
+    for (size_t i = 0; i < 8; ++i)
+    {
+      _bytes.push_back(bytes[i] & 0xFF);
+      _bytes.push_back(bytes[i] >> 8);
+    }
+  }
+}
+
+// converts a single hex char to a number (0 - 15)
+static unsigned char hexDigitToChar(char ch)
+{
+  if (ch > 47 && ch < 58)
+    return (unsigned char)(ch - 48);
+
+  if (ch > 96 && ch < 103)
+    return (unsigned char)(ch - 87);
+
+  if (ch > 64 && ch < 71)
+    return (unsigned char)(ch - 55);
+
+  return 0;
+}
+
+// converts the two hexadecimal characters to an unsigned char (a byte)
+static unsigned char hexPairToChar(char a, char b)
+{
+  return hexDigitToChar(a) * 16 + hexDigitToChar(b);
+}
+
+// create a guid from string
+Guid::Guid(const string &fromString)
+{
+  _bytes.clear();
+
+  char charOne = 0, charTwo;
+  bool lookingForFirstChar = true;
+
+  for (const char &ch : fromString)
+  {
+    if (ch == '-')
+      continue;
+
+    if (lookingForFirstChar)
+    {
+      charOne = ch;
+      lookingForFirstChar = false;
+    }
+    else
+    {
+      charTwo = ch;
+      auto byte = hexPairToChar(charOne, charTwo);
+      _bytes.push_back(byte);
+      lookingForFirstChar = true;
+    }
+  }
+
+}
+
+// create empty guid
+Guid::Guid()
+{
+  _bytes = vector<unsigned char>(16, 0);
+}
+
+// copy constructor
+Guid::Guid(const Guid &other)
+{
+  _bytes = other._bytes;
+}
+
+// overload assignment operator
+Guid &Guid::operator=(const Guid &other)
+{
+  _bytes = other._bytes;
+  return *this;
+}
+
+// overload equality operator
+bool Guid::operator==(const Guid &other) const
+{
+  return _bytes == other._bytes;
+}
+
+// overload inequality operator
+bool Guid::operator!=(const Guid &other) const
+{
+  return !((*this) == other);
+}
+
+const std::string Guid::toString() const
+{
+  std::stringstream os;
+  os << *this;
+  return os.str();
+}
+
+// This is the linux friendly implementation, but it could work on other
+// systems that have libuuid available
+#ifdef GUID_LIBUUID
+Guid GuidGenerator::newGuid()
+{
+  uuid_t id;
+  uuid_generate(id);
+  return id;
+}
+#endif
+
+// this is the mac and ios version
+#ifdef GUID_CFUUID
+Guid GuidGenerator::newGuid()
+{
+  auto newId = CFUUIDCreate(NULL);
+  auto bytes = CFUUIDGetUUIDBytes(newId);
+  CFRelease(newId);
+
+  const unsigned char byteArray[16] =
+  {
+    bytes.byte0,
+    bytes.byte1,
+    bytes.byte2,
+    bytes.byte3,
+    bytes.byte4,
+    bytes.byte5,
+    bytes.byte6,
+    bytes.byte7,
+    bytes.byte8,
+    bytes.byte9,
+    bytes.byte10,
+    bytes.byte11,
+    bytes.byte12,
+    bytes.byte13,
+    bytes.byte14,
+    bytes.byte15
+  };
+  return byteArray;
+}
+#endif
+
+// obviously this is the windows version
+#ifdef GUID_WINDOWS
+Guid GuidGenerator::newGuid()
+{
+  GUID newId;
+  CoCreateGuid(&newId);
+
+  const unsigned char bytes[16] =
+  {
+    (newId.Data1 >> 24) & 0xFF,
+    (newId.Data1 >> 16) & 0xFF,
+    (newId.Data1 >> 8) & 0xFF,
+    (newId.Data1) & 0xff,
+
+    (newId.Data2 >> 8) & 0xFF,
+    (newId.Data2) & 0xff,
+
+    (newId.Data3 >> 8) & 0xFF,
+    (newId.Data3) & 0xFF,
+
+    newId.Data4[0],
+    newId.Data4[1],
+    newId.Data4[2],
+    newId.Data4[3],
+    newId.Data4[4],
+    newId.Data4[5],
+    newId.Data4[6],
+    newId.Data4[7]
+  };
+
+  return bytes;
+}
+#endif
+
+// android version that uses a call to a java api
+#ifdef GUID_ANDROID
+GuidGenerator::GuidGenerator(JNIEnv *env)
+{
+  _env = env;
+  _uuidClass = env->FindClass("java/util/UUID");
+  _newGuidMethod = env->GetStaticMethodID(_uuidClass, "randomUUID", "()Ljava/util/UUID;");
+  _mostSignificantBitsMethod = env->GetMethodID(_uuidClass, "getMostSignificantBits", "()J");
+  _leastSignificantBitsMethod = env->GetMethodID(_uuidClass, "getLeastSignificantBits", "()J");
+}
+
+Guid GuidGenerator::newGuid()
+{
+  jobject javaUuid = _env->CallStaticObjectMethod(_uuidClass, _newGuidMethod);
+  jlong mostSignificant = _env->CallLongMethod(javaUuid, _mostSignificantBitsMethod);
+  jlong leastSignificant = _env->CallLongMethod(javaUuid, _leastSignificantBitsMethod);
+
+  unsigned char bytes[16] =
+  {
+    (mostSignificant >> 56) & 0xFF,
+    (mostSignificant >> 48) & 0xFF,
+    (mostSignificant >> 40) & 0xFF,
+    (mostSignificant >> 32) & 0xFF,
+    (mostSignificant >> 24) & 0xFF,
+    (mostSignificant >> 16) & 0xFF,
+    (mostSignificant >> 8) & 0xFF,
+    (mostSignificant) & 0xFF,
+    (leastSignificant >> 56) & 0xFF,
+    (leastSignificant >> 48) & 0xFF,
+    (leastSignificant >> 40) & 0xFF,
+    (leastSignificant >> 32) & 0xFF,
+    (leastSignificant >> 24) & 0xFF,
+    (leastSignificant >> 16) & 0xFF,
+    (leastSignificant >> 8) & 0xFF,
+    (leastSignificant) & 0xFF,
+  };
+  return bytes;
+}
+#endif