#include "Python.h"

#include "structmember.h"

#if PY_VERSION_HEX < 0x02060000 && !defined(Py_TYPE)

#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)

#endif

#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)

typedef int Py_ssize_t;

#define PY_SSIZE_T_MAX INT_MAX

#define PY_SSIZE_T_MIN INT_MIN

#define PyInt_FromSsize_t PyInt_FromLong

#define PyInt_AsSsize_t PyInt_AsLong

#endif

#ifndef Py_IS_FINITE

#define Py_IS_FINITE(X) (!Py_IS_INFINITY(X) && !Py_IS_NAN(X))

#endif

#ifdef __GNUC__

#define UNUSED __attribute__((__unused__))

#else

#define UNUSED

#endif

#define DEFAULT_ENCODING "utf-8"

#define PyScanner_Check(op) PyObject_TypeCheck(op, &PyScannerType)

#define PyScanner_CheckExact(op) (Py_TYPE(op) == &PyScannerType)

#define PyEncoder_Check(op) PyObject_TypeCheck(op, &PyEncoderType)

#define PyEncoder_CheckExact(op) (Py_TYPE(op) == &PyEncoderType)

static PyTypeObject PyScannerType;

static PyTypeObject PyEncoderType;

typedef struct _PyScannerObject {

PyObject_HEAD

PyObject *encoding;

PyObject *strict;

PyObject *object_hook;

PyObject *pairs_hook;

PyObject *parse_float;

PyObject *parse_int;

PyObject *parse_constant;

} PyScannerObject;

static PyMemberDef scanner_members[] = {

{"encoding", T_OBJECT, offsetof(PyScannerObject, encoding), READONLY, "encoding"},

{"strict", T_OBJECT, offsetof(PyScannerObject, strict), READONLY, "strict"},

{"object_hook", T_OBJECT, offsetof(PyScannerObject, object_hook), READONLY, "object_hook"},

{"object_pairs_hook", T_OBJECT, offsetof(PyScannerObject, pairs_hook), READONLY, "object_pairs_hook"},

{"parse_float", T_OBJECT, offsetof(PyScannerObject, parse_float), READONLY, "parse_float"},

{"parse_int", T_OBJECT, offsetof(PyScannerObject, parse_int), READONLY, "parse_int"},

{"parse_constant", T_OBJECT, offsetof(PyScannerObject, parse_constant), READONLY, "parse_constant"},

{NULL}

};

typedef struct _PyEncoderObject {

PyObject_HEAD

PyObject *markers;

PyObject *defaultfn;

PyObject *encoder;

PyObject *indent;

PyObject *key_separator;

PyObject *item_separator;

PyObject *sort_keys;

PyObject *skipkeys;

int fast_encode;

int allow_nan;

} PyEncoderObject;

static PyMemberDef encoder_members[] = {

{"markers", T_OBJECT, offsetof(PyEncoderObject, markers), READONLY, "markers"},

{"default", T_OBJECT, offsetof(PyEncoderObject, defaultfn), READONLY, "default"},

{"encoder", T_OBJECT, offsetof(PyEncoderObject, encoder), READONLY, "encoder"},

{"indent", T_OBJECT, offsetof(PyEncoderObject, indent), READONLY, "indent"},

{"key_separator", T_OBJECT, offsetof(PyEncoderObject, key_separator), READONLY, "key_separator"},

{"item_separator", T_OBJECT, offsetof(PyEncoderObject, item_separator), READONLY, "item_separator"},

{"sort_keys", T_OBJECT, offsetof(PyEncoderObject, sort_keys), READONLY, "sort_keys"},

{"skipkeys", T_OBJECT, offsetof(PyEncoderObject, skipkeys), READONLY, "skipkeys"},

{NULL}

};

static Py_ssize_t

ascii_escape_char(Py_UNICODE c, char *output, Py_ssize_t chars);

static PyObject *

ascii_escape_unicode(PyObject *pystr);

static PyObject *

ascii_escape_str(PyObject *pystr);

static PyObject *

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

void init_json(void);

static PyObject *

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

static PyObject *

scan_once_unicode(PyScannerObject *s, 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 int

scanner_init(PyObject *self, 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 int

encoder_init(PyObject *self, PyObject *args, PyObject *kwds);

static void

encoder_dealloc(PyObject *self);

static int

encoder_clear(PyObject *self);

static int

encoder_listencode_list(PyEncoderObject *s, PyObject *rval, PyObject *seq, Py_ssize_t indent_level);

static int

encoder_listencode_obj(PyEncoderObject *s, PyObject *rval, PyObject *obj, Py_ssize_t indent_level);

static int

encoder_listencode_dict(PyEncoderObject *s, PyObject *rval, PyObject *dct, Py_ssize_t indent_level);

static PyObject *

_encoded_const(PyObject *obj);

static void

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

static PyObject *

encoder_encode_string(PyEncoderObject *s, PyObject *obj);

static int

_convertPyInt_AsSsize_t(PyObject *o, Py_ssize_t *size_ptr);

static PyObject *

_convertPyInt_FromSsize_t(Py_ssize_t *size_ptr);

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'))

#define MIN_EXPANSION 6

#ifdef Py_UNICODE_WIDE

#define MAX_EXPANSION (2 * MIN_EXPANSION)

#else

#define MAX_EXPANSION MIN_EXPANSION

#endif

static int

_convertPyInt_AsSsize_t(PyObject *o, Py_ssize_t *size_ptr)

{

/* PyObject to Py_ssize_t converter */

*size_ptr = PyInt_AsSsize_t(o);

if (*size_ptr == -1 && PyErr_Occurred())

return 0;

return 1;

}

static PyObject *

_convertPyInt_FromSsize_t(Py_ssize_t *size_ptr)

{

/* Py_ssize_t to PyObject converter */

return PyInt_FromSsize_t(*size_ptr);

}

static Py_ssize_t

ascii_escape_char(Py_UNICODE c, 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++] = (char)c; break;

case '"': output[chars++] = (char)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:

#ifdef Py_UNICODE_WIDE

if (c >= 0x10000) {

/* UTF-16 surrogate pair */

Py_UNICODE v = c - 0x10000;

c = 0xd800 | ((v >> 10) & 0x3ff);

output[chars++] = 'u';

output[chars++] = "0123456789abcdef"[(c >> 12) & 0xf];

output[chars++] = "0123456789abcdef"[(c >> 8) & 0xf];

output[chars++] = "0123456789abcdef"[(c >> 4) & 0xf];

output[chars++] = "0123456789abcdef"[(c ) & 0xf];

c = 0xdc00 | (v & 0x3ff);

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

}

#endif

output[chars++] = 'u';

output[chars++] = "0123456789abcdef"[(c >> 12) & 0xf];

output[chars++] = "0123456789abcdef"[(c >> 8) & 0xf];

output[chars++] = "0123456789abcdef"[(c >> 4) & 0xf];

output[chars++] = "0123456789abcdef"[(c ) & 0xf];

}

return chars;

}

static PyObject *

ascii_escape_unicode(PyObject *pystr)

{

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

Py_ssize_t i;

Py_ssize_t input_chars;

Py_ssize_t output_size;

Py_ssize_t max_output_size;

Py_ssize_t chars;

PyObject *rval;

char *output;

Py_UNICODE *input_unicode;

input_chars = PyUnicode_GET_SIZE(pystr);

input_unicode = PyUnicode_AS_UNICODE(pystr);

/* One char input can be up to 6 chars output, estimate 4 of these */

output_size = 2 + (MIN_EXPANSION * 4) + input_chars;

max_output_size = 2 + (input_chars * MAX_EXPANSION);

rval = PyString_FromStringAndSize(NULL, output_size);

if (rval == NULL) {

return NULL;

}

output = PyString_AS_STRING(rval);

chars = 0;

output[chars++] = '"';

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

Py_UNICODE c = input_unicode[i];

if (S_CHAR(c)) {

output[chars++] = (char)c;

}

else {

chars = ascii_escape_char(c, output, chars);

}

if (output_size - chars < (1 + MAX_EXPANSION)) {

/* There's more than four, so let's resize by a lot */

Py_ssize_t new_output_size = output_size * 2;

/* This is an upper bound */

if (new_output_size > max_output_size) {

new_output_size = max_output_size;

}

/* Make sure that the output size changed before resizing */

if (new_output_size != output_size) {

output_size = new_output_size;

if (_PyString_Resize(&rval, output_size) == -1) {

return NULL;

}

output = PyString_AS_STRING(rval);

}

}

}

output[chars++] = '"';

if (_PyString_Resize(&rval, chars) == -1) {

return NULL;

}

return rval;

}

static PyObject *

ascii_escape_str(PyObject *pystr)

{

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

Py_ssize_t i;

Py_ssize_t input_chars;

Py_ssize_t output_size;

Py_ssize_t chars;

PyObject *rval;

char *output;

char *input_str;

input_chars = PyString_GET_SIZE(pystr);

input_str = PyString_AS_STRING(pystr);

/* Fast path for a string that's already ASCII */

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

Py_UNICODE c = (Py_UNICODE)(unsigned char)input_str[i];

if (!S_CHAR(c)) {

/* If we have to escape something, scan the string for unicode */

Py_ssize_t j;

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

c = (Py_UNICODE)(unsigned char)input_str[j];

if (c > 0x7f) {

/* We hit a non-ASCII character, bail to unicode mode */

PyObject *uni;

uni = PyUnicode_DecodeUTF8(input_str, input_chars, "strict");

if (uni == NULL) {

return NULL;

}

rval = ascii_escape_unicode(uni);

Py_DECREF(uni);

return rval;

}

}

break;

}

}

if (i == input_chars) {

/* Input is already ASCII */

output_size = 2 + input_chars;

}

else {

/* One char input can be up to 6 chars output, estimate 4 of these */

output_size = 2 + (MIN_EXPANSION * 4) + input_chars;

}

rval = PyString_FromStringAndSize(NULL, output_size);

if (rval == NULL) {

return NULL;

}

output = PyString_AS_STRING(rval);

output[0] = '"';

/* We know that everything up to i is ASCII already */

chars = i + 1;

memcpy(&output[1], input_str, i);

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

Py_UNICODE c = (Py_UNICODE)(unsigned char)input_str[i];

if (S_CHAR(c)) {

output[chars++] = (char)c;

}

else {

chars = ascii_escape_char(c, output, chars);

}

/* An ASCII char can't possibly expand to a surrogate! */

if (output_size - chars < (1 + MIN_EXPANSION)) {

/* There's more than four, so let's resize by a lot */

output_size *= 2;

if (output_size > 2 + (input_chars * MIN_EXPANSION)) {

output_size = 2 + (input_chars * MIN_EXPANSION);

}

if (_PyString_Resize(&rval, output_size) == -1) {

return NULL;

}

output = PyString_AS_STRING(rval);

}

}

output[chars++] = '"';

if (_PyString_Resize(&rval, chars) == -1) {

return NULL;

}

return rval;

}

static void

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

{

/* Use the Python function json.decoder.errmsg to raise a nice

looking ValueError exception */

static PyObject *errmsg_fn = NULL;

PyObject *pymsg;

if (errmsg_fn == NULL) {

PyObject *decoder = PyImport_ImportModule("json.decoder");

if (decoder == NULL)

return;

errmsg_fn = PyObject_GetAttrString(decoder, "errmsg");

Py_DECREF(decoder);

if (errmsg_fn == NULL)

return;

}

pymsg = PyObject_CallFunction(errmsg_fn, "(zOO&)", msg, s, _convertPyInt_FromSsize_t, &end);

if (pymsg) {

PyErr_SetObject(PyExc_ValueError, pymsg);

Py_DECREF(pymsg);

}

}

static PyObject *

join_list_unicode(PyObject *lst)

{

/* return u''.join(lst) */

static PyObject *joinfn = NULL;

if (joinfn == NULL) {

PyObject *ustr = PyUnicode_FromUnicode(NULL, 0);

if (ustr == NULL)

return NULL;

joinfn = PyObject_GetAttrString(ustr, "join");

Py_DECREF(ustr);

if (joinfn == NULL)

return NULL;

}

return PyObject_CallFunctionObjArgs(joinfn, lst, NULL);

}

static PyObject *

_build_rval_index_tuple(PyObject *rval, Py_ssize_t idx) {

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

PyObject *tpl;

PyObject *pyidx;

/*

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

*/

if (rval == NULL) {

return NULL;

}

pyidx = PyInt_FromSsize_t(idx);

if (pyidx == NULL) {

Py_DECREF(rval);

return NULL;

}

tpl = PyTuple_New(2);

if (tpl == NULL) {

Py_DECREF(pyidx);

Py_DECREF(rval);

return NULL;

}

PyTuple_SET_ITEM(tpl, 0, rval);

PyTuple_SET_ITEM(tpl, 1, pyidx);

return tpl;

}

static PyObject *

scanstring_str(PyObject *pystr, Py_ssize_t end, char *encoding, int strict, Py_ssize_t *next_end_ptr)

{

/* Read the JSON string from PyString pystr.

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

encoding is the encoding of pystr (must be an ASCII superset)

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 PyString (if ASCII-only) or PyUnicode

*/

PyObject *rval;

Py_ssize_t len = PyString_GET_SIZE(pystr);

Py_ssize_t begin = end - 1;

Py_ssize_t next;

char *buf = PyString_AS_STRING(pystr);

PyObject *chunks = PyList_New(0);

if (chunks == NULL) {

goto bail;

}

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_UNICODE c = 0;

PyObject *chunk = NULL;

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

c = (unsigned char)buf[next];

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

break;

}

else if (strict && c <= 0x1f) {

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

goto bail;

}

}

if (!(c == '"' || c == '\\')) {

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

goto bail;

}

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

if (next != end) {

PyObject *strchunk = PyString_FromStringAndSize(&buf[end], next - end);

if (strchunk == NULL) {

goto bail;

}

chunk = PyUnicode_FromEncodedObject(strchunk, encoding, NULL);

Py_DECREF(strchunk);

if (chunk == NULL) {

goto bail;

}

if (PyList_Append(chunks, chunk)) {

Py_DECREF(chunk);

goto bail;

}

Py_DECREF(chunk);

}

next++;

if (c == '"') {

end = next;

break;

}

if (next == len) {

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

goto bail;

}

c = 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_UNICODE digit = 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;

}

}

#ifdef Py_UNICODE_WIDE

/* Surrogate pair */

if ((c & 0xfc00) == 0xd800) {

Py_UNICODE c2 = 0;

if (end + 6 >= len) {

raise_errmsg("Unpaired high surrogate", pystr, end - 5);

goto bail;

}

if (buf[next++] != '\\' || buf[next++] != 'u') {

raise_errmsg("Unpaired high surrogate", pystr, end - 5);

goto bail;

}

end += 6;

/* Decode 4 hex digits */

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

Py_UNICODE digit = 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 ((c2 & 0xfc00) != 0xdc00) {

raise_errmsg("Unpaired high surrogate", pystr, end - 5);

goto bail;

}

c = 0x10000 + (((c - 0xd800) << 10) | (c2 - 0xdc00));

}

else if ((c & 0xfc00) == 0xdc00) {

raise_errmsg("Unpaired low surrogate", pystr, end - 5);

goto bail;

}

#endif

}

chunk = PyUnicode_FromUnicode(&c, 1);

if (chunk == NULL) {

goto bail;

}

if (PyList_Append(chunks, chunk)) {

Py_DECREF(chunk);

goto bail;

}

Py_DECREF(chunk);

}

rval = join_list_unicode(chunks);

if (rval == NULL) {

goto bail;

}

Py_CLEAR(chunks);

*next_end_ptr = end;

return rval;

bail:

*next_end_ptr = -1;

Py_XDECREF(chunks);

return NULL;

}

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;

Py_ssize_t len = PyUnicode_GET_SIZE(pystr);

Py_ssize_t begin = end - 1;

Py_ssize_t next;

const Py_UNICODE *buf = PyUnicode_AS_UNICODE(pystr);

PyObject *chunks = PyList_New(0);

if (chunks == NULL) {

goto bail;

}

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_UNICODE c = 0;

PyObject *chunk = NULL;

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

c = buf[next];

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

break;

}

else if (strict && c <= 0x1f) {

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

goto bail;

}

}

if (!(c == '"' || c == '\\')) {

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

goto bail;

}

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

if (next != end) {

chunk = PyUnicode_FromUnicode(&buf[end], next - end);

if (chunk == NULL) {

goto bail;

}

if (PyList_Append(chunks, chunk)) {

Py_DECREF(chunk);

goto bail;

}

Py_DECREF(chunk);

}

next++;

if (c == '"') {

end = next;

break;

}

if (next == len) {

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

goto bail;

}

c = 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_UNICODE digit = 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;

}

}

#ifdef Py_UNICODE_WIDE

/* Surrogate pair */

if ((c & 0xfc00) == 0xd800) {

Py_UNICODE c2 = 0;

if (end + 6 >= len) {

raise_errmsg("Unpaired high surrogate", pystr, end - 5);

goto bail;

}

if (buf[next++] != '\\' || buf[next++] != 'u') {

raise_errmsg("Unpaired high surrogate", pystr, end - 5);

goto bail;

}

end += 6;

/* Decode 4 hex digits */

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

Py_UNICODE digit = 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 ((c2 & 0xfc00) != 0xdc00) {

raise_errmsg("Unpaired high surrogate", pystr, end - 5);

goto bail;

}

c = 0x10000 + (((c - 0xd800) << 10) | (c2 - 0xdc00));

}

else if ((c & 0xfc00) == 0xdc00) {

raise_errmsg("Unpaired low surrogate", pystr, end - 5);

goto bail;

}

#endif

}

chunk = PyUnicode_FromUnicode(&c, 1);

if (chunk == NULL) {

goto bail;

}

if (PyList_Append(chunks, chunk)) {

Py_DECREF(chunk);

goto bail;

}

Py_DECREF(chunk);

}

rval = join_list_unicode(chunks);

if (rval == NULL) {

goto bail;

}

Py_DECREF(chunks);

*next_end_ptr = end;

return rval;

bail:

*next_end_ptr = -1;

Py_XDECREF(chunks);

return NULL;

}

PyDoc_STRVAR(pydoc_scanstring,

"scanstring(basestring, end, encoding, strict=True) -> (str, end)\n"

"\n"

"Scan the string s for a JSON string. End is the index of the\n"

"character in s after the quote that started the JSON string.\n"

"Unescapes all valid JSON string escape sequences and raises ValueError\n"

"on attempt to decode an invalid string. If strict is False then literal\n"

"control characters are allowed in the string.\n"

"\n"

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

"after the end quote."

);

static PyObject *

py_scanstring(PyObject* self UNUSED, PyObject *args)

{

PyObject *pystr;

PyObject *rval;

Py_ssize_t end;

Py_ssize_t next_end = -1;

char *encoding = NULL;

int strict = 1;

if (!PyArg_ParseTuple(args, "OO&|zi:scanstring", &pystr, _convertPyInt_AsSsize_t, &end, &encoding, &strict)) {

return NULL;

}

if (encoding == NULL) {

encoding = DEFAULT_ENCODING;

}

if (PyString_Check(pystr)) {

rval = scanstring_str(pystr, end, encoding, strict, &next_end);

}

else if (PyUnicode_Check(pystr)) {

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

}

else {

PyErr_Format(PyExc_TypeError,

"first argument must be a string, not %.80s",

Py_TYPE(pystr)->tp_name);

return NULL;

}

return _build_rval_index_tuple(rval, next_end);

}

PyDoc_STRVAR(pydoc_encode_basestring_ascii,

"encode_basestring_ascii(basestring) -> str\n"

"\n"

"Return an ASCII-only JSON representation of a Python string"

);

static PyObject *

py_encode_basestring_ascii(PyObject* self UNUSED, PyObject *pystr)

{

/* Return an ASCII-only JSON representation of a Python string */

/* METH_O */

if (PyString_Check(pystr)) {

return ascii_escape_str(pystr);

}

else if (PyUnicode_Check(pystr)) {

return ascii_escape_unicode(pystr);

}

else {

PyErr_Format(PyExc_TypeError,

"first argument must be a string, not %.80s",

Py_TYPE(pystr)->tp_name);

return NULL;

}

}

static void

scanner_dealloc(PyObject *self)

{

/* Deallocate scanner object */

scanner_clear(self);

Py_TYPE(self)->tp_free(self);

}

static int

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

{

PyScannerObject *s;

assert(PyScanner_Check(self));

s = (PyScannerObject *)self;

Py_VISIT(s->encoding);

Py_VISIT(s->strict);

Py_VISIT(s->object_hook);

Py_VISIT(s->pairs_hook);

Py_VISIT(s->parse_float);

Py_VISIT(s->parse_int);

Py_VISIT(s->parse_constant);

return 0;

}

static int

scanner_clear(PyObject *self)

{

PyScannerObject *s;

assert(PyScanner_Check(self));

s = (PyScannerObject *)self;

Py_CLEAR(s->encoding);

Py_CLEAR(s->strict);

Py_CLEAR(s->object_hook);

Py_CLEAR(s->pairs_hook);

Py_CLEAR(s->parse_float);

Py_CLEAR(s->parse_int);

Py_CLEAR(s->parse_constant);

return 0;

}

static PyObject *

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

/* Read a JSON object from PyString 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)

*/

char *str = PyString_AS_STRING(pystr);

Py_ssize_t end_idx = PyString_GET_SIZE(pystr) - 1;

PyObject *rval;

PyObject *pairs;

PyObject *item;

PyObject *key = NULL;

PyObject *val = NULL;

char *encoding = PyString_AS_STRING(s->encoding);

int strict = PyObject_IsTrue(s->strict);

Py_ssize_t next_idx;

pairs = PyList_New(0);

if (pairs == NULL)

return NULL;

/* skip whitespace after { */

while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;

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

if (idx <= end_idx && str[idx] != '}') {

while (idx <= end_idx) {

/* read key */

if (str[idx] != '"') {

raise_errmsg("Expecting property name", pystr, idx);

goto bail;

}

key = scanstring_str(pystr, idx + 1, encoding, strict, &next_idx);

if (key == NULL)

goto bail;

idx = next_idx;

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

while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;

if (idx > end_idx || str[idx] != ':') {

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

goto bail;

}

idx++;

while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;

/* read any JSON data type */

val = scan_once_str(s, pystr, idx, &next_idx);

if (val == NULL)

goto bail;

item = PyTuple_Pack(2, key, val);

if (item == NULL)

goto bail;

Py_CLEAR(key);

Py_CLEAR(val);

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

Py_DECREF(item);

goto bail;

}

Py_DECREF(item);

idx = next_idx;

/* skip whitespace before } or , */

while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;

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

if (idx > end_idx) break;

if (str[idx] == '}') {

break;

}

else if (str[idx] != ',') {

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

goto bail;

}

idx++;

/* skip whitespace after , delimiter */

while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++;

}

}

/* verify that idx < end_idx, str[idx] should be '}' */

if (idx > end_idx || str[idx] != '}') {

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

goto bail;

}

/* if pairs_hook is not None: rval = object_pairs_hook(pairs) */

if (s->pairs_hook != Py_None) {

val = PyObject_CallFunctionObjArgs(s->pairs_hook, pairs, NULL);

if (val == NULL)

goto bail;

Py_DECREF(pairs);

*next_idx_ptr = idx + 1;

return val;

}

rval = PyObject_CallFunctionObjArgs((PyObject *)(&PyDict_Type),

pairs, NULL);

if (rval == NULL)

goto bail;

Py_CLEAR(pairs);

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

if (s->object_hook != Py_None) {

val = PyObject_CallFunctionObjArgs(s->object_hook, rval, NULL);

if (val == NULL)

goto bail;

Py_DECREF(rval);

rval = val;

val = NULL;

}

*next_idx_ptr = idx + 1;

return rval;

bail:

Py_XDECREF(key);

Py_XDECREF(val);

Py_XDECREF(pairs);