/* JSON accelerator C extensor: _json module.

*

* It is built as a built-in module (Py_BUILD_CORE_BUILTIN define) on Windows

* and as an extension module (Py_BUILD_CORE_MODULE define) on other

* platforms. */

#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#endif

#include "Python.h"

#include "pycore_ceval.h" // _Py_EnterRecursiveCall()

#include "pycore_critical_section.h" // Py_BEGIN_CRITICAL_SECTION_SEQUENCE_FAST()

#include "pycore_global_strings.h" // _Py_ID()

#include "pycore_pyerrors.h" // _PyErr_FormatNote

#include "pycore_runtime.h" // _PyRuntime

#include "pycore_tuple.h" // _PyTuple_FromPair

#include "pycore_unicodeobject.h" // _PyUnicode_CheckConsistency()

#include <stdbool.h> // bool

#include "clinic/_json.c.h"

/*[clinic input]

module _json

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=549fa53592c925b2]*/

typedef struct _PyScannerObject {

PyObject_HEAD

signed char strict;

PyObject *object_hook;

PyObject *object_pairs_hook;

PyObject *array_hook;

PyObject *parse_float;

PyObject *parse_int;

PyObject *parse_constant;

} PyScannerObject;

#define PyScannerObject_CAST(op) ((PyScannerObject *)(op))

static PyMemberDef scanner_members[] = {

{"strict", Py_T_BOOL, offsetof(PyScannerObject, strict), Py_READONLY, "strict"},

{"object_hook", _Py_T_OBJECT, offsetof(PyScannerObject, object_hook), Py_READONLY, "object_hook"},

{"object_pairs_hook", _Py_T_OBJECT, offsetof(PyScannerObject, object_pairs_hook), Py_READONLY},

{"array_hook", _Py_T_OBJECT, offsetof(PyScannerObject, array_hook), Py_READONLY},

{"parse_float", _Py_T_OBJECT, offsetof(PyScannerObject, parse_float), Py_READONLY, "parse_float"},

{"parse_int", _Py_T_OBJECT, offsetof(PyScannerObject, parse_int), Py_READONLY, "parse_int"},

{"parse_constant", _Py_T_OBJECT, offsetof(PyScannerObject, parse_constant), Py_READONLY, "parse_constant"},

{NULL}

};

typedef struct _PyEncoderObject {

PyObject_HEAD

PyObject *markers;

PyObject *defaultfn;

PyObject *encoder;

PyObject *indent;

PyObject *key_separator;

PyObject *item_separator;

char sort_keys;

char skipkeys;

int allow_nan;

int (*fast_encode)(PyUnicodeWriter *, PyObject *);

} PyEncoderObject;

#define PyEncoderObject_CAST(op) ((PyEncoderObject *)(op))

static PyMemberDef encoder_members[] = {

{"markers", _Py_T_OBJECT, offsetof(PyEncoderObject, markers), Py_READONLY, "markers"},

{"default", _Py_T_OBJECT, offsetof(PyEncoderObject, defaultfn), Py_READONLY, "default"},

{"encoder", _Py_T_OBJECT, offsetof(PyEncoderObject, encoder), Py_READONLY, "encoder"},

{"indent", _Py_T_OBJECT, offsetof(PyEncoderObject, indent), Py_READONLY, "indent"},

{"key_separator", _Py_T_OBJECT, offsetof(PyEncoderObject, key_separator), Py_READONLY, "key_separator"},

{"item_separator", _Py_T_OBJECT, offsetof(PyEncoderObject, item_separator), Py_READONLY, "item_separator"},

{"sort_keys", Py_T_BOOL, offsetof(PyEncoderObject, sort_keys), Py_READONLY, "sort_keys"},

{"skipkeys", Py_T_BOOL, offsetof(PyEncoderObject, skipkeys), Py_READONLY, "skipkeys"},

{NULL}

};

/* Forward decls */

static PyObject *

ascii_escape_unicode(PyObject *pystr);

static PyObject *

py_encode_basestring_ascii(PyObject* Py_UNUSED(self), PyObject *pystr);

static PyObject *

scan_once_unicode(PyScannerObject *s, PyObject *memo, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr);

static PyObject *

_build_rval_index_tuple(PyObject *rval, Py_ssize_t idx);

static PyObject *

scanner_new(PyTypeObject *type, PyObject *args, PyObject *kwds);

static void

scanner_dealloc(PyObject *self);

static int

scanner_clear(PyObject *self);

static PyObject *

encoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds);

static void

encoder_dealloc(PyObject *self);

static int

encoder_clear(PyObject *self);

static int

encoder_listencode_list(PyEncoderObject *s, PyUnicodeWriter *writer, PyObject *seq, Py_ssize_t indent_level, PyObject *indent_cache);

static int

encoder_listencode_obj(PyEncoderObject *s, PyUnicodeWriter *writer, PyObject *obj, Py_ssize_t indent_level, PyObject *indent_cache);

static int

encoder_listencode_dict(PyEncoderObject *s, PyUnicodeWriter *writer, PyObject *dct, Py_ssize_t indent_level, PyObject *indent_cache);

static PyObject *

_encoded_const(PyObject *obj);

static void

raise_errmsg(const char *msg, PyObject *s, Py_ssize_t end);

static int

_steal_accumulate(PyUnicodeWriter *writer, PyObject *stolen);

static int

encoder_write_string(PyEncoderObject *s, PyUnicodeWriter *writer, PyObject *obj);

static PyObject *

encoder_encode_float(PyEncoderObject *s, PyObject *obj);

#define S_CHAR(c) (c >= ' ' && c <= '~' && c != '\\' && c != '"')

#define IS_WHITESPACE(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || ((c) == '\r'))

static Py_ssize_t

ascii_escape_unichar(Py_UCS4 c, unsigned char *output, Py_ssize_t chars)

{

/* Escape unicode code point c to ASCII escape sequences

in char *output. output must have at least 12 bytes unused to

accommodate an escaped surrogate pair "\uXXXX\uXXXX" */

output[chars++] = '\\';

switch (c) {

case '\\': output[chars++] = c; break;

case '"': output[chars++] = c; break;

case '\b': output[chars++] = 'b'; break;

case '\f': output[chars++] = 'f'; break;

case '\n': output[chars++] = 'n'; break;

case '\r': output[chars++] = 'r'; break;

case '\t': output[chars++] = 't'; break;

default:

if (c >= 0x10000) {

/* UTF-16 surrogate pair */

Py_UCS4 v = Py_UNICODE_HIGH_SURROGATE(c);

output[chars++] = 'u';

output[chars++] = Py_hexdigits[(v >> 12) & 0xf];

output[chars++] = Py_hexdigits[(v >> 8) & 0xf];

output[chars++] = Py_hexdigits[(v >> 4) & 0xf];

output[chars++] = Py_hexdigits[(v ) & 0xf];

c = Py_UNICODE_LOW_SURROGATE(c);

output[chars++] = '\\';

}

output[chars++] = 'u';

output[chars++] = Py_hexdigits[(c >> 12) & 0xf];

output[chars++] = Py_hexdigits[(c >> 8) & 0xf];

output[chars++] = Py_hexdigits[(c >> 4) & 0xf];

output[chars++] = Py_hexdigits[(c ) & 0xf];

}

return chars;

}

static Py_ssize_t

ascii_escape_size(const void *input, int kind, Py_ssize_t input_chars)

{

Py_ssize_t i;

Py_ssize_t output_size;

/* Compute the output size */

for (i = 0, output_size = 2; i < input_chars; i++) {

Py_UCS4 c = PyUnicode_READ(kind, input, i);

Py_ssize_t d;

if (S_CHAR(c)) {

d = 1;

}

else {

switch(c) {

case '\\': case '"': case '\b': case '\f':

case '\n': case '\r': case '\t':

d = 2; break;

default:

d = c >= 0x10000 ? 12 : 6;

}

}

if (output_size > PY_SSIZE_T_MAX - d) {

PyErr_SetString(PyExc_OverflowError, "string is too long to escape");

return -1;

}

output_size += d;

}

return output_size;

}

static PyObject *

ascii_escape_unicode_and_size(const void *input, int kind, Py_ssize_t input_chars, Py_ssize_t output_size)

{

Py_ssize_t i;

Py_ssize_t chars;

PyObject *rval;

Py_UCS1 *output;

rval = PyUnicode_New(output_size, 127);

if (rval == NULL) {

return NULL;

}

output = PyUnicode_1BYTE_DATA(rval);

chars = 0;

output[chars++] = '"';

for (i = 0; i < input_chars; i++) {

Py_UCS4 c = PyUnicode_READ(kind, input, i);

if (S_CHAR(c)) {

output[chars++] = c;

}

else {

chars = ascii_escape_unichar(c, output, chars);

}

}

output[chars++] = '"';

#ifdef Py_DEBUG

assert(_PyUnicode_CheckConsistency(rval, 1));

#endif

return rval;

}

static PyObject *

ascii_escape_unicode(PyObject *pystr)

{

/* Take a PyUnicode pystr and return a new ASCII-only escaped PyUnicode */

Py_ssize_t input_chars = PyUnicode_GET_LENGTH(pystr);

const void *input = PyUnicode_DATA(pystr);

int kind = PyUnicode_KIND(pystr);

Py_ssize_t output_size = ascii_escape_size(input, kind, input_chars);

if (output_size < 0) {

return NULL;

}

return ascii_escape_unicode_and_size(input, kind, input_chars, output_size);

}

static int

write_escaped_ascii(PyUnicodeWriter *writer, PyObject *pystr)

{

Py_ssize_t input_chars;

const void *input;

int kind;

input_chars = PyUnicode_GET_LENGTH(pystr);

input = PyUnicode_DATA(pystr);

kind = PyUnicode_KIND(pystr);

Py_ssize_t output_size = ascii_escape_size(input, kind, input_chars);

if (output_size < 0) {

return -1;

}

if (output_size == input_chars + 2) {

/* No need to escape anything */

if (PyUnicodeWriter_WriteChar(writer, '"') < 0) {

return -1;

}

// gh-148241: Avoid PyUnicodeWriter_WriteStr() which calls str(obj)

// on str subclasses

assert(PyUnicode_IS_ASCII(pystr));

if (PyUnicodeWriter_WriteASCII(writer, input, input_chars) < 0) {

return -1;

}

return PyUnicodeWriter_WriteChar(writer, '"');

}

PyObject *rval = ascii_escape_unicode_and_size(input, kind, input_chars, output_size);

if (rval == NULL) {

return -1;

}

return _steal_accumulate(writer, rval);

}

static Py_ssize_t

escape_size(const void *input, int kind, Py_ssize_t input_chars)

{

Py_ssize_t i;

Py_ssize_t output_size;

/* Compute the output size */

for (i = 0, output_size = 2; i < input_chars; i++) {

Py_UCS4 c = PyUnicode_READ(kind, input, i);

Py_ssize_t d;

switch (c) {

case '\\': case '"': case '\b': case '\f':

case '\n': case '\r': case '\t':

d = 2;

break;

default:

if (c <= 0x1f)

d = 6;

else

d = 1;

}

if (output_size > PY_SSIZE_T_MAX - d) {

PyErr_SetString(PyExc_OverflowError, "string is too long to escape");

return -1;

}

output_size += d;

}

return output_size;

}

static PyObject *

escape_unicode_and_size(const void *input, int kind, Py_UCS4 maxchar, Py_ssize_t input_chars, Py_ssize_t output_size)

{

Py_ssize_t i;

Py_ssize_t chars;

PyObject *rval;

rval = PyUnicode_New(output_size, maxchar);

if (rval == NULL)

return NULL;

kind = PyUnicode_KIND(rval);

#define ENCODE_OUTPUT do { \

chars = 0; \

output[chars++] = '"'; \

for (i = 0; i < input_chars; i++) { \

Py_UCS4 c = PyUnicode_READ(kind, input, i); \

switch (c) { \

case '\\': output[chars++] = '\\'; output[chars++] = c; break; \

case '"': output[chars++] = '\\'; output[chars++] = c; break; \

case '\b': output[chars++] = '\\'; output[chars++] = 'b'; break; \

case '\f': output[chars++] = '\\'; output[chars++] = 'f'; break; \

case '\n': output[chars++] = '\\'; output[chars++] = 'n'; break; \

case '\r': output[chars++] = '\\'; output[chars++] = 'r'; break; \

case '\t': output[chars++] = '\\'; output[chars++] = 't'; break; \

default: \

if (c <= 0x1f) { \

output[chars++] = '\\'; \

output[chars++] = 'u'; \

output[chars++] = '0'; \

output[chars++] = '0'; \

output[chars++] = Py_hexdigits[(c >> 4) & 0xf]; \

output[chars++] = Py_hexdigits[(c ) & 0xf]; \

} else { \

output[chars++] = c; \

} \

} \

} \

output[chars++] = '"'; \

} while (0)

if (kind == PyUnicode_1BYTE_KIND) {

Py_UCS1 *output = PyUnicode_1BYTE_DATA(rval);

ENCODE_OUTPUT;

} else if (kind == PyUnicode_2BYTE_KIND) {

Py_UCS2 *output = PyUnicode_2BYTE_DATA(rval);

ENCODE_OUTPUT;

} else {

Py_UCS4 *output = PyUnicode_4BYTE_DATA(rval);

assert(kind == PyUnicode_4BYTE_KIND);

ENCODE_OUTPUT;

}

#undef ENCODE_OUTPUT

#ifdef Py_DEBUG

assert(_PyUnicode_CheckConsistency(rval, 1));

#endif

return rval;

}

static PyObject *

escape_unicode(PyObject *pystr)

{

/* Take a PyUnicode pystr and return a new escaped PyUnicode */

Py_ssize_t input_chars = PyUnicode_GET_LENGTH(pystr);

const void *input = PyUnicode_DATA(pystr);

int kind = PyUnicode_KIND(pystr);

Py_UCS4 maxchar = PyUnicode_MAX_CHAR_VALUE(pystr);

Py_ssize_t output_size = escape_size(input, kind, input_chars);

if (output_size < 0) {

return NULL;

}

return escape_unicode_and_size(input, kind, maxchar, input_chars, output_size);

}

static int

write_escaped_unicode(PyUnicodeWriter *writer, PyObject *pystr)

{

Py_ssize_t input_chars = PyUnicode_GET_LENGTH(pystr);

const void *input = PyUnicode_DATA(pystr);

int kind = PyUnicode_KIND(pystr);

Py_UCS4 maxchar = PyUnicode_MAX_CHAR_VALUE(pystr);

Py_ssize_t output_size = escape_size(input, kind, input_chars);

if (output_size < 0) {

return -1;

}

if (output_size == input_chars + 2) {

/* No need to escape anything */

if (PyUnicodeWriter_WriteChar(writer, '"') < 0) {

return -1;

}

// gh-148241: Avoid PyUnicodeWriter_WriteStr() which calls str(obj)

// on str subclasses

if (_PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, pystr) < 0) {

return -1;

}

return PyUnicodeWriter_WriteChar(writer, '"');

}

PyObject *rval = escape_unicode_and_size(input, kind, maxchar, input_chars, output_size);

if (rval == NULL) {

return -1;

}

return _steal_accumulate(writer, rval);

}

static void

raise_errmsg(const char *msg, PyObject *s, Py_ssize_t end)

{

/* Use JSONDecodeError exception to raise a nice looking ValueError subclass */

_Py_DECLARE_STR(json_decoder, "json.decoder");

PyObject *JSONDecodeError =

PyImport_ImportModuleAttr(&_Py_STR(json_decoder), &_Py_ID(JSONDecodeError));

if (JSONDecodeError == NULL) {

return;

}

PyObject *exc;

exc = PyObject_CallFunction(JSONDecodeError, "zOn", msg, s, end);

if (exc) {

PyErr_SetObject(JSONDecodeError, exc);

Py_DECREF(exc);

}

Py_DECREF(JSONDecodeError);

}

static void

raise_stop_iteration(Py_ssize_t idx)

{

PyObject *value = PyLong_FromSsize_t(idx);

if (value != NULL) {

PyErr_SetObject(PyExc_StopIteration, value);

Py_DECREF(value);

}

}

static PyObject *

_build_rval_index_tuple(PyObject *rval, Py_ssize_t idx) {

/* return (rval, idx) tuple, stealing reference to rval */

PyObject *pyidx;

/*

steal a reference to rval, returns (rval, idx)

*/

if (rval == NULL) {

return NULL;

}

pyidx = PyLong_FromSsize_t(idx);

if (pyidx == NULL) {

Py_DECREF(rval);

return NULL;

}

return _PyTuple_FromPairSteal(rval, pyidx);

}

static PyObject *

scanstring_unicode(PyObject *pystr, Py_ssize_t end, int strict, Py_ssize_t *next_end_ptr)

{

/* Read the JSON string from PyUnicode pystr.

end is the index of the first character after the quote.

if strict is zero then literal control characters are allowed

*next_end_ptr is a return-by-reference index of the character

after the end quote

Return value is a new PyUnicode

*/

PyObject *rval = NULL;

Py_ssize_t len;

Py_ssize_t begin = end - 1;

Py_ssize_t next /* = begin */;

const void *buf;

int kind;

PyUnicodeWriter *writer = NULL;

len = PyUnicode_GET_LENGTH(pystr);

buf = PyUnicode_DATA(pystr);

kind = PyUnicode_KIND(pystr);

if (end < 0 || len < end) {

PyErr_SetString(PyExc_ValueError, "end is out of bounds");

goto bail;

}

while (1) {

/* Find the end of the string or the next escape */

Py_UCS4 c;

{

// Use tight scope variable to help register allocation.

Py_UCS4 d = 0;

for (next = end; next < len; next++) {

d = PyUnicode_READ(kind, buf, next);

if (d == '"' || d == '\\') {

break;

}

if (d <= 0x1f && strict) {

raise_errmsg("Invalid control character at", pystr, next);

goto bail;

}

}

c = d;

}

if (c == '"') {

// Fast path for simple case.

if (writer == NULL) {

PyObject *ret = PyUnicode_Substring(pystr, end, next);

if (ret == NULL) {

goto bail;

}

*next_end_ptr = next + 1;;

return ret;

}

}

else if (c != '\\') {

raise_errmsg("Unterminated string starting at", pystr, begin);

goto bail;

} else if (writer == NULL) {

writer = PyUnicodeWriter_Create(0);

if (writer == NULL) {

goto bail;

}

}

/* Pick up this chunk if it's not zero length */

if (next != end) {

if (PyUnicodeWriter_WriteSubstring(writer, pystr, end, next) < 0) {

goto bail;

}

}

next++;

if (c == '"') {

end = next;

break;

}

if (next == len) {

raise_errmsg("Unterminated string starting at", pystr, begin);

goto bail;

}

c = PyUnicode_READ(kind, buf, next);

if (c != 'u') {

/* Non-unicode backslash escapes */

end = next + 1;

switch (c) {

case '"': break;

case '\\': break;

case '/': break;

case 'b': c = '\b'; break;

case 'f': c = '\f'; break;

case 'n': c = '\n'; break;

case 'r': c = '\r'; break;

case 't': c = '\t'; break;

default: c = 0;

}

if (c == 0) {

raise_errmsg("Invalid \\escape", pystr, end - 2);

goto bail;

}

}

else {

c = 0;

next++;

end = next + 4;

if (end >= len) {

raise_errmsg("Invalid \\uXXXX escape", pystr, next - 1);

goto bail;

}

/* Decode 4 hex digits */

for (; next < end; next++) {

Py_UCS4 digit = PyUnicode_READ(kind, buf, next);

c <<= 4;

switch (digit) {

case '0': case '1': case '2': case '3': case '4':

case '5': case '6': case '7': case '8': case '9':

c |= (digit - '0'); break;

case 'a': case 'b': case 'c': case 'd': case 'e':

case 'f':

c |= (digit - 'a' + 10); break;

case 'A': case 'B': case 'C': case 'D': case 'E':

case 'F':

c |= (digit - 'A' + 10); break;

default:

raise_errmsg("Invalid \\uXXXX escape", pystr, end - 5);

goto bail;

}

}

/* Surrogate pair */

if (Py_UNICODE_IS_HIGH_SURROGATE(c) && end + 6 < len &&

PyUnicode_READ(kind, buf, next++) == '\\' &&

PyUnicode_READ(kind, buf, next++) == 'u') {

Py_UCS4 c2 = 0;

end += 6;

/* Decode 4 hex digits */

for (; next < end; next++) {

Py_UCS4 digit = PyUnicode_READ(kind, buf, next);

c2 <<= 4;

switch (digit) {

case '0': case '1': case '2': case '3': case '4':

case '5': case '6': case '7': case '8': case '9':

c2 |= (digit - '0'); break;

case 'a': case 'b': case 'c': case 'd': case 'e':

case 'f':

c2 |= (digit - 'a' + 10); break;

case 'A': case 'B': case 'C': case 'D': case 'E':

case 'F':

c2 |= (digit - 'A' + 10); break;

default:

raise_errmsg("Invalid \\uXXXX escape", pystr, end - 5);

goto bail;

}

}

if (Py_UNICODE_IS_LOW_SURROGATE(c2))

c = Py_UNICODE_JOIN_SURROGATES(c, c2);

else

end -= 6;

}

}

if (PyUnicodeWriter_WriteChar(writer, c) < 0) {

goto bail;

}

}

rval = PyUnicodeWriter_Finish(writer);

*next_end_ptr = end;

return rval;

bail:

*next_end_ptr = -1;

PyUnicodeWriter_Discard(writer);

return NULL;

}

/*[clinic input]

_json.scanstring as py_scanstring

pystr: unicode

end: Py_ssize_t

strict: bool = True

/

Scan the string s for a JSON string.

End is the index of the character in s after the quote that started the

JSON string. Unescapes all valid JSON string escape sequences and raises

ValueError on attempt to decode an invalid string. If strict is False

then literal control characters are allowed in the string.

Returns a tuple of the decoded string and the index of the character in s

after the end quote.

[clinic start generated code]*/

static PyObject *

py_scanstring_impl(PyObject *module, PyObject *pystr, Py_ssize_t end,

int strict)

/*[clinic end generated code: output=961740cfae07cdb3 input=cff59e47498f4d8e]*/

{

Py_ssize_t next_end = -1;

PyObject *rval = scanstring_unicode(pystr, end, strict, &next_end);

return _build_rval_index_tuple(rval, next_end);

}

/*[clinic input]

_json.encode_basestring_ascii as py_encode_basestring_ascii

pystr: unicode

/

Return an ASCII-only JSON representation of a Python string

[clinic start generated code]*/

static PyObject *

py_encode_basestring_ascii_impl(PyObject *module, PyObject *pystr)

/*[clinic end generated code: output=7b3841287cf211df input=4f3609498aff2de5]*/

{

return ascii_escape_unicode(pystr);

}

/*[clinic input]

_json.encode_basestring as py_encode_basestring

pystr: unicode

/

Return a JSON representation of a Python string

[clinic start generated code]*/

static PyObject *

py_encode_basestring_impl(PyObject *module, PyObject *pystr)

/*[clinic end generated code: output=900950f95df3f1c9 input=d42ef714b2c07386]*/

{

return escape_unicode(pystr);

}

static void

scanner_dealloc(PyObject *self)

{

PyTypeObject *tp = Py_TYPE(self);

/* bpo-31095: UnTrack is needed before calling any callbacks */

PyObject_GC_UnTrack(self);

(void)scanner_clear(self);

tp->tp_free(self);

Py_DECREF(tp);

}

static int

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

{

PyScannerObject *self = PyScannerObject_CAST(op);

Py_VISIT(Py_TYPE(self));

Py_VISIT(self->object_hook);

Py_VISIT(self->object_pairs_hook);

Py_VISIT(self->array_hook);

Py_VISIT(self->parse_float);

Py_VISIT(self->parse_int);

Py_VISIT(self->parse_constant);

return 0;

}

static int

scanner_clear(PyObject *op)

{

PyScannerObject *self = PyScannerObject_CAST(op);

Py_CLEAR(self->object_hook);

Py_CLEAR(self->object_pairs_hook);

Py_CLEAR(self->array_hook);

Py_CLEAR(self->parse_float);

Py_CLEAR(self->parse_int);

Py_CLEAR(self->parse_constant);

return 0;

}

static PyObject *

_parse_object_unicode(PyScannerObject *s, PyObject *memo, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr)

{

/* Read a JSON object from PyUnicode pystr.

idx is the index of the first character after the opening curly brace.

*next_idx_ptr is a return-by-reference index to the first character after

the closing curly brace.

Returns a new PyObject (usually a dict, but object_hook can change that)

*/

const void *str;

int kind;

Py_ssize_t end_idx;

PyObject *val = NULL;

PyObject *rval = NULL;

PyObject *key = NULL;

int has_pairs_hook = (s->object_pairs_hook != Py_None);

Py_ssize_t next_idx;

Py_ssize_t comma_idx;

str = PyUnicode_DATA(pystr);

kind = PyUnicode_KIND(pystr);

end_idx = PyUnicode_GET_LENGTH(pystr) - 1;

if (has_pairs_hook)

rval = PyList_New(0);

else

rval = PyDict_New();

if (rval == NULL)

return NULL;

/* skip whitespace after { */

while (idx <= end_idx && IS_WHITESPACE(PyUnicode_READ(kind,str, idx))) idx++;

/* only loop if the object is non-empty */

if (idx > end_idx || PyUnicode_READ(kind, str, idx) != '}') {

while (1) {

PyObject *memokey;

/* read key */

if (idx > end_idx || PyUnicode_READ(kind, str, idx) != '"') {

raise_errmsg("Expecting property name enclosed in double quotes", pystr, idx);

goto bail;

}

key = scanstring_unicode(pystr, idx + 1, s->strict, &next_idx);

if (key == NULL)

goto bail;

if (PyDict_SetDefaultRef(memo, key, key, &memokey) < 0) {

goto bail;

}

Py_SETREF(key, memokey);

idx = next_idx;

/* skip whitespace between key and : delimiter, read :, skip whitespace */

while (idx <= end_idx && IS_WHITESPACE(PyUnicode_READ(kind, str, idx))) idx++;

if (idx > end_idx || PyUnicode_READ(kind, str, idx) != ':') {

raise_errmsg("Expecting ':' delimiter", pystr, idx);

goto bail;

}

idx++;

while (idx <= end_idx && IS_WHITESPACE(PyUnicode_READ(kind, str, idx))) idx++;

/* read any JSON term */

val = scan_once_unicode(s, memo, pystr, idx, &next_idx);

if (val == NULL)

goto bail;

if (has_pairs_hook) {

PyObject *item = _PyTuple_FromPairSteal(key, val);

key = val = NULL;

if (item == NULL)

goto bail;

if (PyList_Append(rval, item) == -1) {

Py_DECREF(item);

goto bail;

}

Py_DECREF(item);

}

else {

if (PyDict_SetItem(rval, key, val) < 0)

goto bail;

Py_CLEAR(key);

Py_CLEAR(val);

}

idx = next_idx;

/* skip whitespace before } or , */

while (idx <= end_idx && IS_WHITESPACE(PyUnicode_READ(kind, str, idx))) idx++;

/* bail if the object is closed or we didn't get the , delimiter */

if (idx <= end_idx && PyUnicode_READ(kind, str, idx) == '}')

break;

if (idx > end_idx || PyUnicode_READ(kind, str, idx) != ',') {

raise_errmsg("Expecting ',' delimiter", pystr, idx);

goto bail;

}

comma_idx = idx;

idx++;

/* skip whitespace after , delimiter */

while (idx <= end_idx && IS_WHITESPACE(PyUnicode_READ(kind, str, idx))) idx++;

if (idx <= end_idx && PyUnicode_READ(kind, str, idx) == '}') {

raise_errmsg("Illegal trailing comma before end of object", pystr, comma_idx);

goto bail;

}

}

}

*next_idx_ptr = idx + 1;

if (has_pairs_hook) {

val = PyObject_CallOneArg(s->object_pairs_hook, rval);

Py_DECREF(rval);

return val;

}

/* if object_hook is not None: rval = object_hook(rval) */

if (s->object_hook != Py_None) {

val = PyObject_CallOneArg(s->object_hook, rval);

Py_DECREF(rval);

return val;

}

return rval;

bail:

Py_XDECREF(key);

Py_XDECREF(val);

Py_XDECREF(rval);

return NULL;

}

static PyObject *

_parse_array_unicode(PyScannerObject *s, PyObject *memo, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr) {

/* Read a JSON array from PyUnicode pystr.

idx is the index of the first character after the opening brace.

*next_idx_ptr is a return-by-reference index to the first character after

the closing brace.

Returns a new PyList

*/

const void *str;

int kind;

Py_ssize_t end_idx;

PyObject *val = NULL;

PyObject *rval;

Py_ssize_t next_idx;

Py_ssize_t comma_idx;

rval = PyList_New(0);

if (rval == NULL)

return NULL;

str = PyUnicode_DATA(pystr);

kind = PyUnicode_KIND(pystr);

end_idx = PyUnicode_GET_LENGTH(pystr) - 1;

/* skip whitespace after [ */

while (idx <= end_idx && IS_WHITESPACE(PyUnicode_READ(kind, str, idx))) idx++;

/* only loop if the array is non-empty */

if (idx > end_idx || PyUnicode_READ(kind, str, idx) != ']') {

while (1) {

/* read any JSON term */

val = scan_once_unicode(s, memo, pystr, idx, &next_idx);

if (val == NULL)

goto bail;

if (PyList_Append(rval, val) == -1)

goto bail;

Py_CLEAR(val);

idx = next_idx;

/* skip whitespace between term and , */

while (idx <= end_idx && IS_WHITESPACE(PyUnicode_READ(kind, str, idx))) idx++;

/* bail if the array is closed or we didn't get the , delimiter */

if (idx <= end_idx && PyUnicode_READ(kind, str, idx) == ']')

break;

if (idx > end_idx || PyUnicode_READ(kind, str, idx) != ',') {

raise_errmsg("Expecting ',' delimiter", pystr, idx);

goto bail;

}

comma_idx = idx;

idx++;

/* skip whitespace after , */

while (idx <= end_idx && IS_WHITESPACE(PyUnicode_READ(kind, str, idx))) idx++;

if (idx <= end_idx && PyUnicode_READ(kind, str, idx) == ']') {

raise_errmsg("Illegal trailing comma before end of array", pystr, comma_idx);

goto bail;

}

}

}

/* verify that idx < end_idx, PyUnicode_READ(kind, str, idx) should be ']' */

if (idx > end_idx || PyUnicode_READ(kind, str, idx) != ']') {

raise_errmsg("Expecting value", pystr, end_idx);

goto bail;

}

*next_idx_ptr = idx + 1;

/* if array_hook is not None: return array_hook(rval) */

if (!Py_IsNone(s->array_hook)) {

val = PyObject_CallOneArg(s->array_hook, rval);

Py_DECREF(rval);

return val;

}

return rval;

bail:

Py_XDECREF(val);

Py_DECREF(rval);

return NULL;

}

static PyObject *

_parse_constant(PyScannerObject *s, const char *constant, Py_ssize_t idx, Py_ssize_t *next_idx_ptr) {

/* Read a JSON constant.

constant is the constant string that was found

("NaN", "Infinity", "-Infinity").

idx is the index of the first character of the constant

*next_idx_ptr is a return-by-reference index to the first character after

the constant.

Returns the result of parse_constant

*/

PyObject *cstr;

PyObject *rval;

/* constant is "NaN", "Infinity", or "-Infinity" */

cstr = PyUnicode_InternFromString(constant);

if (cstr == NULL)

return NULL;

/* rval = parse_constant(constant) */

rval = PyObject_CallOneArg(s->parse_constant, cstr);

idx += PyUnicode_GET_LENGTH(cstr);

Py_DECREF(cstr);

*next_idx_ptr = idx;

return rval;

}

static PyObject *

_match_number_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t start, Py_ssize_t *next_idx_ptr) {

/* Read a JSON number from PyUnicode pystr.

idx is the index of the first character of the number

*next_idx_ptr is a return-by-reference index to the first character after

the number.

Returns a new PyObject representation of that number:

PyLong, or PyFloat.

May return other types if parse_int or parse_float are set

*/

const void *str;

int kind;

Py_ssize_t end_idx;

Py_ssize_t idx = start;

int is_float = 0;

PyObject *rval;