#include <Python.h>

#if defined(__GNUC__)

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wunused-variable"

#endif

#include <datetime.h>

#if defined(__GNUC__)

#pragma GCC diagnostic pop

#endif

#include <structmember.h>

#include <algorithm>

#include <cmath>

#include <memory>

#include <string>

#include <vector>

#include "rapidjson/reader.h"

#include "rapidjson/schema.h"

#include "rapidjson/stringbuffer.h"

#include "rapidjson/writer.h"

#include "rapidjson/prettywriter.h"

#include "rapidjson/error/en.h"

using namespace rapidjson;

#define PyDateTimeAPI (state->apis.datetime)

struct PyDerefer {

void operator() (PyObject* obj) const noexcept {Py_DecRef(obj);}

};

using PyStrongRef = std::unique_ptr<PyObject, PyDerefer>;

static PyStrongRef

inline from_module_and_spec(PyObject& module, PyType_Spec& spec) noexcept {

PyStrongRef type{PyType_FromModuleAndSpec(&module, &spec, NULL)};

return type;

}

static int

heap_type_traverse(PyObject *op, visitproc visit, void *arg)

}

#if defined (_MSC_VER) && (_MSC_VER < 1900)

#define IS_NAN(x) Py_IS_NAN(x)

#define IS_INF(x) Py_IS_INFINITY(x)

#else

#define IS_NAN(x) std::isnan(x)

#define IS_INF(x) std::isinf(x)

#endif

struct Errors {

PyObject* validation = NULL;

PyObject* decode = NULL;

};

struct Types {

};

struct Names {

};

struct Strings {

};

struct Consts {

};

struct APIs {

PyDateTime_CAPI* datetime = NULL;

};

typedef struct {

Types types;

Consts consts;

APIs apis;

} rj_state;

namespace { extern PyModuleDef module_def; }

static inline rj_state*

get_rj_state(PyObject* module)

{

void* state = PyModule_GetState(module);

assert(state != NULL);

return (rj_state*) state;

}

static inline rj_state*

get_type_state(PyTypeObject* type)

{

PyObject* module = PyType_GetModuleByDef(type, &module_def);

if (module == NULL)

return NULL;

return get_rj_state(module);

}

static int

rj_clear(PyObject* self)

}

static int

rj_traverse(PyObject* self, visitproc visit, void* arg)

}

static void

rj_free(void* self)

{

(void) rj_clear((PyObject*) self);

}

struct HandlerContext {

};

enum DatetimeMode {

};

#define DATETIME_MODE_FORMATS_MASK 0x0f // 0b00001111 in C++14

static inline int

datetime_mode_format(unsigned mode) {

return mode & DATETIME_MODE_FORMATS_MASK;

}

static inline bool

valid_datetime_mode(long mode) {

}

static int

days_per_month(int year, int month) {

}

enum UuidMode {

};

enum NumberMode {

};

enum BytesMode {

};

enum ParseMode {

};

enum WriteMode {

};

enum IterableMode {

};

enum MappingMode {

};

static PyObject* do_decode(const rj_state* state, PyObject* decoder,

const char* jsonStr, Py_ssize_t jsonStrlen,

PyObject* jsonStream, size_t chunkSize,

PyObject* objectHook,

unsigned numberMode, unsigned datetimeMode,

unsigned uuidMode, unsigned parseMode);

static PyObject* decoder_call(PyObject* self, PyObject* args, PyObject* kwargs);

static PyObject* decoder_new(PyTypeObject* type, PyObject* args, PyObject* kwargs);

static PyObject* do_encode(const rj_state* state, PyObject* value, PyObject* defaultFn, bool ensureAscii,

unsigned writeMode, char indentChar, unsigned indentCount,

unsigned numberMode, unsigned datetimeMode,

unsigned uuidMode, unsigned bytesMode,

unsigned iterableMode, unsigned mappingMode);

static PyObject* do_stream_encode(const rj_state* state, PyObject* value, PyObject* stream, size_t chunkSize,

PyObject* defaultFn, bool ensureAscii,

unsigned writeMode, char indentChar,

unsigned indentCount, unsigned numberMode,

unsigned datetimeMode, unsigned uuidMode,

unsigned bytesMode, unsigned iterableMode,

unsigned mappingMode);

static PyObject* encoder_call(PyObject* self, PyObject* args, PyObject* kwargs);

static PyObject* encoder_new(PyTypeObject* type, PyObject* args, PyObject* kwargs);

static PyObject* validator_call(PyObject* self, PyObject* args, PyObject* kwargs);

static void validator_dealloc(PyObject* self);

static PyObject* validator_new(PyTypeObject* type, PyObject* args, PyObject* kwargs);

class PyReadStreamWrapper {

};

class PyWriteStreamWrapper {

};

inline void PutUnsafe(PyWriteStreamWrapper& stream, char c) {

stream.Put(c);

}

typedef struct {

PyObject_HEAD

PyObject* value;

} RawJSON;

static void

RawJSON_dealloc(RawJSON* self)

}

static PyObject*

RawJSON_new(PyTypeObject* type, PyObject* args, PyObject* kwds)

{

static char const* kwlist[] = {

"value",

NULL

};

PyObject* value = NULL;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "U", (char**) kwlist, &value))

return NULL;

PyObject* self = type->tp_alloc(type, 0);

if (self == NULL)

return NULL;

((RawJSON*) self)->value = value;

Py_INCREF(value);

return self;

}

static PyMemberDef RawJSON_members[] = {

{"value",

T_OBJECT_EX, offsetof(RawJSON, value), READONLY,

"string representing a serialized JSON object"},

{NULL} /* Sentinel */

};

PyDoc_STRVAR(rawjson_doc,

"Raw (preserialized) JSON object\n"

"\n"

"When rapidjson tries to serialize instances of this class, it will"

" use their literal `value`. For instance:\n"

">>> rapidjson.dumps(RawJSON('{\"already\": \"serialized\"}'))\n"

"'{\"already\": \"serialized\"}'");

static PyType_Slot RawJSON_Type_Slot[] = {

{Py_tp_dealloc, reinterpret_cast<void*>(RawJSON_dealloc)},

{Py_tp_doc, const_cast<char*>(rawjson_doc)},

{Py_tp_members, reinterpret_cast<void*>(RawJSON_members)},

{Py_tp_new, reinterpret_cast<void*>(RawJSON_new)},

{Py_tp_traverse, reinterpret_cast<void*>(heap_type_traverse)},

{0, NULL}

};

static PyType_Spec RawJSON_Type_Spec = {

"rapidjson.RawJSON", /* name */

sizeof(RawJSON), /* basicsize */

0, /* itemsize */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE, /* flags */

RawJSON_Type_Slot /* slots */

};

static bool

accept_indent_arg(PyObject* arg, unsigned &write_mode, unsigned &indent_count,

}

static bool

accept_write_mode_arg(PyObject* arg, unsigned &write_mode)

}

static bool

accept_number_mode_arg(PyObject* arg, int allow_nan, unsigned &number_mode)

}

static bool

accept_datetime_mode_arg(PyObject* arg, unsigned &datetime_mode)

}

static bool

accept_uuid_mode_arg(PyObject* arg, unsigned &uuid_mode)

}

static bool

accept_bytes_mode_arg(PyObject* arg, unsigned &bytes_mode)

}

static bool

accept_iterable_mode_arg(PyObject* arg, unsigned &iterable_mode)

}

static bool

accept_mapping_mode_arg(PyObject* arg, unsigned &mapping_mode)

}

static bool

accept_chunk_size_arg(PyObject* arg, size_t &chunk_size)

}

static bool

accept_parse_mode_arg(PyObject* arg, unsigned &parse_mode)

}

static PyObject*

float_from_string(const char* s, Py_ssize_t len)

{

double x;

const char* end;

/* We don't care about overflow or underflow. If the platform

x = PyOS_string_to_double(s, (char **) &end, NULL);

if (end != s + len) {

return NULL;

} else if (x == -1.0 && PyErr_Occurred()) {

return NULL;

} else {

return PyFloat_FromDouble(x);

}

}

struct PyHandler {