PyObject* object;

const char* key;

SizeType keyLength;

bool isObject;

bool keyValuePairs;

bool copiedKey;

DM_NONE = 0,

// Formats

DM_ISO8601 = 1<<0, // Bidirectional ISO8601 for datetimes, dates and times

DM_UNIX_TIME = 1<<1, // Serialization only, "Unix epoch"-based number of seconds

// Options

DM_ONLY_SECONDS = 1<<4, // Truncate values to the whole second, ignoring micro seconds

DM_IGNORE_TZ = 1<<5, // Ignore timezones

DM_NAIVE_IS_UTC = 1<<6, // Assume naive datetime are in UTC timezone

DM_SHIFT_TO_UTC = 1<<7, // Shift to/from UTC

DM_MAX = 1<<8

int format = datetime_mode_format(mode);

return (mode >= 0 && mode < DM_MAX

&& (format <= DM_UNIX_TIME)

&& (mode == 0 || format > 0));

assert(month >= 1);

assert(month <= 12);

if (month == 1 || month == 3 || month == 5 || month == 7

|| month == 8 || month == 10 || month == 12) {

return 31;

} else if (month == 4 || month == 6 || month == 9 || month == 11) {

return 30;

} else if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) {

return 29;

} else {

return 28;

}

UM_NONE = 0,

UM_CANONICAL = 1<<0, // 4-dashed 32 hex chars: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

UM_HEX = 1<<1, // canonical OR 32 hex chars in a row

UM_MAX = 1<<2

NM_NONE = 0,

NM_NAN = 1<<0, // allow "not-a-number" values

NM_DECIMAL = 1<<1, // serialize Decimal instances, deserialize floats as Decimal

NM_NATIVE = 1<<2, // use faster native C library number handling

NM_MAX = 1<<3

BM_NONE = 0,

BM_UTF8 = 1<<0, // try to convert to UTF-8

BM_MAX = 1<<1

PM_NONE = 0,

PM_COMMENTS = 1<<0, // Allow one-line // ... and multi-line /* ... */ comments

PM_TRAILING_COMMAS = 1<<1, // allow trailing commas at the end of objects and arrays

PM_MAX = 1<<2

WM_COMPACT = 0,

WM_PRETTY = 1<<0, // Use PrettyWriter

WM_SINGLE_LINE_ARRAY = 1<<1, // Format arrays on a single line

WM_MAX = 1<<2

IM_ANY_ITERABLE = 0, // Default, any iterable is dumped as JSON array

IM_ONLY_LISTS = 1<<0, // Only list instances are dumped as JSON arrays

IM_MAX = 1<<1

MM_ANY_MAPPING = 0, // Default, any mapping is dumped as JSON object

MM_ONLY_DICTS = 1<<0, // Only dict instances are dumped as JSON objects

MM_COERCE_KEYS_TO_STRINGS = 1<<1, // Convert keys to strings

MM_SKIP_NON_STRING_KEYS = 1<<2, // Ignore non-string keys

MM_SORT_KEYS = 1<<3, // Sort keys

MM_MAX = 1<<4

typedef char Ch;

PyReadStreamWrapper(PyObject* stream, size_t size)

: stream(stream) {

Py_INCREF(stream);

chunkSize = PyLong_FromUnsignedLong(size);

buffer = NULL;

chunk = NULL;

chunkLen = 0;

pos = 0;

offset = 0;

eof = false;

}

~PyReadStreamWrapper() {

Py_CLEAR(stream);

Py_CLEAR(chunkSize);

Py_CLEAR(chunk);

}

Ch Peek() {

if (!eof && pos == chunkLen) {

Read();

}

return eof ? '\0' : buffer[pos];

}

Ch Take() {

if (!eof && pos == chunkLen) {

Read();

}

return eof ? '\0' : buffer[pos++];

}

size_t Tell() const {

return offset + pos;

}

bool IsEnd() const {

return eof;

}

void Flush() {

assert(false);

}

void Put(Ch c) {

assert(false);

}

Ch* PutBegin() {

assert(false);

return 0;

}

size_t PutEnd(Ch* begin) {

assert(false);

return 0;

}

void Read() {

Py_CLEAR(chunk);

chunk = PyObject_CallMethodObjArgs(stream, read_name, chunkSize, NULL);

if (chunk == NULL) {

eof = true;

} else {

Py_ssize_t len;

if (PyBytes_Check(chunk)) {

len = PyBytes_GET_SIZE(chunk);

buffer = PyBytes_AS_STRING(chunk);

} else {

buffer = PyUnicode_AsUTF8AndSize(chunk, &len);

if (buffer == NULL) {

len = 0;

}

}

if (len == 0) {

eof = true;

} else {

offset += chunkLen;

chunkLen = len;

pos = 0;

}

}

}

PyObject* stream;

PyObject* chunkSize;

PyObject* chunk;

const Ch* buffer;

size_t chunkLen;

size_t pos;

size_t offset;

bool eof;

typedef char Ch;

PyWriteStreamWrapper(PyObject* stream, size_t size)

: stream(stream) {

Py_INCREF(stream);

buffer = (char*) PyMem_Malloc(size);

assert(buffer);

bufferEnd = buffer + size;

cursor = buffer;

multiByteChar = NULL;

isBinary = !PyObject_HasAttr(stream, encoding_name);

}

~PyWriteStreamWrapper() {

Py_CLEAR(stream);

PyMem_Free(buffer);

}

Ch Peek() {

assert(false);

return 0;

}

Ch Take() {

assert(false);

return 0;

}

size_t Tell() const {

assert(false);

return 0;

}

void Flush() {

PyObject* c;

if (isBinary) {

c = PyBytes_FromStringAndSize(buffer, (size_t)(cursor - buffer));

cursor = buffer;

} else {

if (multiByteChar == NULL) {

c = PyUnicode_FromStringAndSize(buffer, (size_t)(cursor - buffer));

cursor = buffer;

} else {

size_t complete = (size_t)(multiByteChar - buffer);

c = PyUnicode_FromStringAndSize(buffer, complete);

size_t remaining = (size_t)(cursor - multiByteChar);

if (RAPIDJSON_LIKELY(remaining < complete))

memcpy(buffer, multiByteChar, remaining);

else

std::memmove(buffer, multiByteChar, remaining);

cursor = buffer + remaining;

multiByteChar = NULL;

}

}

if (c == NULL) {

// Propagate the error state, it will be caught by dumps_internal()

} else {

PyObject* res = PyObject_CallMethodObjArgs(stream, write_name, c, NULL);

if (res == NULL) {

// Likewise

} else {

Py_DECREF(res);

}

Py_DECREF(c);

}

}

void Put(Ch c) {

if (cursor == bufferEnd)

Flush();

if (!isBinary) {

if ((c & 0x80) == 0) {

multiByteChar = NULL;

} else if (c & 0x40) {

multiByteChar = cursor;

}

}

*cursor++ = c;

}

void Append(const char* s, size_t n) {

while (n > 0) {

if (cursor == bufferEnd) {

if (!isBinary)

trackMultiByteChar();

Flush();

}

size_t room = (size_t)(bufferEnd - cursor);

size_t chunk = n < room ? n : room;

memcpy(cursor, s, chunk);

cursor += chunk;

s += chunk;

n -= chunk;

}

if (!isBinary)

trackMultiByteChar();

}

Ch* PutBegin() {

assert(false);

return 0;

}

size_t PutEnd(Ch* begin) {

assert(false);

return 0;

}

/* Record whether the buffer ends in the middle of a UTF-8 sequence, so that

void trackMultiByteChar() {

size_t used = (size_t)(cursor - buffer);

size_t back = used < 4 ? used : 4;

size_t pos = used;

while (back > 0) {

--pos;

--back;

if ((buffer[pos] & 0xC0) != 0x80)

break;

}

if (pos == used) {

multiByteChar = NULL;

return;

}

unsigned char lead = (unsigned char) buffer[pos];

size_t need = lead >= 0xF0 ? 4 : lead >= 0xE0 ? 3 : lead >= 0xC0 ? 2 : 1;

multiByteChar = (used - pos < need) ? buffer + pos : NULL;

}

PyObject* stream;

Ch* buffer;

Ch* bufferEnd;

Ch* cursor;

Ch* multiByteChar;

bool isBinary;

{

Py_XDECREF(self->value);

Py_TYPE(self)->tp_free((PyObject*) self);

char &indent_char)

{

if (arg != NULL && arg != Py_None) {

write_mode = WM_PRETTY;

if (PyLong_Check(arg) && PyLong_AsLong(arg) >= 0) {

indent_count = PyLong_AsUnsignedLong(arg);

} else if (PyUnicode_Check(arg)) {

Py_ssize_t len;

const char* indentStr = PyUnicode_AsUTF8AndSize(arg, &len);

indent_count = len;

if (indent_count) {

indent_char = '\0';

while (len--) {

char ch = indentStr[len];

if (ch == '\n' || ch == ' ' || ch == '\t' || ch == '\r') {

if (indent_char == '\0') {

indent_char = ch;

} else if (indent_char != ch) {

PyErr_SetString(

PyExc_TypeError,

"indent string cannot contains different chars");

return false;

}

} else {

PyErr_SetString(PyExc_TypeError,

"non-whitespace char in indent string");

return false;

}

}

}

} else {

PyErr_SetString(PyExc_TypeError,

"indent must be a non-negative int or a string");

return false;

}

}

return true;

{

if (arg != NULL && arg != Py_None) {

if (PyLong_Check(arg)) {

long mode = PyLong_AsLong(arg);

if (mode < 0 || mode >= WM_MAX) {

PyErr_SetString(PyExc_ValueError, "Invalid write_mode");

return false;

}

write_mode = (unsigned) mode;

} else {

PyErr_SetString(PyExc_TypeError,

"write_mode must be a non-negative int");

return false;

}

}

return true;

{

if (arg != NULL) {

if (arg == Py_None)

number_mode = NM_NONE;

else if (PyLong_Check(arg)) {

long mode = PyLong_AsLong(arg);

if (mode < 0 || mode >= NM_MAX) {

PyErr_SetString(PyExc_ValueError, "Invalid number_mode, out of range");

return false;

}

number_mode = (unsigned) mode;

} else {

PyErr_SetString(PyExc_TypeError,

"number_mode must be a non-negative int");

return false;

}

}

if (allow_nan != -1) {

if (allow_nan)

number_mode |= NM_NAN;

else

number_mode &= ~NM_NAN;

}

return true;

{

if (arg != NULL && arg != Py_None) {

if (PyLong_Check(arg)) {

long mode = PyLong_AsLong(arg);

if (!valid_datetime_mode(mode)) {

PyErr_SetString(PyExc_ValueError, "Invalid datetime_mode, out of range");

return false;

}

datetime_mode = (unsigned) mode;

} else {

PyErr_SetString(PyExc_TypeError,

"datetime_mode must be a non-negative int");

return false;

}

}

return true;

{

if (arg != NULL && arg != Py_None) {

if (PyLong_Check(arg)) {

long mode = PyLong_AsLong(arg);

if (mode < 0 || mode >= UM_MAX) {

PyErr_SetString(PyExc_ValueError, "Invalid uuid_mode, out of range");

return false;

}

uuid_mode = (unsigned) mode;

} else {

PyErr_SetString(PyExc_TypeError, "uuid_mode must be a non-negative int");

return false;

}

}

return true;

{

if (arg != NULL && arg != Py_None) {

if (PyLong_Check(arg)) {

long mode = PyLong_AsLong(arg);

if (mode < 0 || mode >= BM_MAX) {

PyErr_SetString(PyExc_ValueError, "Invalid bytes_mode, out of range");

return false;

}

bytes_mode = (unsigned) mode;

} else {

PyErr_SetString(PyExc_TypeError, "bytes_mode must be a non-negative int");

return false;

}

}

return true;

{

if (arg != NULL && arg != Py_None) {

if (PyLong_Check(arg)) {

long mode = PyLong_AsLong(arg);

if (mode < 0 || mode >= IM_MAX) {

PyErr_SetString(PyExc_ValueError, "Invalid iterable_mode, out of range");

return false;

}

iterable_mode = (unsigned) mode;

} else {

PyErr_SetString(PyExc_TypeError, "iterable_mode must be a non-negative int");

return false;

}

}

return true;

{

if (arg != NULL && arg != Py_None) {

if (PyLong_Check(arg)) {

long mode = PyLong_AsLong(arg);

if (mode < 0 || mode >= MM_MAX) {

PyErr_SetString(PyExc_ValueError, "Invalid mapping_mode, out of range");

return false;

}

mapping_mode = (unsigned) mode;

} else {

PyErr_SetString(PyExc_TypeError, "mapping_mode must be a non-negative int");

return false;

}

}

return true;

{

if (arg != NULL && arg != Py_None) {

if (PyLong_Check(arg)) {

Py_ssize_t size = PyNumber_AsSsize_t(arg, PyExc_ValueError);

if (PyErr_Occurred() || size < 4 || size > UINT_MAX) {

PyErr_SetString(PyExc_ValueError, "Invalid chunk_size, out of range");

return false;

}

chunk_size = (size_t) size;

} else {

PyErr_SetString(PyExc_TypeError,

"chunk_size must be a non-negative int");

return false;

}

}

return true;

{

if (arg != NULL && arg != Py_None) {

if (PyLong_Check(arg)) {

long mode = PyLong_AsLong(arg);

if (mode < 0 || mode >= PM_MAX) {

PyErr_SetString(PyExc_ValueError, "Invalid parse_mode, out of range");

return false;

}

parse_mode = (unsigned) mode;

} else {

PyErr_SetString(PyExc_TypeError,

"parse_mode must be a non-negative int");

return false;

}

}

return true;

PyObject* decoderStartObject;

PyObject* decoderEndObject;

PyObject* decoderEndArray;

PyObject* decoderString;

PyObject* sharedKeys;

PyObject* root;

PyObject* objectHook;

unsigned datetimeMode;

unsigned uuidMode;

unsigned numberMode;

unsigned recursionLimit;

std::vector<HandlerContext> stack;

PyHandler(PyObject* decoder,

PyObject* hook,

unsigned dm,

unsigned um,

unsigned nm)

: decoderStartObject(NULL),

decoderEndObject(NULL),

decoderEndArray(NULL),

decoderString(NULL),

root(NULL),

objectHook(hook),

datetimeMode(dm),

uuidMode(um),

numberMode(nm)

{

stack.reserve(128);

if (decoder != NULL) {

assert(!objectHook);

if (PyObject_HasAttr(decoder, start_object_name)) {

decoderStartObject = PyObject_GetAttr(decoder, start_object_name);

}

if (PyObject_HasAttr(decoder, end_object_name)) {

decoderEndObject = PyObject_GetAttr(decoder, end_object_name);

}

if (PyObject_HasAttr(decoder, end_array_name)) {

decoderEndArray = PyObject_GetAttr(decoder, end_array_name);

}

if (PyObject_HasAttr(decoder, string_name)) {

decoderString = PyObject_GetAttr(decoder, string_name);

}

}

sharedKeys = PyDict_New();

recursionLimit = Py_GetRecursionLimit();

}

~PyHandler() {

while (!stack.empty()) {

const HandlerContext& ctx = stack.back();

if (ctx.copiedKey)

PyMem_Free((void*) ctx.key);

if (ctx.object != NULL)

Py_DECREF(ctx.object);

stack.pop_back();

}

Py_CLEAR(decoderStartObject);

Py_CLEAR(decoderEndObject);

Py_CLEAR(decoderEndArray);

Py_CLEAR(decoderString);

Py_CLEAR(sharedKeys);

}

bool Handle(PyObject* value) {

if (root) {

const HandlerContext& current = stack.back();

if (current.isObject) {

PyObject* key = PyUnicode_FromStringAndSize(current.key,

current.keyLength);

if (key == NULL) {

Py_DECREF(value);

return false;

}

PyObject* shared_key = PyDict_SetDefault(sharedKeys, key, key);

if (shared_key == NULL) {

Py_DECREF(key);

Py_DECREF(value);

return false;

}

Py_INCREF(shared_key);

Py_DECREF(key);

key = shared_key;

int rc;

if (current.keyValuePairs) {

PyObject* pair = PyTuple_Pack(2, key, value);

Py_DECREF(key);

Py_DECREF(value);

if (pair == NULL) {

return false;

}

rc = PyList_Append(current.object, pair);

Py_DECREF(pair);

} else {

if (PyDict_CheckExact(current.object))

// If it's a standard dictionary, this is +20% faster

rc = PyDict_SetItem(current.object, key, value);

else

rc = PyObject_SetItem(current.object, key, value);

Py_DECREF(key);

Py_DECREF(value);

}

if (rc == -1) {

return false;

}

} else {

int rc = PyList_Append(current.object, value);

Py_DECREF(value);

if (rc == -1) {

return false;

}

}

} else {

root = value;

}

return true;

}

bool Key(const char* str, SizeType length, bool copy) {

HandlerContext& current = stack.back();

// This happens when operating in stream mode and kParseInsituFlag is not set: we

// must copy the incoming string in the context, and destroy the duplicate when

// the context gets reused for the next dictionary key

if (current.key && current.copiedKey) {

PyMem_Free((void*) current.key);

current.key = NULL;

}

if (copy) {

char* copied_str = (char*) PyMem_Malloc(length+1);

if (copied_str == NULL)

return false;

memcpy(copied_str, str, length+1);

str = copied_str;

assert(!current.key);

}

current.key = str;

current.keyLength = length;

current.copiedKey = copy;

return true;

}

bool StartObject() {

if (recursionLimit-- == 0) {