simdjson 0.1.0

data/vendor/simdjson/include/simdjson/portability.h

@@ -0,0 +1,172 @@
+#ifndef SIMDJSON_PORTABILITY_H
+#define SIMDJSON_PORTABILITY_H
+
+#if defined(__x86_64__) || defined(_M_AMD64)
+#define IS_X86_64 1
+#endif
+#if defined(__aarch64__) || defined(_M_ARM64)
+#define IS_ARM64 1
+#endif
+
+// this is almost standard?
+#define STRINGIFY(a) #a
+
+// we are going to use runtime dispatch
+#ifdef IS_X86_64
+#ifdef __clang__
+// clang does not have GCC push pop
+// warning: clang attribute push can't be used within a namespace in clang up
+// til 8.0 so TARGET_REGION and UNTARGET_REGION must be *outside* of a
+// namespace.
+#define TARGET_REGION(T)                                                       \
+  _Pragma(STRINGIFY(                                                           \
+      clang attribute push(__attribute__((target(T))), apply_to = function)))
+#define UNTARGET_REGION _Pragma("clang attribute pop")
+#elif defined(__GNUC__)
+// GCC is easier
+#define TARGET_REGION(T)                                                       \
+  _Pragma("GCC push_options") _Pragma(STRINGIFY(GCC target(T)))
+#define UNTARGET_REGION _Pragma("GCC pop_options")
+#else
+#define TARGET_REGION(T)
+#define UNTARGET_REGION
+#endif // clang then gcc
+
+// under GCC and CLANG, we use these two macros
+#define TARGET_HASWELL TARGET_REGION("avx2,bmi,pclmul")
+#define TARGET_WESTMERE TARGET_REGION("sse4.2,pclmul")
+
+#endif // x86
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#else
+#if IS_X86_64
+#include <x86intrin.h>
+#elif IS_ARM64
+#include <arm_neon.h>
+#endif
+#endif
+
+#ifdef _MSC_VER
+/* Microsoft C/C++-compatible compiler */
+#include <cstdint>
+#include <iso646.h>
+
+namespace simdjson {
+static inline bool add_overflow(uint64_t value1, uint64_t value2,
+                                uint64_t *result) {
+  return _addcarry_u64(0, value1, value2,
+                       reinterpret_cast<unsigned __int64 *>(result));
+}
+
+#pragma intrinsic(_umul128)
+static inline bool mul_overflow(uint64_t value1, uint64_t value2,
+                                uint64_t *result) {
+  uint64_t high;
+  *result = _umul128(value1, value2, &high);
+  return high;
+}
+
+static inline int trailing_zeroes(uint64_t input_num) {
+  return static_cast<int>(_tzcnt_u64(input_num));
+}
+
+static inline int leading_zeroes(uint64_t input_num) {
+  return static_cast<int>(_lzcnt_u64(input_num));
+}
+
+static inline int hamming(uint64_t input_num) {
+#ifdef _WIN64 // highly recommended!!!
+  return (int)__popcnt64(input_num);
+#else // if we must support 32-bit Windows
+  return (int)(__popcnt((uint32_t)input_num) +
+               __popcnt((uint32_t)(input_num >> 32)));
+#endif
+}
+} // namespace simdjson
+#else
+#include <cstdint>
+#include <cstdlib>
+
+namespace simdjson {
+static inline bool add_overflow(uint64_t value1, uint64_t value2,
+                                uint64_t *result) {
+  return __builtin_uaddll_overflow(value1, value2,
+                                   (unsigned long long *)result);
+}
+static inline bool mul_overflow(uint64_t value1, uint64_t value2,
+                                uint64_t *result) {
+  return __builtin_umulll_overflow(value1, value2,
+                                   (unsigned long long *)result);
+}
+
+/* result might be undefined when input_num is zero */
+static inline int trailing_zeroes(uint64_t input_num) {
+#ifdef __BMI__ // tzcnt is BMI1
+  return _tzcnt_u64(input_num);
+#else
+  return __builtin_ctzll(input_num);
+#endif
+}
+
+/* result might be undefined when input_num is zero */
+static inline int leading_zeroes(uint64_t input_num) {
+#ifdef __BMI2__
+  return _lzcnt_u64(input_num);
+#else
+  return __builtin_clzll(input_num);
+#endif
+}
+
+/* result might be undefined when input_num is zero */
+static inline int hamming(uint64_t input_num) {
+#ifdef __POPCOUNT__
+  return _popcnt64(input_num);
+#else
+  return __builtin_popcountll(input_num);
+#endif
+}
+} // namespace simdjson
+#endif // _MSC_VER
+
+namespace simdjson {
+// portable version of  posix_memalign
+static inline void *aligned_malloc(size_t alignment, size_t size) {
+  void *p;
+#ifdef _MSC_VER
+  p = _aligned_malloc(size, alignment);
+#elif defined(__MINGW32__) || defined(__MINGW64__)
+  p = __mingw_aligned_malloc(size, alignment);
+#else
+  // somehow, if this is used before including "x86intrin.h", it creates an
+  // implicit defined warning.
+  if (posix_memalign(&p, alignment, size) != 0) {
+    return nullptr;
+  }
+#endif
+  return p;
+}
+
+static inline char *aligned_malloc_char(size_t alignment, size_t size) {
+  return (char *)aligned_malloc(alignment, size);
+}
+
+static inline void aligned_free(void *mem_block) {
+  if (mem_block == nullptr) {
+    return;
+  }
+#ifdef _MSC_VER
+  _aligned_free(mem_block);
+#elif defined(__MINGW32__) || defined(__MINGW64__)
+  __mingw_aligned_free(mem_block);
+#else
+  free(mem_block);
+#endif
+}
+
+static inline void aligned_free_char(char *mem_block) {
+  aligned_free((void *)mem_block);
+}
+} // namespace simdjson
+#endif // SIMDJSON_PORTABILITY_H

data/vendor/simdjson/include/simdjson/simdjson.h

@@ -0,0 +1,44 @@
+#ifndef SIMDJSON_ERR_H
+#define SIMDJSON_ERR_H
+
+#include <string>
+
+namespace simdjson {
+// Represents the minimal architecture that would support an implementation
+enum class Architecture {
+  WESTMERE,
+  HASWELL,
+  ARM64,
+  NONE,
+// TODO remove 'native' in favor of runtime dispatch?
+// the 'native' enum class value should point at a good default on the current
+// machine
+#ifdef IS_X86_64
+  NATIVE = WESTMERE
+#elif defined(IS_ARM64)
+  NATIVE = ARM64
+#endif
+};
+
+enum ErrorValues {
+  SUCCESS = 0,
+  CAPACITY,    // This ParsedJson can't support a document that big
+  MEMALLOC,    // Error allocating memory, most likely out of memory
+  TAPE_ERROR,  // Something went wrong while writing to the tape (stage 2), this
+               // is a generic error
+  DEPTH_ERROR, // Your document exceeds the user-specified depth limitation
+  STRING_ERROR,    // Problem while parsing a string
+  T_ATOM_ERROR,    // Problem while parsing an atom starting with the letter 't'
+  F_ATOM_ERROR,    // Problem while parsing an atom starting with the letter 'f'
+  N_ATOM_ERROR,    // Problem while parsing an atom starting with the letter 'n'
+  NUMBER_ERROR,    // Problem while parsing a number
+  UTF8_ERROR,      // the input is not valid UTF-8
+  UNITIALIZED,     // unknown error, or uninitialized document
+  EMPTY,           // no structural document found
+  UNESCAPED_CHARS, // found unescaped characters in a string.
+  UNCLOSED_STRING, // missing quote at the end
+  UNEXPECTED_ERROR // indicative of a bug in simdjson
+};
+const std::string &error_message(const int);
+} // namespace simdjson
+#endif

data/vendor/simdjson/include/simdjson/simdjson_version.h

@@ -0,0 +1,13 @@
+// /include/simdjson/simdjson_version.h automatically generated by release.py,
+// do not change by hand
+#ifndef SIMDJSON_INCLUDE_SIMDJSON_VERSION
+#define SIMDJSON_INCLUDE_SIMDJSON_VERSION
+#define SIMDJSON_VERSION 0.2.1
+namespace simdjson {
+enum {
+  SIMDJSON_VERSION_MAJOR = 0,
+  SIMDJSON_VERSION_MINOR = 2,
+  SIMDJSON_VERSION_REVISION = 1
+};
+}
+#endif // SIMDJSON_INCLUDE_SIMDJSON_VERSION