8817bb2e |
1 | #include "Python.h" |
2 | #include "structmember.h" |
3 | #if PY_VERSION_HEX < 0x02060000 && !defined(Py_TYPE) |
4 | #define Py_TYPE(ob) (((PyObject*)(ob))->ob_type) |
5 | #endif |
6 | #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) |
7 | typedef int Py_ssize_t; |
8 | #define PY_SSIZE_T_MAX INT_MAX |
9 | #define PY_SSIZE_T_MIN INT_MIN |
10 | #define PyInt_FromSsize_t PyInt_FromLong |
11 | #define PyInt_AsSsize_t PyInt_AsLong |
12 | #endif |
13 | #ifndef Py_IS_FINITE |
14 | #define Py_IS_FINITE(X) (!Py_IS_INFINITY(X) && !Py_IS_NAN(X)) |
15 | #endif |
16 | |
17 | #ifdef __GNUC__ |
18 | #define UNUSED __attribute__((__unused__)) |
19 | #else |
20 | #define UNUSED |
21 | #endif |
22 | |
23 | #define DEFAULT_ENCODING "utf-8" |
24 | |
25 | #define PyScanner_Check(op) PyObject_TypeCheck(op, &PyScannerType) |
26 | #define PyScanner_CheckExact(op) (Py_TYPE(op) == &PyScannerType) |
27 | #define PyEncoder_Check(op) PyObject_TypeCheck(op, &PyEncoderType) |
28 | #define PyEncoder_CheckExact(op) (Py_TYPE(op) == &PyEncoderType) |
29 | |
30 | static PyTypeObject PyScannerType; |
31 | static PyTypeObject PyEncoderType; |
32 | |
33 | typedef struct _PyScannerObject { |
34 | PyObject_HEAD |
35 | PyObject *encoding; |
36 | PyObject *strict; |
37 | PyObject *object_hook; |
38 | PyObject *parse_float; |
39 | PyObject *parse_int; |
40 | PyObject *parse_constant; |
41 | } PyScannerObject; |
42 | |
43 | static PyMemberDef scanner_members[] = { |
44 | {"encoding", T_OBJECT, offsetof(PyScannerObject, encoding), READONLY, "encoding"}, |
45 | {"strict", T_OBJECT, offsetof(PyScannerObject, strict), READONLY, "strict"}, |
46 | {"object_hook", T_OBJECT, offsetof(PyScannerObject, object_hook), READONLY, "object_hook"}, |
47 | {"parse_float", T_OBJECT, offsetof(PyScannerObject, parse_float), READONLY, "parse_float"}, |
48 | {"parse_int", T_OBJECT, offsetof(PyScannerObject, parse_int), READONLY, "parse_int"}, |
49 | {"parse_constant", T_OBJECT, offsetof(PyScannerObject, parse_constant), READONLY, "parse_constant"}, |
50 | {NULL} |
51 | }; |
52 | |
53 | typedef struct _PyEncoderObject { |
54 | PyObject_HEAD |
55 | PyObject *markers; |
56 | PyObject *defaultfn; |
57 | PyObject *encoder; |
58 | PyObject *indent; |
59 | PyObject *key_separator; |
60 | PyObject *item_separator; |
61 | PyObject *sort_keys; |
62 | PyObject *skipkeys; |
63 | int fast_encode; |
64 | int allow_nan; |
65 | } PyEncoderObject; |
66 | |
67 | static PyMemberDef encoder_members[] = { |
68 | {"markers", T_OBJECT, offsetof(PyEncoderObject, markers), READONLY, "markers"}, |
69 | {"default", T_OBJECT, offsetof(PyEncoderObject, defaultfn), READONLY, "default"}, |
70 | {"encoder", T_OBJECT, offsetof(PyEncoderObject, encoder), READONLY, "encoder"}, |
71 | {"indent", T_OBJECT, offsetof(PyEncoderObject, indent), READONLY, "indent"}, |
72 | {"key_separator", T_OBJECT, offsetof(PyEncoderObject, key_separator), READONLY, "key_separator"}, |
73 | {"item_separator", T_OBJECT, offsetof(PyEncoderObject, item_separator), READONLY, "item_separator"}, |
74 | {"sort_keys", T_OBJECT, offsetof(PyEncoderObject, sort_keys), READONLY, "sort_keys"}, |
75 | {"skipkeys", T_OBJECT, offsetof(PyEncoderObject, skipkeys), READONLY, "skipkeys"}, |
76 | {NULL} |
77 | }; |
78 | |
79 | static Py_ssize_t |
80 | ascii_escape_char(Py_UNICODE c, char *output, Py_ssize_t chars); |
81 | static PyObject * |
82 | ascii_escape_unicode(PyObject *pystr); |
83 | static PyObject * |
84 | ascii_escape_str(PyObject *pystr); |
85 | static PyObject * |
86 | py_encode_basestring_ascii(PyObject* self UNUSED, PyObject *pystr); |
87 | void init_speedups(void); |
88 | static PyObject * |
89 | scan_once_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr); |
90 | static PyObject * |
91 | scan_once_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr); |
92 | static PyObject * |
93 | _build_rval_index_tuple(PyObject *rval, Py_ssize_t idx); |
94 | static PyObject * |
95 | scanner_new(PyTypeObject *type, PyObject *args, PyObject *kwds); |
96 | static int |
97 | scanner_init(PyObject *self, PyObject *args, PyObject *kwds); |
98 | static void |
99 | scanner_dealloc(PyObject *self); |
100 | static int |
101 | scanner_clear(PyObject *self); |
102 | static PyObject * |
103 | encoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds); |
104 | static int |
105 | encoder_init(PyObject *self, PyObject *args, PyObject *kwds); |
106 | static void |
107 | encoder_dealloc(PyObject *self); |
108 | static int |
109 | encoder_clear(PyObject *self); |
110 | static int |
111 | encoder_listencode_list(PyEncoderObject *s, PyObject *rval, PyObject *seq, Py_ssize_t indent_level); |
112 | static int |
113 | encoder_listencode_obj(PyEncoderObject *s, PyObject *rval, PyObject *obj, Py_ssize_t indent_level); |
114 | static int |
115 | encoder_listencode_dict(PyEncoderObject *s, PyObject *rval, PyObject *dct, Py_ssize_t indent_level); |
116 | static PyObject * |
117 | _encoded_const(PyObject *const); |
118 | static void |
119 | raise_errmsg(char *msg, PyObject *s, Py_ssize_t end); |
120 | static PyObject * |
121 | encoder_encode_string(PyEncoderObject *s, PyObject *obj); |
122 | static int |
123 | _convertPyInt_AsSsize_t(PyObject *o, Py_ssize_t *size_ptr); |
124 | static PyObject * |
125 | _convertPyInt_FromSsize_t(Py_ssize_t *size_ptr); |
126 | static PyObject * |
127 | encoder_encode_float(PyEncoderObject *s, PyObject *obj); |
128 | |
129 | #define S_CHAR(c) (c >= ' ' && c <= '~' && c != '\\' && c != '"') |
130 | #define IS_WHITESPACE(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || ((c) == '\r')) |
131 | |
132 | #define MIN_EXPANSION 6 |
133 | #ifdef Py_UNICODE_WIDE |
134 | #define MAX_EXPANSION (2 * MIN_EXPANSION) |
135 | #else |
136 | #define MAX_EXPANSION MIN_EXPANSION |
137 | #endif |
138 | |
139 | static int |
140 | _convertPyInt_AsSsize_t(PyObject *o, Py_ssize_t *size_ptr) |
141 | { |
142 | /* PyObject to Py_ssize_t converter */ |
143 | *size_ptr = PyInt_AsSsize_t(o); |
144 | if (*size_ptr == -1 && PyErr_Occurred()); |
145 | return 1; |
146 | return 0; |
147 | } |
148 | |
149 | static PyObject * |
150 | _convertPyInt_FromSsize_t(Py_ssize_t *size_ptr) |
151 | { |
152 | /* Py_ssize_t to PyObject converter */ |
153 | return PyInt_FromSsize_t(*size_ptr); |
154 | } |
155 | |
156 | static Py_ssize_t |
157 | ascii_escape_char(Py_UNICODE c, char *output, Py_ssize_t chars) |
158 | { |
159 | /* Escape unicode code point c to ASCII escape sequences |
160 | in char *output. output must have at least 12 bytes unused to |
161 | accommodate an escaped surrogate pair "\uXXXX\uXXXX" */ |
162 | output[chars++] = '\\'; |
163 | switch (c) { |
164 | case '\\': output[chars++] = (char)c; break; |
165 | case '"': output[chars++] = (char)c; break; |
166 | case '\b': output[chars++] = 'b'; break; |
167 | case '\f': output[chars++] = 'f'; break; |
168 | case '\n': output[chars++] = 'n'; break; |
169 | case '\r': output[chars++] = 'r'; break; |
170 | case '\t': output[chars++] = 't'; break; |
171 | default: |
172 | #ifdef Py_UNICODE_WIDE |
173 | if (c >= 0x10000) { |
174 | /* UTF-16 surrogate pair */ |
175 | Py_UNICODE v = c - 0x10000; |
176 | c = 0xd800 | ((v >> 10) & 0x3ff); |
177 | output[chars++] = 'u'; |
178 | output[chars++] = "0123456789abcdef"[(c >> 12) & 0xf]; |
179 | output[chars++] = "0123456789abcdef"[(c >> 8) & 0xf]; |
180 | output[chars++] = "0123456789abcdef"[(c >> 4) & 0xf]; |
181 | output[chars++] = "0123456789abcdef"[(c ) & 0xf]; |
182 | c = 0xdc00 | (v & 0x3ff); |
183 | output[chars++] = '\\'; |
184 | } |
185 | #endif |
186 | output[chars++] = 'u'; |
187 | output[chars++] = "0123456789abcdef"[(c >> 12) & 0xf]; |
188 | output[chars++] = "0123456789abcdef"[(c >> 8) & 0xf]; |
189 | output[chars++] = "0123456789abcdef"[(c >> 4) & 0xf]; |
190 | output[chars++] = "0123456789abcdef"[(c ) & 0xf]; |
191 | } |
192 | return chars; |
193 | } |
194 | |
195 | static PyObject * |
196 | ascii_escape_unicode(PyObject *pystr) |
197 | { |
198 | /* Take a PyUnicode pystr and return a new ASCII-only escaped PyString */ |
199 | Py_ssize_t i; |
200 | Py_ssize_t input_chars; |
201 | Py_ssize_t output_size; |
202 | Py_ssize_t max_output_size; |
203 | Py_ssize_t chars; |
204 | PyObject *rval; |
205 | char *output; |
206 | Py_UNICODE *input_unicode; |
207 | |
208 | input_chars = PyUnicode_GET_SIZE(pystr); |
209 | input_unicode = PyUnicode_AS_UNICODE(pystr); |
210 | |
211 | /* One char input can be up to 6 chars output, estimate 4 of these */ |
212 | output_size = 2 + (MIN_EXPANSION * 4) + input_chars; |
213 | max_output_size = 2 + (input_chars * MAX_EXPANSION); |
214 | rval = PyString_FromStringAndSize(NULL, output_size); |
215 | if (rval == NULL) { |
216 | return NULL; |
217 | } |
218 | output = PyString_AS_STRING(rval); |
219 | chars = 0; |
220 | output[chars++] = '"'; |
221 | for (i = 0; i < input_chars; i++) { |
222 | Py_UNICODE c = input_unicode[i]; |
223 | if (S_CHAR(c)) { |
224 | output[chars++] = (char)c; |
225 | } |
226 | else { |
227 | chars = ascii_escape_char(c, output, chars); |
228 | } |
229 | if (output_size - chars < (1 + MAX_EXPANSION)) { |
230 | /* There's more than four, so let's resize by a lot */ |
231 | Py_ssize_t new_output_size = output_size * 2; |
232 | /* This is an upper bound */ |
233 | if (new_output_size > max_output_size) { |
234 | new_output_size = max_output_size; |
235 | } |
236 | /* Make sure that the output size changed before resizing */ |
237 | if (new_output_size != output_size) { |
238 | output_size = new_output_size; |
239 | if (_PyString_Resize(&rval, output_size) == -1) { |
240 | return NULL; |
241 | } |
242 | output = PyString_AS_STRING(rval); |
243 | } |
244 | } |
245 | } |
246 | output[chars++] = '"'; |
247 | if (_PyString_Resize(&rval, chars) == -1) { |
248 | return NULL; |
249 | } |
250 | return rval; |
251 | } |
252 | |
253 | static PyObject * |
254 | ascii_escape_str(PyObject *pystr) |
255 | { |
256 | /* Take a PyString pystr and return a new ASCII-only escaped PyString */ |
257 | Py_ssize_t i; |
258 | Py_ssize_t input_chars; |
259 | Py_ssize_t output_size; |
260 | Py_ssize_t chars; |
261 | PyObject *rval; |
262 | char *output; |
263 | char *input_str; |
264 | |
265 | input_chars = PyString_GET_SIZE(pystr); |
266 | input_str = PyString_AS_STRING(pystr); |
267 | |
268 | /* Fast path for a string that's already ASCII */ |
269 | for (i = 0; i < input_chars; i++) { |
270 | Py_UNICODE c = (Py_UNICODE)(unsigned char)input_str[i]; |
271 | if (!S_CHAR(c)) { |
272 | /* If we have to escape something, scan the string for unicode */ |
273 | Py_ssize_t j; |
274 | for (j = i; j < input_chars; j++) { |
275 | c = (Py_UNICODE)(unsigned char)input_str[j]; |
276 | if (c > 0x7f) { |
277 | /* We hit a non-ASCII character, bail to unicode mode */ |
278 | PyObject *uni; |
279 | uni = PyUnicode_DecodeUTF8(input_str, input_chars, "strict"); |
280 | if (uni == NULL) { |
281 | return NULL; |
282 | } |
283 | rval = ascii_escape_unicode(uni); |
284 | Py_DECREF(uni); |
285 | return rval; |
286 | } |
287 | } |
288 | break; |
289 | } |
290 | } |
291 | |
292 | if (i == input_chars) { |
293 | /* Input is already ASCII */ |
294 | output_size = 2 + input_chars; |
295 | } |
296 | else { |
297 | /* One char input can be up to 6 chars output, estimate 4 of these */ |
298 | output_size = 2 + (MIN_EXPANSION * 4) + input_chars; |
299 | } |
300 | rval = PyString_FromStringAndSize(NULL, output_size); |
301 | if (rval == NULL) { |
302 | return NULL; |
303 | } |
304 | output = PyString_AS_STRING(rval); |
305 | output[0] = '"'; |
306 | |
307 | /* We know that everything up to i is ASCII already */ |
308 | chars = i + 1; |
309 | memcpy(&output[1], input_str, i); |
310 | |
311 | for (; i < input_chars; i++) { |
312 | Py_UNICODE c = (Py_UNICODE)(unsigned char)input_str[i]; |
313 | if (S_CHAR(c)) { |
314 | output[chars++] = (char)c; |
315 | } |
316 | else { |
317 | chars = ascii_escape_char(c, output, chars); |
318 | } |
319 | /* An ASCII char can't possibly expand to a surrogate! */ |
320 | if (output_size - chars < (1 + MIN_EXPANSION)) { |
321 | /* There's more than four, so let's resize by a lot */ |
322 | output_size *= 2; |
323 | if (output_size > 2 + (input_chars * MIN_EXPANSION)) { |
324 | output_size = 2 + (input_chars * MIN_EXPANSION); |
325 | } |
326 | if (_PyString_Resize(&rval, output_size) == -1) { |
327 | return NULL; |
328 | } |
329 | output = PyString_AS_STRING(rval); |
330 | } |
331 | } |
332 | output[chars++] = '"'; |
333 | if (_PyString_Resize(&rval, chars) == -1) { |
334 | return NULL; |
335 | } |
336 | return rval; |
337 | } |
338 | |
339 | static void |
340 | raise_errmsg(char *msg, PyObject *s, Py_ssize_t end) |
341 | { |
342 | /* Use the Python function simplejson.decoder.errmsg to raise a nice |
343 | looking ValueError exception */ |
344 | static PyObject *errmsg_fn = NULL; |
345 | PyObject *pymsg; |
346 | if (errmsg_fn == NULL) { |
347 | PyObject *decoder = PyImport_ImportModule("simplejson.decoder"); |
348 | if (decoder == NULL) |
349 | return; |
350 | errmsg_fn = PyObject_GetAttrString(decoder, "errmsg"); |
351 | Py_DECREF(decoder); |
352 | if (errmsg_fn == NULL) |
353 | return; |
354 | } |
355 | pymsg = PyObject_CallFunction(errmsg_fn, "(zOO&)", msg, s, _convertPyInt_FromSsize_t, &end); |
356 | if (pymsg) { |
357 | PyErr_SetObject(PyExc_ValueError, pymsg); |
358 | Py_DECREF(pymsg); |
359 | } |
360 | } |
361 | |
362 | static PyObject * |
363 | join_list_unicode(PyObject *lst) |
364 | { |
365 | /* return u''.join(lst) */ |
366 | static PyObject *joinfn = NULL; |
367 | if (joinfn == NULL) { |
368 | PyObject *ustr = PyUnicode_FromUnicode(NULL, 0); |
369 | if (ustr == NULL) |
370 | return NULL; |
371 | |
372 | joinfn = PyObject_GetAttrString(ustr, "join"); |
373 | Py_DECREF(ustr); |
374 | if (joinfn == NULL) |
375 | return NULL; |
376 | } |
377 | return PyObject_CallFunctionObjArgs(joinfn, lst, NULL); |
378 | } |
379 | |
380 | static PyObject * |
381 | join_list_string(PyObject *lst) |
382 | { |
383 | /* return ''.join(lst) */ |
384 | static PyObject *joinfn = NULL; |
385 | if (joinfn == NULL) { |
386 | PyObject *ustr = PyString_FromStringAndSize(NULL, 0); |
387 | if (ustr == NULL) |
388 | return NULL; |
389 | |
390 | joinfn = PyObject_GetAttrString(ustr, "join"); |
391 | Py_DECREF(ustr); |
392 | if (joinfn == NULL) |
393 | return NULL; |
394 | } |
395 | return PyObject_CallFunctionObjArgs(joinfn, lst, NULL); |
396 | } |
397 | |
398 | static PyObject * |
399 | _build_rval_index_tuple(PyObject *rval, Py_ssize_t idx) { |
400 | /* return (rval, idx) tuple, stealing reference to rval */ |
401 | PyObject *tpl; |
402 | PyObject *pyidx; |
403 | /* |
404 | steal a reference to rval, returns (rval, idx) |
405 | */ |
406 | if (rval == NULL) { |
407 | return NULL; |
408 | } |
409 | pyidx = PyInt_FromSsize_t(idx); |
410 | if (pyidx == NULL) { |
411 | Py_DECREF(rval); |
412 | return NULL; |
413 | } |
414 | tpl = PyTuple_New(2); |
415 | if (tpl == NULL) { |
416 | Py_DECREF(pyidx); |
417 | Py_DECREF(rval); |
418 | return NULL; |
419 | } |
420 | PyTuple_SET_ITEM(tpl, 0, rval); |
421 | PyTuple_SET_ITEM(tpl, 1, pyidx); |
422 | return tpl; |
423 | } |
424 | |
425 | static PyObject * |
426 | scanstring_str(PyObject *pystr, Py_ssize_t end, char *encoding, int strict, Py_ssize_t *next_end_ptr) |
427 | { |
428 | /* Read the JSON string from PyString pystr. |
429 | end is the index of the first character after the quote. |
430 | encoding is the encoding of pystr (must be an ASCII superset) |
431 | if strict is zero then literal control characters are allowed |
432 | *next_end_ptr is a return-by-reference index of the character |
433 | after the end quote |
434 | |
435 | Return value is a new PyString (if ASCII-only) or PyUnicode |
436 | */ |
437 | PyObject *rval; |
438 | Py_ssize_t len = PyString_GET_SIZE(pystr); |
439 | Py_ssize_t begin = end - 1; |
440 | Py_ssize_t next = begin; |
441 | int has_unicode = 0; |
442 | char *buf = PyString_AS_STRING(pystr); |
443 | PyObject *chunks = PyList_New(0); |
444 | if (chunks == NULL) { |
445 | goto bail; |
446 | } |
447 | if (end < 0 || len <= end) { |
448 | PyErr_SetString(PyExc_ValueError, "end is out of bounds"); |
449 | goto bail; |
450 | } |
451 | while (1) { |
452 | /* Find the end of the string or the next escape */ |
453 | Py_UNICODE c = 0; |
454 | PyObject *chunk = NULL; |
455 | for (next = end; next < len; next++) { |
456 | c = (unsigned char)buf[next]; |
457 | if (c == '"' || c == '\\') { |
458 | break; |
459 | } |
460 | else if (strict && c <= 0x1f) { |
461 | raise_errmsg("Invalid control character at", pystr, next); |
462 | goto bail; |
463 | } |
464 | else if (c > 0x7f) { |
465 | has_unicode = 1; |
466 | } |
467 | } |
468 | if (!(c == '"' || c == '\\')) { |
469 | raise_errmsg("Unterminated string starting at", pystr, begin); |
470 | goto bail; |
471 | } |
472 | /* Pick up this chunk if it's not zero length */ |
473 | if (next != end) { |
474 | PyObject *strchunk = PyString_FromStringAndSize(&buf[end], next - end); |
475 | if (strchunk == NULL) { |
476 | goto bail; |
477 | } |
478 | if (has_unicode) { |
479 | chunk = PyUnicode_FromEncodedObject(strchunk, encoding, NULL); |
480 | Py_DECREF(strchunk); |
481 | if (chunk == NULL) { |
482 | goto bail; |
483 | } |
484 | } |
485 | else { |
486 | chunk = strchunk; |
487 | } |
488 | if (PyList_Append(chunks, chunk)) { |
489 | Py_DECREF(chunk); |
490 | goto bail; |
491 | } |
492 | Py_DECREF(chunk); |
493 | } |
494 | next++; |
495 | if (c == '"') { |
496 | end = next; |
497 | break; |
498 | } |
499 | if (next == len) { |
500 | raise_errmsg("Unterminated string starting at", pystr, begin); |
501 | goto bail; |
502 | } |
503 | c = buf[next]; |
504 | if (c != 'u') { |
505 | /* Non-unicode backslash escapes */ |
506 | end = next + 1; |
507 | switch (c) { |
508 | case '"': break; |
509 | case '\\': break; |
510 | case '/': break; |
511 | case 'b': c = '\b'; break; |
512 | case 'f': c = '\f'; break; |
513 | case 'n': c = '\n'; break; |
514 | case 'r': c = '\r'; break; |
515 | case 't': c = '\t'; break; |
516 | default: c = 0; |
517 | } |
518 | if (c == 0) { |
519 | raise_errmsg("Invalid \\escape", pystr, end - 2); |
520 | goto bail; |
521 | } |
522 | } |
523 | else { |
524 | c = 0; |
525 | next++; |
526 | end = next + 4; |
527 | if (end >= len) { |
528 | raise_errmsg("Invalid \\uXXXX escape", pystr, next - 1); |
529 | goto bail; |
530 | } |
531 | /* Decode 4 hex digits */ |
532 | for (; next < end; next++) { |
533 | Py_UNICODE digit = buf[next]; |
534 | c <<= 4; |
535 | switch (digit) { |
536 | case '0': case '1': case '2': case '3': case '4': |
537 | case '5': case '6': case '7': case '8': case '9': |
538 | c |= (digit - '0'); break; |
539 | case 'a': case 'b': case 'c': case 'd': case 'e': |
540 | case 'f': |
541 | c |= (digit - 'a' + 10); break; |
542 | case 'A': case 'B': case 'C': case 'D': case 'E': |
543 | case 'F': |
544 | c |= (digit - 'A' + 10); break; |
545 | default: |
546 | raise_errmsg("Invalid \\uXXXX escape", pystr, end - 5); |
547 | goto bail; |
548 | } |
549 | } |
550 | #ifdef Py_UNICODE_WIDE |
551 | /* Surrogate pair */ |
552 | if ((c & 0xfc00) == 0xd800) { |
553 | Py_UNICODE c2 = 0; |
554 | if (end + 6 >= len) { |
555 | raise_errmsg("Unpaired high surrogate", pystr, end - 5); |
556 | goto bail; |
557 | } |
558 | if (buf[next++] != '\\' || buf[next++] != 'u') { |
559 | raise_errmsg("Unpaired high surrogate", pystr, end - 5); |
560 | goto bail; |
561 | } |
562 | end += 6; |
563 | /* Decode 4 hex digits */ |
564 | for (; next < end; next++) { |
565 | c2 <<= 4; |
566 | Py_UNICODE digit = buf[next]; |
567 | switch (digit) { |
568 | case '0': case '1': case '2': case '3': case '4': |
569 | case '5': case '6': case '7': case '8': case '9': |
570 | c2 |= (digit - '0'); break; |
571 | case 'a': case 'b': case 'c': case 'd': case 'e': |
572 | case 'f': |
573 | c2 |= (digit - 'a' + 10); break; |
574 | case 'A': case 'B': case 'C': case 'D': case 'E': |
575 | case 'F': |
576 | c2 |= (digit - 'A' + 10); break; |
577 | default: |
578 | raise_errmsg("Invalid \\uXXXX escape", pystr, end - 5); |
579 | goto bail; |
580 | } |
581 | } |
582 | if ((c2 & 0xfc00) != 0xdc00) { |
583 | raise_errmsg("Unpaired high surrogate", pystr, end - 5); |
584 | goto bail; |
585 | } |
586 | c = 0x10000 + (((c - 0xd800) << 10) | (c2 - 0xdc00)); |
587 | } |
588 | else if ((c & 0xfc00) == 0xdc00) { |
589 | raise_errmsg("Unpaired low surrogate", pystr, end - 5); |
590 | goto bail; |
591 | } |
592 | #endif |
593 | } |
594 | if (c > 0x7f) { |
595 | has_unicode = 1; |
596 | } |
597 | if (has_unicode) { |
598 | chunk = PyUnicode_FromUnicode(&c, 1); |
599 | if (chunk == NULL) { |
600 | goto bail; |
601 | } |
602 | } |
603 | else { |
604 | char c_char = Py_CHARMASK(c); |
605 | chunk = PyString_FromStringAndSize(&c_char, 1); |
606 | if (chunk == NULL) { |
607 | goto bail; |
608 | } |
609 | } |
610 | if (PyList_Append(chunks, chunk)) { |
611 | Py_DECREF(chunk); |
612 | goto bail; |
613 | } |
614 | Py_DECREF(chunk); |
615 | } |
616 | |
617 | rval = join_list_string(chunks); |
618 | if (rval == NULL) { |
619 | goto bail; |
620 | } |
621 | Py_CLEAR(chunks); |
622 | *next_end_ptr = end; |
623 | return rval; |
624 | bail: |
625 | *next_end_ptr = -1; |
626 | Py_XDECREF(chunks); |
627 | return NULL; |
628 | } |
629 | |
630 | |
631 | static PyObject * |
632 | scanstring_unicode(PyObject *pystr, Py_ssize_t end, int strict, Py_ssize_t *next_end_ptr) |
633 | { |
634 | /* Read the JSON string from PyUnicode pystr. |
635 | end is the index of the first character after the quote. |
636 | if strict is zero then literal control characters are allowed |
637 | *next_end_ptr is a return-by-reference index of the character |
638 | after the end quote |
639 | |
640 | Return value is a new PyUnicode |
641 | */ |
642 | PyObject *rval; |
643 | Py_ssize_t len = PyUnicode_GET_SIZE(pystr); |
644 | Py_ssize_t begin = end - 1; |
645 | Py_ssize_t next = begin; |
646 | const Py_UNICODE *buf = PyUnicode_AS_UNICODE(pystr); |
647 | PyObject *chunks = PyList_New(0); |
648 | if (chunks == NULL) { |
649 | goto bail; |
650 | } |
651 | if (end < 0 || len <= end) { |
652 | PyErr_SetString(PyExc_ValueError, "end is out of bounds"); |
653 | goto bail; |
654 | } |
655 | while (1) { |
656 | /* Find the end of the string or the next escape */ |
657 | Py_UNICODE c = 0; |
658 | PyObject *chunk = NULL; |
659 | for (next = end; next < len; next++) { |
660 | c = buf[next]; |
661 | if (c == '"' || c == '\\') { |
662 | break; |
663 | } |
664 | else if (strict && c <= 0x1f) { |
665 | raise_errmsg("Invalid control character at", pystr, next); |
666 | goto bail; |
667 | } |
668 | } |
669 | if (!(c == '"' || c == '\\')) { |
670 | raise_errmsg("Unterminated string starting at", pystr, begin); |
671 | goto bail; |
672 | } |
673 | /* Pick up this chunk if it's not zero length */ |
674 | if (next != end) { |
675 | chunk = PyUnicode_FromUnicode(&buf[end], next - end); |
676 | if (chunk == NULL) { |
677 | goto bail; |
678 | } |
679 | if (PyList_Append(chunks, chunk)) { |
680 | Py_DECREF(chunk); |
681 | goto bail; |
682 | } |
683 | Py_DECREF(chunk); |
684 | } |
685 | next++; |
686 | if (c == '"') { |
687 | end = next; |
688 | break; |
689 | } |
690 | if (next == len) { |
691 | raise_errmsg("Unterminated string starting at", pystr, begin); |
692 | goto bail; |
693 | } |
694 | c = buf[next]; |
695 | if (c != 'u') { |
696 | /* Non-unicode backslash escapes */ |
697 | end = next + 1; |
698 | switch (c) { |
699 | case '"': break; |
700 | case '\\': break; |
701 | case '/': break; |
702 | case 'b': c = '\b'; break; |
703 | case 'f': c = '\f'; break; |
704 | case 'n': c = '\n'; break; |
705 | case 'r': c = '\r'; break; |
706 | case 't': c = '\t'; break; |
707 | default: c = 0; |
708 | } |
709 | if (c == 0) { |
710 | raise_errmsg("Invalid \\escape", pystr, end - 2); |
711 | goto bail; |
712 | } |
713 | } |
714 | else { |
715 | c = 0; |
716 | next++; |
717 | end = next + 4; |
718 | if (end >= len) { |
719 | raise_errmsg("Invalid \\uXXXX escape", pystr, next - 1); |
720 | goto bail; |
721 | } |
722 | /* Decode 4 hex digits */ |
723 | for (; next < end; next++) { |
724 | Py_UNICODE digit = buf[next]; |
725 | c <<= 4; |
726 | switch (digit) { |
727 | case '0': case '1': case '2': case '3': case '4': |
728 | case '5': case '6': case '7': case '8': case '9': |
729 | c |= (digit - '0'); break; |
730 | case 'a': case 'b': case 'c': case 'd': case 'e': |
731 | case 'f': |
732 | c |= (digit - 'a' + 10); break; |
733 | case 'A': case 'B': case 'C': case 'D': case 'E': |
734 | case 'F': |
735 | c |= (digit - 'A' + 10); break; |
736 | default: |
737 | raise_errmsg("Invalid \\uXXXX escape", pystr, end - 5); |
738 | goto bail; |
739 | } |
740 | } |
741 | #ifdef Py_UNICODE_WIDE |
742 | /* Surrogate pair */ |
743 | if ((c & 0xfc00) == 0xd800) { |
744 | Py_UNICODE c2 = 0; |
745 | if (end + 6 >= len) { |
746 | raise_errmsg("Unpaired high surrogate", pystr, end - 5); |
747 | goto bail; |
748 | } |
749 | if (buf[next++] != '\\' || buf[next++] != 'u') { |
750 | raise_errmsg("Unpaired high surrogate", pystr, end - 5); |
751 | goto bail; |
752 | } |
753 | end += 6; |
754 | /* Decode 4 hex digits */ |
755 | for (; next < end; next++) { |
756 | c2 <<= 4; |
757 | Py_UNICODE digit = buf[next]; |
758 | switch (digit) { |
759 | case '0': case '1': case '2': case '3': case '4': |
760 | case '5': case '6': case '7': case '8': case '9': |
761 | c2 |= (digit - '0'); break; |
762 | case 'a': case 'b': case 'c': case 'd': case 'e': |
763 | case 'f': |
764 | c2 |= (digit - 'a' + 10); break; |
765 | case 'A': case 'B': case 'C': case 'D': case 'E': |
766 | case 'F': |
767 | c2 |= (digit - 'A' + 10); break; |
768 | default: |
769 | raise_errmsg("Invalid \\uXXXX escape", pystr, end - 5); |
770 | goto bail; |
771 | } |
772 | } |
773 | if ((c2 & 0xfc00) != 0xdc00) { |
774 | raise_errmsg("Unpaired high surrogate", pystr, end - 5); |
775 | goto bail; |
776 | } |
777 | c = 0x10000 + (((c - 0xd800) << 10) | (c2 - 0xdc00)); |
778 | } |
779 | else if ((c & 0xfc00) == 0xdc00) { |
780 | raise_errmsg("Unpaired low surrogate", pystr, end - 5); |
781 | goto bail; |
782 | } |
783 | #endif |
784 | } |
785 | chunk = PyUnicode_FromUnicode(&c, 1); |
786 | if (chunk == NULL) { |
787 | goto bail; |
788 | } |
789 | if (PyList_Append(chunks, chunk)) { |
790 | Py_DECREF(chunk); |
791 | goto bail; |
792 | } |
793 | Py_DECREF(chunk); |
794 | } |
795 | |
796 | rval = join_list_unicode(chunks); |
797 | if (rval == NULL) { |
798 | goto bail; |
799 | } |
800 | Py_DECREF(chunks); |
801 | *next_end_ptr = end; |
802 | return rval; |
803 | bail: |
804 | *next_end_ptr = -1; |
805 | Py_XDECREF(chunks); |
806 | return NULL; |
807 | } |
808 | |
809 | PyDoc_STRVAR(pydoc_scanstring, |
810 | "scanstring(basestring, end, encoding, strict=True) -> (str, end)\n" |
811 | "\n" |
812 | "Scan the string s for a JSON string. End is the index of the\n" |
813 | "character in s after the quote that started the JSON string.\n" |
814 | "Unescapes all valid JSON string escape sequences and raises ValueError\n" |
815 | "on attempt to decode an invalid string. If strict is False then literal\n" |
816 | "control characters are allowed in the string.\n" |
817 | "\n" |
818 | "Returns a tuple of the decoded string and the index of the character in s\n" |
819 | "after the end quote." |
820 | ); |
821 | |
822 | static PyObject * |
823 | py_scanstring(PyObject* self UNUSED, PyObject *args) |
824 | { |
825 | PyObject *pystr; |
826 | PyObject *rval; |
827 | Py_ssize_t end; |
828 | Py_ssize_t next_end = -1; |
829 | char *encoding = NULL; |
830 | int strict = 1; |
831 | if (!PyArg_ParseTuple(args, "OO&|zi:scanstring", &pystr, _convertPyInt_AsSsize_t, &end, &encoding, &strict)) { |
832 | return NULL; |
833 | } |
834 | if (encoding == NULL) { |
835 | encoding = DEFAULT_ENCODING; |
836 | } |
837 | if (PyString_Check(pystr)) { |
838 | rval = scanstring_str(pystr, end, encoding, strict, &next_end); |
839 | } |
840 | else if (PyUnicode_Check(pystr)) { |
841 | rval = scanstring_unicode(pystr, end, strict, &next_end); |
842 | } |
843 | else { |
844 | PyErr_Format(PyExc_TypeError, |
845 | "first argument must be a string, not %.80s", |
846 | Py_TYPE(pystr)->tp_name); |
847 | return NULL; |
848 | } |
849 | return _build_rval_index_tuple(rval, next_end); |
850 | } |
851 | |
852 | PyDoc_STRVAR(pydoc_encode_basestring_ascii, |
853 | "encode_basestring_ascii(basestring) -> str\n" |
854 | "\n" |
855 | "Return an ASCII-only JSON representation of a Python string" |
856 | ); |
857 | |
858 | static PyObject * |
859 | py_encode_basestring_ascii(PyObject* self UNUSED, PyObject *pystr) |
860 | { |
861 | /* Return an ASCII-only JSON representation of a Python string */ |
862 | /* METH_O */ |
863 | if (PyString_Check(pystr)) { |
864 | return ascii_escape_str(pystr); |
865 | } |
866 | else if (PyUnicode_Check(pystr)) { |
867 | return ascii_escape_unicode(pystr); |
868 | } |
869 | else { |
870 | PyErr_Format(PyExc_TypeError, |
871 | "first argument must be a string, not %.80s", |
872 | Py_TYPE(pystr)->tp_name); |
873 | return NULL; |
874 | } |
875 | } |
876 | |
877 | static void |
878 | scanner_dealloc(PyObject *self) |
879 | { |
880 | /* Deallocate scanner object */ |
881 | scanner_clear(self); |
882 | Py_TYPE(self)->tp_free(self); |
883 | } |
884 | |
885 | static int |
886 | scanner_traverse(PyObject *self, visitproc visit, void *arg) |
887 | { |
888 | PyScannerObject *s; |
889 | assert(PyScanner_Check(self)); |
890 | s = (PyScannerObject *)self; |
891 | Py_VISIT(s->encoding); |
892 | Py_VISIT(s->strict); |
893 | Py_VISIT(s->object_hook); |
894 | Py_VISIT(s->parse_float); |
895 | Py_VISIT(s->parse_int); |
896 | Py_VISIT(s->parse_constant); |
897 | return 0; |
898 | } |
899 | |
900 | static int |
901 | scanner_clear(PyObject *self) |
902 | { |
903 | PyScannerObject *s; |
904 | assert(PyScanner_Check(self)); |
905 | s = (PyScannerObject *)self; |
906 | Py_CLEAR(s->encoding); |
907 | Py_CLEAR(s->strict); |
908 | Py_CLEAR(s->object_hook); |
909 | Py_CLEAR(s->parse_float); |
910 | Py_CLEAR(s->parse_int); |
911 | Py_CLEAR(s->parse_constant); |
912 | return 0; |
913 | } |
914 | |
915 | static PyObject * |
916 | _parse_object_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr) { |
917 | /* Read a JSON object from PyString pystr. |
918 | idx is the index of the first character after the opening curly brace. |
919 | *next_idx_ptr is a return-by-reference index to the first character after |
920 | the closing curly brace. |
921 | |
922 | Returns a new PyObject (usually a dict, but object_hook can change that) |
923 | */ |
924 | char *str = PyString_AS_STRING(pystr); |
925 | Py_ssize_t end_idx = PyString_GET_SIZE(pystr) - 1; |
926 | PyObject *rval = PyDict_New(); |
927 | PyObject *key = NULL; |
928 | PyObject *val = NULL; |
929 | char *encoding = PyString_AS_STRING(s->encoding); |
930 | int strict = PyObject_IsTrue(s->strict); |
931 | Py_ssize_t next_idx; |
932 | if (rval == NULL) |
933 | return NULL; |
934 | |
935 | /* skip whitespace after { */ |
936 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
937 | |
938 | /* only loop if the object is non-empty */ |
939 | if (idx <= end_idx && str[idx] != '}') { |
940 | while (idx <= end_idx) { |
941 | /* read key */ |
942 | if (str[idx] != '"') { |
943 | raise_errmsg("Expecting property name", pystr, idx); |
944 | goto bail; |
945 | } |
946 | key = scanstring_str(pystr, idx + 1, encoding, strict, &next_idx); |
947 | if (key == NULL) |
948 | goto bail; |
949 | idx = next_idx; |
950 | |
951 | /* skip whitespace between key and : delimiter, read :, skip whitespace */ |
952 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
953 | if (idx > end_idx || str[idx] != ':') { |
954 | raise_errmsg("Expecting : delimiter", pystr, idx); |
955 | goto bail; |
956 | } |
957 | idx++; |
958 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
959 | |
960 | /* read any JSON data type */ |
961 | val = scan_once_str(s, pystr, idx, &next_idx); |
962 | if (val == NULL) |
963 | goto bail; |
964 | |
965 | if (PyDict_SetItem(rval, key, val) == -1) |
966 | goto bail; |
967 | |
968 | Py_CLEAR(key); |
969 | Py_CLEAR(val); |
970 | idx = next_idx; |
971 | |
972 | /* skip whitespace before } or , */ |
973 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
974 | |
975 | /* bail if the object is closed or we didn't get the , delimiter */ |
976 | if (idx > end_idx) break; |
977 | if (str[idx] == '}') { |
978 | break; |
979 | } |
980 | else if (str[idx] != ',') { |
981 | raise_errmsg("Expecting , delimiter", pystr, idx); |
982 | goto bail; |
983 | } |
984 | idx++; |
985 | |
986 | /* skip whitespace after , delimiter */ |
987 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
988 | } |
989 | } |
990 | /* verify that idx < end_idx, str[idx] should be '}' */ |
991 | if (idx > end_idx || str[idx] != '}') { |
992 | raise_errmsg("Expecting object", pystr, end_idx); |
993 | goto bail; |
994 | } |
995 | /* if object_hook is not None: rval = object_hook(rval) */ |
996 | if (s->object_hook != Py_None) { |
997 | val = PyObject_CallFunctionObjArgs(s->object_hook, rval, NULL); |
998 | if (val == NULL) |
999 | goto bail; |
1000 | Py_DECREF(rval); |
1001 | rval = val; |
1002 | val = NULL; |
1003 | } |
1004 | *next_idx_ptr = idx + 1; |
1005 | return rval; |
1006 | bail: |
1007 | Py_XDECREF(key); |
1008 | Py_XDECREF(val); |
1009 | Py_DECREF(rval); |
1010 | return NULL; |
1011 | } |
1012 | |
1013 | static PyObject * |
1014 | _parse_object_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr) { |
1015 | /* Read a JSON object from PyUnicode pystr. |
1016 | idx is the index of the first character after the opening curly brace. |
1017 | *next_idx_ptr is a return-by-reference index to the first character after |
1018 | the closing curly brace. |
1019 | |
1020 | Returns a new PyObject (usually a dict, but object_hook can change that) |
1021 | */ |
1022 | Py_UNICODE *str = PyUnicode_AS_UNICODE(pystr); |
1023 | Py_ssize_t end_idx = PyUnicode_GET_SIZE(pystr) - 1; |
1024 | PyObject *val = NULL; |
1025 | PyObject *rval = PyDict_New(); |
1026 | PyObject *key = NULL; |
1027 | int strict = PyObject_IsTrue(s->strict); |
1028 | Py_ssize_t next_idx; |
1029 | if (rval == NULL) |
1030 | return NULL; |
1031 | |
1032 | /* skip whitespace after { */ |
1033 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
1034 | |
1035 | /* only loop if the object is non-empty */ |
1036 | if (idx <= end_idx && str[idx] != '}') { |
1037 | while (idx <= end_idx) { |
1038 | /* read key */ |
1039 | if (str[idx] != '"') { |
1040 | raise_errmsg("Expecting property name", pystr, idx); |
1041 | goto bail; |
1042 | } |
1043 | key = scanstring_unicode(pystr, idx + 1, strict, &next_idx); |
1044 | if (key == NULL) |
1045 | goto bail; |
1046 | idx = next_idx; |
1047 | |
1048 | /* skip whitespace between key and : delimiter, read :, skip whitespace */ |
1049 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
1050 | if (idx > end_idx || str[idx] != ':') { |
1051 | raise_errmsg("Expecting : delimiter", pystr, idx); |
1052 | goto bail; |
1053 | } |
1054 | idx++; |
1055 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
1056 | |
1057 | /* read any JSON term */ |
1058 | val = scan_once_unicode(s, pystr, idx, &next_idx); |
1059 | if (val == NULL) |
1060 | goto bail; |
1061 | |
1062 | if (PyDict_SetItem(rval, key, val) == -1) |
1063 | goto bail; |
1064 | |
1065 | Py_CLEAR(key); |
1066 | Py_CLEAR(val); |
1067 | idx = next_idx; |
1068 | |
1069 | /* skip whitespace before } or , */ |
1070 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
1071 | |
1072 | /* bail if the object is closed or we didn't get the , delimiter */ |
1073 | if (idx > end_idx) break; |
1074 | if (str[idx] == '}') { |
1075 | break; |
1076 | } |
1077 | else if (str[idx] != ',') { |
1078 | raise_errmsg("Expecting , delimiter", pystr, idx); |
1079 | goto bail; |
1080 | } |
1081 | idx++; |
1082 | |
1083 | /* skip whitespace after , delimiter */ |
1084 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
1085 | } |
1086 | } |
1087 | |
1088 | /* verify that idx < end_idx, str[idx] should be '}' */ |
1089 | if (idx > end_idx || str[idx] != '}') { |
1090 | raise_errmsg("Expecting object", pystr, end_idx); |
1091 | goto bail; |
1092 | } |
1093 | |
1094 | /* if object_hook is not None: rval = object_hook(rval) */ |
1095 | if (s->object_hook != Py_None) { |
1096 | val = PyObject_CallFunctionObjArgs(s->object_hook, rval, NULL); |
1097 | if (val == NULL) |
1098 | goto bail; |
1099 | Py_DECREF(rval); |
1100 | rval = val; |
1101 | val = NULL; |
1102 | } |
1103 | *next_idx_ptr = idx + 1; |
1104 | return rval; |
1105 | bail: |
1106 | Py_XDECREF(key); |
1107 | Py_XDECREF(val); |
1108 | Py_DECREF(rval); |
1109 | return NULL; |
1110 | } |
1111 | |
1112 | static PyObject * |
1113 | _parse_array_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr) { |
1114 | /* Read a JSON array from PyString pystr. |
1115 | idx is the index of the first character after the opening brace. |
1116 | *next_idx_ptr is a return-by-reference index to the first character after |
1117 | the closing brace. |
1118 | |
1119 | Returns a new PyList |
1120 | */ |
1121 | char *str = PyString_AS_STRING(pystr); |
1122 | Py_ssize_t end_idx = PyString_GET_SIZE(pystr) - 1; |
1123 | PyObject *val = NULL; |
1124 | PyObject *rval = PyList_New(0); |
1125 | Py_ssize_t next_idx; |
1126 | if (rval == NULL) |
1127 | return NULL; |
1128 | |
1129 | /* skip whitespace after [ */ |
1130 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
1131 | |
1132 | /* only loop if the array is non-empty */ |
1133 | if (idx <= end_idx && str[idx] != ']') { |
1134 | while (idx <= end_idx) { |
1135 | |
1136 | /* read any JSON term and de-tuplefy the (rval, idx) */ |
1137 | val = scan_once_str(s, pystr, idx, &next_idx); |
1138 | if (val == NULL) |
1139 | goto bail; |
1140 | |
1141 | if (PyList_Append(rval, val) == -1) |
1142 | goto bail; |
1143 | |
1144 | Py_CLEAR(val); |
1145 | idx = next_idx; |
1146 | |
1147 | /* skip whitespace between term and , */ |
1148 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
1149 | |
1150 | /* bail if the array is closed or we didn't get the , delimiter */ |
1151 | if (idx > end_idx) break; |
1152 | if (str[idx] == ']') { |
1153 | break; |
1154 | } |
1155 | else if (str[idx] != ',') { |
1156 | raise_errmsg("Expecting , delimiter", pystr, idx); |
1157 | goto bail; |
1158 | } |
1159 | idx++; |
1160 | |
1161 | /* skip whitespace after , */ |
1162 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
1163 | } |
1164 | } |
1165 | |
1166 | /* verify that idx < end_idx, str[idx] should be ']' */ |
1167 | if (idx > end_idx || str[idx] != ']') { |
1168 | raise_errmsg("Expecting object", pystr, end_idx); |
1169 | goto bail; |
1170 | } |
1171 | *next_idx_ptr = idx + 1; |
1172 | return rval; |
1173 | bail: |
1174 | Py_XDECREF(val); |
1175 | Py_DECREF(rval); |
1176 | return NULL; |
1177 | } |
1178 | |
1179 | static PyObject * |
1180 | _parse_array_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr) { |
1181 | /* Read a JSON array from PyString pystr. |
1182 | idx is the index of the first character after the opening brace. |
1183 | *next_idx_ptr is a return-by-reference index to the first character after |
1184 | the closing brace. |
1185 | |
1186 | Returns a new PyList |
1187 | */ |
1188 | Py_UNICODE *str = PyUnicode_AS_UNICODE(pystr); |
1189 | Py_ssize_t end_idx = PyUnicode_GET_SIZE(pystr) - 1; |
1190 | PyObject *val = NULL; |
1191 | PyObject *rval = PyList_New(0); |
1192 | Py_ssize_t next_idx; |
1193 | if (rval == NULL) |
1194 | return NULL; |
1195 | |
1196 | /* skip whitespace after [ */ |
1197 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
1198 | |
1199 | /* only loop if the array is non-empty */ |
1200 | if (idx <= end_idx && str[idx] != ']') { |
1201 | while (idx <= end_idx) { |
1202 | |
1203 | /* read any JSON term */ |
1204 | val = scan_once_unicode(s, pystr, idx, &next_idx); |
1205 | if (val == NULL) |
1206 | goto bail; |
1207 | |
1208 | if (PyList_Append(rval, val) == -1) |
1209 | goto bail; |
1210 | |
1211 | Py_CLEAR(val); |
1212 | idx = next_idx; |
1213 | |
1214 | /* skip whitespace between term and , */ |
1215 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
1216 | |
1217 | /* bail if the array is closed or we didn't get the , delimiter */ |
1218 | if (idx > end_idx) break; |
1219 | if (str[idx] == ']') { |
1220 | break; |
1221 | } |
1222 | else if (str[idx] != ',') { |
1223 | raise_errmsg("Expecting , delimiter", pystr, idx); |
1224 | goto bail; |
1225 | } |
1226 | idx++; |
1227 | |
1228 | /* skip whitespace after , */ |
1229 | while (idx <= end_idx && IS_WHITESPACE(str[idx])) idx++; |
1230 | } |
1231 | } |
1232 | |
1233 | /* verify that idx < end_idx, str[idx] should be ']' */ |
1234 | if (idx > end_idx || str[idx] != ']') { |
1235 | raise_errmsg("Expecting object", pystr, end_idx); |
1236 | goto bail; |
1237 | } |
1238 | *next_idx_ptr = idx + 1; |
1239 | return rval; |
1240 | bail: |
1241 | Py_XDECREF(val); |
1242 | Py_DECREF(rval); |
1243 | return NULL; |
1244 | } |
1245 | |
1246 | static PyObject * |
1247 | _parse_constant(PyScannerObject *s, char *constant, Py_ssize_t idx, Py_ssize_t *next_idx_ptr) { |
1248 | /* Read a JSON constant from PyString pystr. |
1249 | constant is the constant string that was found |
1250 | ("NaN", "Infinity", "-Infinity"). |
1251 | idx is the index of the first character of the constant |
1252 | *next_idx_ptr is a return-by-reference index to the first character after |
1253 | the constant. |
1254 | |
1255 | Returns the result of parse_constant |
1256 | */ |
1257 | PyObject *cstr; |
1258 | PyObject *rval; |
1259 | /* constant is "NaN", "Infinity", or "-Infinity" */ |
1260 | cstr = PyString_InternFromString(constant); |
1261 | if (cstr == NULL) |
1262 | return NULL; |
1263 | |
1264 | /* rval = parse_constant(constant) */ |
1265 | rval = PyObject_CallFunctionObjArgs(s->parse_constant, cstr, NULL); |
1266 | idx += PyString_GET_SIZE(cstr); |
1267 | Py_DECREF(cstr); |
1268 | *next_idx_ptr = idx; |
1269 | return rval; |
1270 | } |
1271 | |
1272 | static PyObject * |
1273 | _match_number_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t start, Py_ssize_t *next_idx_ptr) { |
1274 | /* Read a JSON number from PyString pystr. |
1275 | idx is the index of the first character of the number |
1276 | *next_idx_ptr is a return-by-reference index to the first character after |
1277 | the number. |
1278 | |
1279 | Returns a new PyObject representation of that number: |
1280 | PyInt, PyLong, or PyFloat. |
1281 | May return other types if parse_int or parse_float are set |
1282 | */ |
1283 | char *str = PyString_AS_STRING(pystr); |
1284 | Py_ssize_t end_idx = PyString_GET_SIZE(pystr) - 1; |
1285 | Py_ssize_t idx = start; |
1286 | int is_float = 0; |
1287 | PyObject *rval; |
1288 | PyObject *numstr; |
1289 | |
1290 | /* read a sign if it's there, make sure it's not the end of the string */ |
1291 | if (str[idx] == '-') { |
1292 | idx++; |
1293 | if (idx > end_idx) { |
1294 | PyErr_SetNone(PyExc_StopIteration); |
1295 | return NULL; |
1296 | } |
1297 | } |
1298 | |
1299 | /* read as many integer digits as we find as long as it doesn't start with 0 */ |
1300 | if (str[idx] >= '1' && str[idx] <= '9') { |
1301 | idx++; |
1302 | while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++; |
1303 | } |
1304 | /* if it starts with 0 we only expect one integer digit */ |
1305 | else if (str[idx] == '0') { |
1306 | idx++; |
1307 | } |
1308 | /* no integer digits, error */ |
1309 | else { |
1310 | PyErr_SetNone(PyExc_StopIteration); |
1311 | return NULL; |
1312 | } |
1313 | |
1314 | /* if the next char is '.' followed by a digit then read all float digits */ |
1315 | if (idx < end_idx && str[idx] == '.' && str[idx + 1] >= '0' && str[idx + 1] <= '9') { |
1316 | is_float = 1; |
1317 | idx += 2; |
1318 | while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++; |
1319 | } |
1320 | |
1321 | /* if the next char is 'e' or 'E' then maybe read the exponent (or backtrack) */ |
1322 | if (idx < end_idx && (str[idx] == 'e' || str[idx] == 'E')) { |
1323 | |
1324 | /* save the index of the 'e' or 'E' just in case we need to backtrack */ |
1325 | Py_ssize_t e_start = idx; |
1326 | idx++; |
1327 | |
1328 | /* read an exponent sign if present */ |
1329 | if (idx < end_idx && (str[idx] == '-' || str[idx] == '+')) idx++; |
1330 | |
1331 | /* read all digits */ |
1332 | while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++; |
1333 | |
1334 | /* if we got a digit, then parse as float. if not, backtrack */ |
1335 | if (str[idx - 1] >= '0' && str[idx - 1] <= '9') { |
1336 | is_float = 1; |
1337 | } |
1338 | else { |
1339 | idx = e_start; |
1340 | } |
1341 | } |
1342 | |
1343 | /* copy the section we determined to be a number */ |
1344 | numstr = PyString_FromStringAndSize(&str[start], idx - start); |
1345 | if (numstr == NULL) |
1346 | return NULL; |
1347 | if (is_float) { |
1348 | /* parse as a float using a fast path if available, otherwise call user defined method */ |
1349 | if (s->parse_float != (PyObject *)&PyFloat_Type) { |
1350 | rval = PyObject_CallFunctionObjArgs(s->parse_float, numstr, NULL); |
1351 | } |
1352 | else { |
1353 | rval = PyFloat_FromDouble(PyOS_ascii_atof(PyString_AS_STRING(numstr))); |
1354 | } |
1355 | } |
1356 | else { |
1357 | /* parse as an int using a fast path if available, otherwise call user defined method */ |
1358 | if (s->parse_int != (PyObject *)&PyInt_Type) { |
1359 | rval = PyObject_CallFunctionObjArgs(s->parse_int, numstr, NULL); |
1360 | } |
1361 | else { |
1362 | rval = PyInt_FromString(PyString_AS_STRING(numstr), NULL, 10); |
1363 | } |
1364 | } |
1365 | Py_DECREF(numstr); |
1366 | *next_idx_ptr = idx; |
1367 | return rval; |
1368 | } |
1369 | |
1370 | static PyObject * |
1371 | _match_number_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t start, Py_ssize_t *next_idx_ptr) { |
1372 | /* Read a JSON number from PyUnicode pystr. |
1373 | idx is the index of the first character of the number |
1374 | *next_idx_ptr is a return-by-reference index to the first character after |
1375 | the number. |
1376 | |
1377 | Returns a new PyObject representation of that number: |
1378 | PyInt, PyLong, or PyFloat. |
1379 | May return other types if parse_int or parse_float are set |
1380 | */ |
1381 | Py_UNICODE *str = PyUnicode_AS_UNICODE(pystr); |
1382 | Py_ssize_t end_idx = PyUnicode_GET_SIZE(pystr) - 1; |
1383 | Py_ssize_t idx = start; |
1384 | int is_float = 0; |
1385 | PyObject *rval; |
1386 | PyObject *numstr; |
1387 | |
1388 | /* read a sign if it's there, make sure it's not the end of the string */ |
1389 | if (str[idx] == '-') { |
1390 | idx++; |
1391 | if (idx > end_idx) { |
1392 | PyErr_SetNone(PyExc_StopIteration); |
1393 | return NULL; |
1394 | } |
1395 | } |
1396 | |
1397 | /* read as many integer digits as we find as long as it doesn't start with 0 */ |
1398 | if (str[idx] >= '1' && str[idx] <= '9') { |
1399 | idx++; |
1400 | while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++; |
1401 | } |
1402 | /* if it starts with 0 we only expect one integer digit */ |
1403 | else if (str[idx] == '0') { |
1404 | idx++; |
1405 | } |
1406 | /* no integer digits, error */ |
1407 | else { |
1408 | PyErr_SetNone(PyExc_StopIteration); |
1409 | return NULL; |
1410 | } |
1411 | |
1412 | /* if the next char is '.' followed by a digit then read all float digits */ |
1413 | if (idx < end_idx && str[idx] == '.' && str[idx + 1] >= '0' && str[idx + 1] <= '9') { |
1414 | is_float = 1; |
1415 | idx += 2; |
1416 | while (idx < end_idx && str[idx] >= '0' && str[idx] <= '9') idx++; |
1417 | } |
1418 | |
1419 | /* if the next char is 'e' or 'E' then maybe read the exponent (or backtrack) */ |
1420 | if (idx < end_idx && (str[idx] == 'e' || str[idx] == 'E')) { |
1421 | Py_ssize_t e_start = idx; |
1422 | idx++; |
1423 | |
1424 | /* read an exponent sign if present */ |
1425 | if (idx < end_idx && (str[idx] == '-' || str[idx] == '+')) idx++; |
1426 | |
1427 | /* read all digits */ |
1428 | while (idx <= end_idx && str[idx] >= '0' && str[idx] <= '9') idx++; |
1429 | |
1430 | /* if we got a digit, then parse as float. if not, backtrack */ |
1431 | if (str[idx - 1] >= '0' && str[idx - 1] <= '9') { |
1432 | is_float = 1; |
1433 | } |
1434 | else { |
1435 | idx = e_start; |
1436 | } |
1437 | } |
1438 | |
1439 | /* copy the section we determined to be a number */ |
1440 | numstr = PyUnicode_FromUnicode(&str[start], idx - start); |
1441 | if (numstr == NULL) |
1442 | return NULL; |
1443 | if (is_float) { |
1444 | /* parse as a float using a fast path if available, otherwise call user defined method */ |
1445 | if (s->parse_float != (PyObject *)&PyFloat_Type) { |
1446 | rval = PyObject_CallFunctionObjArgs(s->parse_float, numstr, NULL); |
1447 | } |
1448 | else { |
1449 | rval = PyFloat_FromString(numstr, NULL); |
1450 | } |
1451 | } |
1452 | else { |
1453 | /* no fast path for unicode -> int, just call */ |
1454 | rval = PyObject_CallFunctionObjArgs(s->parse_int, numstr, NULL); |
1455 | } |
1456 | Py_DECREF(numstr); |
1457 | *next_idx_ptr = idx; |
1458 | return rval; |
1459 | } |
1460 | |
1461 | static PyObject * |
1462 | scan_once_str(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr) |
1463 | { |
1464 | /* Read one JSON term (of any kind) from PyString pystr. |
1465 | idx is the index of the first character of the term |
1466 | *next_idx_ptr is a return-by-reference index to the first character after |
1467 | the number. |
1468 | |
1469 | Returns a new PyObject representation of the term. |
1470 | */ |
1471 | char *str = PyString_AS_STRING(pystr); |
1472 | Py_ssize_t length = PyString_GET_SIZE(pystr); |
1473 | if (idx >= length) { |
1474 | PyErr_SetNone(PyExc_StopIteration); |
1475 | return NULL; |
1476 | } |
1477 | switch (str[idx]) { |
1478 | case '"': |
1479 | /* string */ |
1480 | return scanstring_str(pystr, idx + 1, |
1481 | PyString_AS_STRING(s->encoding), |
1482 | PyObject_IsTrue(s->strict), |
1483 | next_idx_ptr); |
1484 | case '{': |
1485 | /* object */ |
1486 | return _parse_object_str(s, pystr, idx + 1, next_idx_ptr); |
1487 | case '[': |
1488 | /* array */ |
1489 | return _parse_array_str(s, pystr, idx + 1, next_idx_ptr); |
1490 | case 'n': |
1491 | /* null */ |
1492 | if ((idx + 3 < length) && str[idx + 1] == 'u' && str[idx + 2] == 'l' && str[idx + 3] == 'l') { |
1493 | Py_INCREF(Py_None); |
1494 | *next_idx_ptr = idx + 4; |
1495 | return Py_None; |
1496 | } |
1497 | break; |
1498 | case 't': |
1499 | /* true */ |
1500 | if ((idx + 3 < length) && str[idx + 1] == 'r' && str[idx + 2] == 'u' && str[idx + 3] == 'e') { |
1501 | Py_INCREF(Py_True); |
1502 | *next_idx_ptr = idx + 4; |
1503 | return Py_True; |
1504 | } |
1505 | break; |
1506 | case 'f': |
1507 | /* false */ |
1508 | if ((idx + 4 < length) && str[idx + 1] == 'a' && str[idx + 2] == 'l' && str[idx + 3] == 's' && str[idx + 4] == 'e') { |
1509 | Py_INCREF(Py_False); |
1510 | *next_idx_ptr = idx + 5; |
1511 | return Py_False; |
1512 | } |
1513 | break; |
1514 | case 'N': |
1515 | /* NaN */ |
1516 | if ((idx + 2 < length) && str[idx + 1] == 'a' && str[idx + 2] == 'N') { |
1517 | return _parse_constant(s, "NaN", idx, next_idx_ptr); |
1518 | } |
1519 | break; |
1520 | case 'I': |
1521 | /* Infinity */ |
1522 | if ((idx + 7 < length) && str[idx + 1] == 'n' && str[idx + 2] == 'f' && str[idx + 3] == 'i' && str[idx + 4] == 'n' && str[idx + 5] == 'i' && str[idx + 6] == 't' && str[idx + 7] == 'y') { |
1523 | return _parse_constant(s, "Infinity", idx, next_idx_ptr); |
1524 | } |
1525 | break; |
1526 | case '-': |
1527 | /* -Infinity */ |
1528 | if ((idx + 8 < length) && str[idx + 1] == 'I' && str[idx + 2] == 'n' && str[idx + 3] == 'f' && str[idx + 4] == 'i' && str[idx + 5] == 'n' && str[idx + 6] == 'i' && str[idx + 7] == 't' && str[idx + 8] == 'y') { |
1529 | return _parse_constant(s, "-Infinity", idx, next_idx_ptr); |
1530 | } |
1531 | break; |
1532 | } |
1533 | /* Didn't find a string, object, array, or named constant. Look for a number. */ |
1534 | return _match_number_str(s, pystr, idx, next_idx_ptr); |
1535 | } |
1536 | |
1537 | static PyObject * |
1538 | scan_once_unicode(PyScannerObject *s, PyObject *pystr, Py_ssize_t idx, Py_ssize_t *next_idx_ptr) |
1539 | { |
1540 | /* Read one JSON term (of any kind) from PyUnicode pystr. |
1541 | idx is the index of the first character of the term |
1542 | *next_idx_ptr is a return-by-reference index to the first character after |
1543 | the number. |
1544 | |
1545 | Returns a new PyObject representation of the term. |
1546 | */ |
1547 | Py_UNICODE *str = PyUnicode_AS_UNICODE(pystr); |
1548 | Py_ssize_t length = PyUnicode_GET_SIZE(pystr); |
1549 | if (idx >= length) { |
1550 | PyErr_SetNone(PyExc_StopIteration); |
1551 | return NULL; |
1552 | } |
1553 | switch (str[idx]) { |
1554 | case '"': |
1555 | /* string */ |
1556 | return scanstring_unicode(pystr, idx + 1, |
1557 | PyObject_IsTrue(s->strict), |
1558 | next_idx_ptr); |
1559 | case '{': |
1560 | /* object */ |
1561 | return _parse_object_unicode(s, pystr, idx + 1, next_idx_ptr); |
1562 | case '[': |
1563 | /* array */ |
1564 | return _parse_array_unicode(s, pystr, idx + 1, next_idx_ptr); |
1565 | case 'n': |
1566 | /* null */ |
1567 | if ((idx + 3 < length) && str[idx + 1] == 'u' && str[idx + 2] == 'l' && str[idx + 3] == 'l') { |
1568 | Py_INCREF(Py_None); |
1569 | *next_idx_ptr = idx + 4; |
1570 | return Py_None; |
1571 | } |
1572 | break; |
1573 | case 't': |
1574 | /* true */ |
1575 | if ((idx + 3 < length) && str[idx + 1] == 'r' && str[idx + 2] == 'u' && str[idx + 3] == 'e') { |
1576 | Py_INCREF(Py_True); |
1577 | *next_idx_ptr = idx + 4; |
1578 | return Py_True; |
1579 | } |
1580 | break; |
1581 | case 'f': |
1582 | /* false */ |
1583 | if ((idx + 4 < length) && str[idx + 1] == 'a' && str[idx + 2] == 'l' && str[idx + 3] == 's' && str[idx + 4] == 'e') { |
1584 | Py_INCREF(Py_False); |
1585 | *next_idx_ptr = idx + 5; |
1586 | return Py_False; |
1587 | } |
1588 | break; |
1589 | case 'N': |
1590 | /* NaN */ |
1591 | if ((idx + 2 < length) && str[idx + 1] == 'a' && str[idx + 2] == 'N') { |
1592 | return _parse_constant(s, "NaN", idx, next_idx_ptr); |
1593 | } |
1594 | break; |
1595 | case 'I': |
1596 | /* Infinity */ |
1597 | if ((idx + 7 < length) && str[idx + 1] == 'n' && str[idx + 2] == 'f' && str[idx + 3] == 'i' && str[idx + 4] == 'n' && str[idx + 5] == 'i' && str[idx + 6] == 't' && str[idx + 7] == 'y') { |
1598 | return _parse_constant(s, "Infinity", idx, next_idx_ptr); |
1599 | } |
1600 | break; |
1601 | case '-': |
1602 | /* -Infinity */ |
1603 | if ((idx + 8 < length) && str[idx + 1] == 'I' && str[idx + 2] == 'n' && str[idx + 3] == 'f' && str[idx + 4] == 'i' && str[idx + 5] == 'n' && str[idx + 6] == 'i' && str[idx + 7] == 't' && str[idx + 8] == 'y') { |
1604 | return _parse_constant(s, "-Infinity", idx, next_idx_ptr); |
1605 | } |
1606 | break; |
1607 | } |
1608 | /* Didn't find a string, object, array, or named constant. Look for a number. */ |
1609 | return _match_number_unicode(s, pystr, idx, next_idx_ptr); |
1610 | } |
1611 | |
1612 | static PyObject * |
1613 | scanner_call(PyObject *self, PyObject *args, PyObject *kwds) |
1614 | { |
1615 | /* Python callable interface to scan_once_{str,unicode} */ |
1616 | PyObject *pystr; |
1617 | PyObject *rval; |
1618 | Py_ssize_t idx; |
1619 | Py_ssize_t next_idx = -1; |
1620 | static char *kwlist[] = {"string", "idx", NULL}; |
1621 | PyScannerObject *s; |
1622 | assert(PyScanner_Check(self)); |
1623 | s = (PyScannerObject *)self; |
1624 | if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&:scan_once", kwlist, &pystr, _convertPyInt_AsSsize_t, &idx)) |
1625 | return NULL; |
1626 | |
1627 | if (PyString_Check(pystr)) { |
1628 | rval = scan_once_str(s, pystr, idx, &next_idx); |
1629 | } |
1630 | else if (PyUnicode_Check(pystr)) { |
1631 | rval = scan_once_unicode(s, pystr, idx, &next_idx); |
1632 | } |
1633 | else { |
1634 | PyErr_Format(PyExc_TypeError, |
1635 | "first argument must be a string, not %.80s", |
1636 | Py_TYPE(pystr)->tp_name); |
1637 | return NULL; |
1638 | } |
1639 | return _build_rval_index_tuple(rval, next_idx); |
1640 | } |
1641 | |
1642 | static PyObject * |
1643 | scanner_new(PyTypeObject *type, PyObject *args, PyObject *kwds) |
1644 | { |
1645 | PyScannerObject *s; |
1646 | s = (PyScannerObject *)type->tp_alloc(type, 0); |
1647 | if (s != NULL) { |
1648 | s->encoding = NULL; |
1649 | s->strict = NULL; |
1650 | s->object_hook = NULL; |
1651 | s->parse_float = NULL; |
1652 | s->parse_int = NULL; |
1653 | s->parse_constant = NULL; |
1654 | } |
1655 | return (PyObject *)s; |
1656 | } |
1657 | |
1658 | static int |
1659 | scanner_init(PyObject *self, PyObject *args, PyObject *kwds) |
1660 | { |
1661 | /* Initialize Scanner object */ |
1662 | PyObject *ctx; |
1663 | static char *kwlist[] = {"context", NULL}; |
1664 | PyScannerObject *s; |
1665 | |
1666 | assert(PyScanner_Check(self)); |
1667 | s = (PyScannerObject *)self; |
1668 | |
1669 | if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:make_scanner", kwlist, &ctx)) |
1670 | return -1; |
1671 | |
1672 | /* PyString_AS_STRING is used on encoding */ |
1673 | s->encoding = PyObject_GetAttrString(ctx, "encoding"); |
1674 | if (s->encoding == Py_None) { |
1675 | Py_DECREF(Py_None); |
1676 | s->encoding = PyString_InternFromString(DEFAULT_ENCODING); |
1677 | } |
1678 | else if (PyUnicode_Check(s->encoding)) { |
1679 | PyObject *tmp = PyUnicode_AsEncodedString(s->encoding, NULL, NULL); |
1680 | Py_DECREF(s->encoding); |
1681 | s->encoding = tmp; |
1682 | } |
1683 | if (s->encoding == NULL || !PyString_Check(s->encoding)) |
1684 | goto bail; |
1685 | |
1686 | /* All of these will fail "gracefully" so we don't need to verify them */ |
1687 | s->strict = PyObject_GetAttrString(ctx, "strict"); |
1688 | if (s->strict == NULL) |
1689 | goto bail; |
1690 | s->object_hook = PyObject_GetAttrString(ctx, "object_hook"); |
1691 | if (s->object_hook == NULL) |
1692 | goto bail; |
1693 | s->parse_float = PyObject_GetAttrString(ctx, "parse_float"); |
1694 | if (s->parse_float == NULL) |
1695 | goto bail; |
1696 | s->parse_int = PyObject_GetAttrString(ctx, "parse_int"); |
1697 | if (s->parse_int == NULL) |
1698 | goto bail; |
1699 | s->parse_constant = PyObject_GetAttrString(ctx, "parse_constant"); |
1700 | if (s->parse_constant == NULL) |
1701 | goto bail; |
1702 | |
1703 | return 0; |
1704 | |
1705 | bail: |
1706 | Py_CLEAR(s->encoding); |
1707 | Py_CLEAR(s->strict); |
1708 | Py_CLEAR(s->object_hook); |
1709 | Py_CLEAR(s->parse_float); |
1710 | Py_CLEAR(s->parse_int); |
1711 | Py_CLEAR(s->parse_constant); |
1712 | return -1; |
1713 | } |
1714 | |
1715 | PyDoc_STRVAR(scanner_doc, "JSON scanner object"); |
1716 | |
1717 | static |
1718 | PyTypeObject PyScannerType = { |
1719 | PyObject_HEAD_INIT(NULL) |
1720 | 0, /* tp_internal */ |
1721 | "simplejson._speedups.Scanner", /* tp_name */ |
1722 | sizeof(PyScannerObject), /* tp_basicsize */ |
1723 | 0, /* tp_itemsize */ |
1724 | scanner_dealloc, /* tp_dealloc */ |
1725 | 0, /* tp_print */ |
1726 | 0, /* tp_getattr */ |
1727 | 0, /* tp_setattr */ |
1728 | 0, /* tp_compare */ |
1729 | 0, /* tp_repr */ |
1730 | 0, /* tp_as_number */ |
1731 | 0, /* tp_as_sequence */ |
1732 | 0, /* tp_as_mapping */ |
1733 | 0, /* tp_hash */ |
1734 | scanner_call, /* tp_call */ |
1735 | 0, /* tp_str */ |
1736 | 0,/* PyObject_GenericGetAttr, */ /* tp_getattro */ |
1737 | 0,/* PyObject_GenericSetAttr, */ /* tp_setattro */ |
1738 | 0, /* tp_as_buffer */ |
1739 | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */ |
1740 | scanner_doc, /* tp_doc */ |
1741 | scanner_traverse, /* tp_traverse */ |
1742 | scanner_clear, /* tp_clear */ |
1743 | 0, /* tp_richcompare */ |
1744 | 0, /* tp_weaklistoffset */ |
1745 | 0, /* tp_iter */ |
1746 | 0, /* tp_iternext */ |
1747 | 0, /* tp_methods */ |
1748 | scanner_members, /* tp_members */ |
1749 | 0, /* tp_getset */ |
1750 | 0, /* tp_base */ |
1751 | 0, /* tp_dict */ |
1752 | 0, /* tp_descr_get */ |
1753 | 0, /* tp_descr_set */ |
1754 | 0, /* tp_dictoffset */ |
1755 | scanner_init, /* tp_init */ |
1756 | 0,/* PyType_GenericAlloc, */ /* tp_alloc */ |
1757 | scanner_new, /* tp_new */ |
1758 | 0,/* PyObject_GC_Del, */ /* tp_free */ |
1759 | }; |
1760 | |
1761 | static PyObject * |
1762 | encoder_new(PyTypeObject *type, PyObject *args, PyObject *kwds) |
1763 | { |
1764 | PyEncoderObject *s; |
1765 | s = (PyEncoderObject *)type->tp_alloc(type, 0); |
1766 | if (s != NULL) { |
1767 | s->markers = NULL; |
1768 | s->defaultfn = NULL; |
1769 | s->encoder = NULL; |
1770 | s->indent = NULL; |
1771 | s->key_separator = NULL; |
1772 | s->item_separator = NULL; |
1773 | s->sort_keys = NULL; |
1774 | s->skipkeys = NULL; |
1775 | } |
1776 | return (PyObject *)s; |
1777 | } |
1778 | |
1779 | static int |
1780 | encoder_init(PyObject *self, PyObject *args, PyObject *kwds) |
1781 | { |
1782 | /* initialize Encoder object */ |
1783 | static char *kwlist[] = {"markers", "default", "encoder", "indent", "key_separator", "item_separator", "sort_keys", "skipkeys", "allow_nan", NULL}; |
1784 | |
1785 | PyEncoderObject *s; |
1786 | PyObject *allow_nan; |
1787 | |
1788 | assert(PyEncoder_Check(self)); |
1789 | s = (PyEncoderObject *)self; |
1790 | |
1791 | if (!PyArg_ParseTupleAndKeywords(args, kwds, "OOOOOOOOO:make_encoder", kwlist, |
1792 | &s->markers, &s->defaultfn, &s->encoder, &s->indent, &s->key_separator, &s->item_separator, &s->sort_keys, &s->skipkeys, &allow_nan)) |
1793 | return -1; |
1794 | |
1795 | Py_INCREF(s->markers); |
1796 | Py_INCREF(s->defaultfn); |
1797 | Py_INCREF(s->encoder); |
1798 | Py_INCREF(s->indent); |
1799 | Py_INCREF(s->key_separator); |
1800 | Py_INCREF(s->item_separator); |
1801 | Py_INCREF(s->sort_keys); |
1802 | Py_INCREF(s->skipkeys); |
1803 | s->fast_encode = (PyCFunction_Check(s->encoder) && PyCFunction_GetFunction(s->encoder) == (PyCFunction)py_encode_basestring_ascii); |
1804 | s->allow_nan = PyObject_IsTrue(allow_nan); |
1805 | return 0; |
1806 | } |
1807 | |
1808 | static PyObject * |
1809 | encoder_call(PyObject *self, PyObject *args, PyObject *kwds) |
1810 | { |
1811 | /* Python callable interface to encode_listencode_obj */ |
1812 | static char *kwlist[] = {"obj", "_current_indent_level", NULL}; |
1813 | PyObject *obj; |
1814 | PyObject *rval; |
1815 | Py_ssize_t indent_level; |
1816 | PyEncoderObject *s; |
1817 | assert(PyEncoder_Check(self)); |
1818 | s = (PyEncoderObject *)self; |
1819 | if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO&:_iterencode", kwlist, |
1820 | &obj, _convertPyInt_AsSsize_t, &indent_level)) |
1821 | return NULL; |
1822 | rval = PyList_New(0); |
1823 | if (rval == NULL) |
1824 | return NULL; |
1825 | if (encoder_listencode_obj(s, rval, obj, indent_level)) { |
1826 | Py_DECREF(rval); |
1827 | return NULL; |
1828 | } |
1829 | return rval; |
1830 | } |
1831 | |
1832 | static PyObject * |
1833 | _encoded_const(PyObject *obj) |
1834 | { |
1835 | /* Return the JSON string representation of None, True, False */ |
1836 | if (obj == Py_None) { |
1837 | static PyObject *s_null = NULL; |
1838 | if (s_null == NULL) { |
1839 | s_null = PyString_InternFromString("null"); |
1840 | } |
1841 | Py_INCREF(s_null); |
1842 | return s_null; |
1843 | } |
1844 | else if (obj == Py_True) { |
1845 | static PyObject *s_true = NULL; |
1846 | if (s_true == NULL) { |
1847 | s_true = PyString_InternFromString("true"); |
1848 | } |
1849 | Py_INCREF(s_true); |
1850 | return s_true; |
1851 | } |
1852 | else if (obj == Py_False) { |
1853 | static PyObject *s_false = NULL; |
1854 | if (s_false == NULL) { |
1855 | s_false = PyString_InternFromString("false"); |
1856 | } |
1857 | Py_INCREF(s_false); |
1858 | return s_false; |
1859 | } |
1860 | else { |
1861 | PyErr_SetString(PyExc_ValueError, "not a const"); |
1862 | return NULL; |
1863 | } |
1864 | } |
1865 | |
1866 | static PyObject * |
1867 | encoder_encode_float(PyEncoderObject *s, PyObject *obj) |
1868 | { |
1869 | /* Return the JSON representation of a PyFloat */ |
1870 | double i = PyFloat_AS_DOUBLE(obj); |
1871 | if (!Py_IS_FINITE(i)) { |
1872 | if (!s->allow_nan) { |
1873 | PyErr_SetString(PyExc_ValueError, "Out of range float values are not JSON compliant"); |
1874 | return NULL; |
1875 | } |
1876 | if (i > 0) { |
1877 | return PyString_FromString("Infinity"); |
1878 | } |
1879 | else if (i < 0) { |
1880 | return PyString_FromString("-Infinity"); |
1881 | } |
1882 | else { |
1883 | return PyString_FromString("NaN"); |
1884 | } |
1885 | } |
1886 | /* Use a better float format here? */ |
1887 | return PyObject_Repr(obj); |
1888 | } |
1889 | |
1890 | static PyObject * |
1891 | encoder_encode_string(PyEncoderObject *s, PyObject *obj) |
1892 | { |
1893 | /* Return the JSON representation of a string */ |
1894 | if (s->fast_encode) |
1895 | return py_encode_basestring_ascii(NULL, obj); |
1896 | else |
1897 | return PyObject_CallFunctionObjArgs(s->encoder, obj, NULL); |
1898 | } |
1899 | |
1900 | static int |
1901 | _steal_list_append(PyObject *lst, PyObject *stolen) |
1902 | { |
1903 | /* Append stolen and then decrement its reference count */ |
1904 | int rval = PyList_Append(lst, stolen); |
1905 | Py_DECREF(stolen); |
1906 | return rval; |
1907 | } |
1908 | |
1909 | static int |
1910 | encoder_listencode_obj(PyEncoderObject *s, PyObject *rval, PyObject *obj, Py_ssize_t indent_level) |
1911 | { |
1912 | /* Encode Python object obj to a JSON term, rval is a PyList */ |
1913 | PyObject *newobj; |
1914 | int rv; |
1915 | |
1916 | if (obj == Py_None || obj == Py_True || obj == Py_False) { |
1917 | PyObject *cstr = _encoded_const(obj); |
1918 | if (cstr == NULL) |
1919 | return -1; |
1920 | return _steal_list_append(rval, cstr); |
1921 | } |
1922 | else if (PyString_Check(obj) || PyUnicode_Check(obj)) |
1923 | { |
1924 | PyObject *encoded = encoder_encode_string(s, obj); |
1925 | if (encoded == NULL) |
1926 | return -1; |
1927 | return _steal_list_append(rval, encoded); |
1928 | } |
1929 | else if (PyInt_Check(obj) || PyLong_Check(obj)) { |
1930 | PyObject *encoded = PyObject_Str(obj); |
1931 | if (encoded == NULL) |
1932 | return -1; |
1933 | return _steal_list_append(rval, encoded); |
1934 | } |
1935 | else if (PyFloat_Check(obj)) { |
1936 | PyObject *encoded = encoder_encode_float(s, obj); |
1937 | if (encoded == NULL) |
1938 | return -1; |
1939 | return _steal_list_append(rval, encoded); |
1940 | } |
1941 | else if (PyList_Check(obj) || PyTuple_Check(obj)) { |
1942 | return encoder_listencode_list(s, rval, obj, indent_level); |
1943 | } |
1944 | else if (PyDict_Check(obj)) { |
1945 | return encoder_listencode_dict(s, rval, obj, indent_level); |
1946 | } |
1947 | else { |
1948 | PyObject *ident = NULL; |
1949 | if (s->markers != Py_None) { |
1950 | int has_key; |
1951 | ident = PyLong_FromVoidPtr(obj); |
1952 | if (ident == NULL) |
1953 | return -1; |
1954 | has_key = PyDict_Contains(s->markers, ident); |
1955 | if (has_key) { |
1956 | if (has_key != -1) |
1957 | PyErr_SetString(PyExc_ValueError, "Circular reference detected"); |
1958 | Py_DECREF(ident); |
1959 | return -1; |
1960 | } |
1961 | if (PyDict_SetItem(s->markers, ident, obj)) { |
1962 | Py_DECREF(ident); |
1963 | return -1; |
1964 | } |
1965 | } |
1966 | newobj = PyObject_CallFunctionObjArgs(s->defaultfn, obj, NULL); |
1967 | if (newobj == NULL) { |
1968 | Py_XDECREF(ident); |
1969 | return -1; |
1970 | } |
1971 | rv = encoder_listencode_obj(s, rval, newobj, indent_level); |
1972 | Py_DECREF(newobj); |
1973 | if (rv) { |
1974 | Py_XDECREF(ident); |
1975 | return -1; |
1976 | } |
1977 | if (ident != NULL) { |
1978 | if (PyDict_DelItem(s->markers, ident)) { |
1979 | Py_XDECREF(ident); |
1980 | return -1; |
1981 | } |
1982 | Py_XDECREF(ident); |
1983 | } |
1984 | return rv; |
1985 | } |
1986 | } |
1987 | |
1988 | static int |
1989 | encoder_listencode_dict(PyEncoderObject *s, PyObject *rval, PyObject *dct, Py_ssize_t indent_level) |
1990 | { |
1991 | /* Encode Python dict dct a JSON term, rval is a PyList */ |
1992 | static PyObject *open_dict = NULL; |
1993 | static PyObject *close_dict = NULL; |
1994 | static PyObject *empty_dict = NULL; |
1995 | PyObject *kstr = NULL; |
1996 | PyObject *ident = NULL; |
1997 | PyObject *key, *value; |
1998 | Py_ssize_t pos; |
1999 | int skipkeys; |
2000 | Py_ssize_t idx; |
2001 | |
2002 | if (open_dict == NULL || close_dict == NULL || empty_dict == NULL) { |
2003 | open_dict = PyString_InternFromString("{"); |
2004 | close_dict = PyString_InternFromString("}"); |
2005 | empty_dict = PyString_InternFromString("{}"); |
2006 | if (open_dict == NULL || close_dict == NULL || empty_dict == NULL) |
2007 | return -1; |
2008 | } |
2009 | if (PyDict_Size(dct) == 0) |
2010 | return PyList_Append(rval, empty_dict); |
2011 | |
2012 | if (s->markers != Py_None) { |
2013 | int has_key; |
2014 | ident = PyLong_FromVoidPtr(dct); |
2015 | if (ident == NULL) |
2016 | goto bail; |
2017 | has_key = PyDict_Contains(s->markers, ident); |
2018 | if (has_key) { |
2019 | if (has_key != -1) |
2020 | PyErr_SetString(PyExc_ValueError, "Circular reference detected"); |
2021 | goto bail; |
2022 | } |
2023 | if (PyDict_SetItem(s->markers, ident, dct)) { |
2024 | goto bail; |
2025 | } |
2026 | } |
2027 | |
2028 | if (PyList_Append(rval, open_dict)) |
2029 | goto bail; |
2030 | |
2031 | if (s->indent != Py_None) { |
2032 | /* TODO: DOES NOT RUN */ |
2033 | indent_level += 1; |
2034 | /* |
2035 | newline_indent = '\n' + (' ' * (_indent * _current_indent_level)) |
2036 | separator = _item_separator + newline_indent |
2037 | buf += newline_indent |
2038 | */ |
2039 | } |
2040 | |
2041 | /* TODO: C speedup not implemented for sort_keys */ |
2042 | |
2043 | pos = 0; |
2044 | skipkeys = PyObject_IsTrue(s->skipkeys); |
2045 | idx = 0; |
2046 | while (PyDict_Next(dct, &pos, &key, &value)) { |
2047 | PyObject *encoded; |
2048 | |
2049 | if (PyString_Check(key) || PyUnicode_Check(key)) { |
2050 | Py_INCREF(key); |
2051 | kstr = key; |
2052 | } |
2053 | else if (PyFloat_Check(key)) { |
2054 | kstr = encoder_encode_float(s, key); |
2055 | if (kstr == NULL) |
2056 | goto bail; |
2057 | } |
2058 | else if (PyInt_Check(key) || PyLong_Check(key)) { |
2059 | kstr = PyObject_Str(key); |
2060 | if (kstr == NULL) |
2061 | goto bail; |
2062 | } |
2063 | else if (key == Py_True || key == Py_False || key == Py_None) { |
2064 | kstr = _encoded_const(key); |
2065 | if (kstr == NULL) |
2066 | goto bail; |
2067 | } |
2068 | else if (skipkeys) { |
2069 | continue; |
2070 | } |
2071 | else { |
2072 | /* TODO: include repr of key */ |
2073 | PyErr_SetString(PyExc_ValueError, "keys must be a string"); |
2074 | goto bail; |
2075 | } |
2076 | |
2077 | if (idx) { |
2078 | if (PyList_Append(rval, s->item_separator)) |
2079 | goto bail; |
2080 | } |
2081 | |
2082 | encoded = encoder_encode_string(s, kstr); |
2083 | Py_CLEAR(kstr); |
2084 | if (encoded == NULL) |
2085 | goto bail; |
2086 | if (PyList_Append(rval, encoded)) { |
2087 | Py_DECREF(encoded); |
2088 | goto bail; |
2089 | } |
2090 | Py_DECREF(encoded); |
2091 | if (PyList_Append(rval, s->key_separator)) |
2092 | goto bail; |
2093 | if (encoder_listencode_obj(s, rval, value, indent_level)) |
2094 | goto bail; |
2095 | idx += 1; |
2096 | } |
2097 | if (ident != NULL) { |
2098 | if (PyDict_DelItem(s->markers, ident)) |
2099 | goto bail; |
2100 | Py_CLEAR(ident); |
2101 | } |
2102 | if (s->indent != Py_None) { |
2103 | /* TODO: DOES NOT RUN */ |
2104 | indent_level -= 1; |
2105 | /* |
2106 | yield '\n' + (' ' * (_indent * _current_indent_level)) |
2107 | */ |
2108 | } |
2109 | if (PyList_Append(rval, close_dict)) |
2110 | goto bail; |
2111 | return 0; |
2112 | |
2113 | bail: |
2114 | Py_XDECREF(kstr); |
2115 | Py_XDECREF(ident); |
2116 | return -1; |
2117 | } |
2118 | |
2119 | |
2120 | static int |
2121 | encoder_listencode_list(PyEncoderObject *s, PyObject *rval, PyObject *seq, Py_ssize_t indent_level) |
2122 | { |
2123 | /* Encode Python list seq to a JSON term, rval is a PyList */ |
2124 | static PyObject *open_array = NULL; |
2125 | static PyObject *close_array = NULL; |
2126 | static PyObject *empty_array = NULL; |
2127 | PyObject *ident = NULL; |
2128 | PyObject *s_fast = NULL; |
2129 | Py_ssize_t num_items; |
2130 | PyObject **seq_items; |
2131 | Py_ssize_t i; |
2132 | |
2133 | if (open_array == NULL || close_array == NULL || empty_array == NULL) { |
2134 | open_array = PyString_InternFromString("["); |
2135 | close_array = PyString_InternFromString("]"); |
2136 | empty_array = PyString_InternFromString("[]"); |
2137 | if (open_array == NULL || close_array == NULL || empty_array == NULL) |
2138 | return -1; |
2139 | } |
2140 | ident = NULL; |
2141 | s_fast = PySequence_Fast(seq, "_iterencode_list needs a sequence"); |
2142 | if (s_fast == NULL) |
2143 | return -1; |
2144 | num_items = PySequence_Fast_GET_SIZE(s_fast); |
2145 | if (num_items == 0) { |
2146 | Py_DECREF(s_fast); |
2147 | return PyList_Append(rval, empty_array); |
2148 | } |
2149 | |
2150 | if (s->markers != Py_None) { |
2151 | int has_key; |
2152 | ident = PyLong_FromVoidPtr(seq); |
2153 | if (ident == NULL) |
2154 | goto bail; |
2155 | has_key = PyDict_Contains(s->markers, ident); |
2156 | if (has_key) { |
2157 | if (has_key != -1) |
2158 | PyErr_SetString(PyExc_ValueError, "Circular reference detected"); |
2159 | goto bail; |
2160 | } |
2161 | if (PyDict_SetItem(s->markers, ident, seq)) { |
2162 | goto bail; |
2163 | } |
2164 | } |
2165 | |
2166 | seq_items = PySequence_Fast_ITEMS(s_fast); |
2167 | if (PyList_Append(rval, open_array)) |
2168 | goto bail; |
2169 | if (s->indent != Py_None) { |
2170 | /* TODO: DOES NOT RUN */ |
2171 | indent_level += 1; |
2172 | /* |
2173 | newline_indent = '\n' + (' ' * (_indent * _current_indent_level)) |
2174 | separator = _item_separator + newline_indent |
2175 | buf += newline_indent |
2176 | */ |
2177 | } |
2178 | for (i = 0; i < num_items; i++) { |
2179 | PyObject *obj = seq_items[i]; |
2180 | if (i) { |
2181 | if (PyList_Append(rval, s->item_separator)) |
2182 | goto bail; |
2183 | } |
2184 | if (encoder_listencode_obj(s, rval, obj, indent_level)) |
2185 | goto bail; |
2186 | } |
2187 | if (ident != NULL) { |
2188 | if (PyDict_DelItem(s->markers, ident)) |
2189 | goto bail; |
2190 | Py_CLEAR(ident); |
2191 | } |
2192 | if (s->indent != Py_None) { |
2193 | /* TODO: DOES NOT RUN */ |
2194 | indent_level -= 1; |
2195 | /* |
2196 | yield '\n' + (' ' * (_indent * _current_indent_level)) |
2197 | */ |
2198 | } |
2199 | if (PyList_Append(rval, close_array)) |
2200 | goto bail; |
2201 | Py_DECREF(s_fast); |
2202 | return 0; |
2203 | |
2204 | bail: |
2205 | Py_XDECREF(ident); |
2206 | Py_DECREF(s_fast); |
2207 | return -1; |
2208 | } |
2209 | |
2210 | static void |
2211 | encoder_dealloc(PyObject *self) |
2212 | { |
2213 | /* Deallocate Encoder */ |
2214 | encoder_clear(self); |
2215 | Py_TYPE(self)->tp_free(self); |
2216 | } |
2217 | |
2218 | static int |
2219 | encoder_traverse(PyObject *self, visitproc visit, void *arg) |
2220 | { |
2221 | PyEncoderObject *s; |
2222 | assert(PyEncoder_Check(self)); |
2223 | s = (PyEncoderObject *)self; |
2224 | Py_VISIT(s->markers); |
2225 | Py_VISIT(s->defaultfn); |
2226 | Py_VISIT(s->encoder); |
2227 | Py_VISIT(s->indent); |
2228 | Py_VISIT(s->key_separator); |
2229 | Py_VISIT(s->item_separator); |
2230 | Py_VISIT(s->sort_keys); |
2231 | Py_VISIT(s->skipkeys); |
2232 | return 0; |
2233 | } |
2234 | |
2235 | static int |
2236 | encoder_clear(PyObject *self) |
2237 | { |
2238 | /* Deallocate Encoder */ |
2239 | PyEncoderObject *s; |
2240 | assert(PyEncoder_Check(self)); |
2241 | s = (PyEncoderObject *)self; |
2242 | Py_CLEAR(s->markers); |
2243 | Py_CLEAR(s->defaultfn); |
2244 | Py_CLEAR(s->encoder); |
2245 | Py_CLEAR(s->indent); |
2246 | Py_CLEAR(s->key_separator); |
2247 | Py_CLEAR(s->item_separator); |
2248 | Py_CLEAR(s->sort_keys); |
2249 | Py_CLEAR(s->skipkeys); |
2250 | return 0; |
2251 | } |
2252 | |
2253 | PyDoc_STRVAR(encoder_doc, "_iterencode(obj, _current_indent_level) -> iterable"); |
2254 | |
2255 | static |
2256 | PyTypeObject PyEncoderType = { |
2257 | PyObject_HEAD_INIT(NULL) |
2258 | 0, /* tp_internal */ |
2259 | "simplejson._speedups.Encoder", /* tp_name */ |
2260 | sizeof(PyEncoderObject), /* tp_basicsize */ |
2261 | 0, /* tp_itemsize */ |
2262 | encoder_dealloc, /* tp_dealloc */ |
2263 | 0, /* tp_print */ |
2264 | 0, /* tp_getattr */ |
2265 | 0, /* tp_setattr */ |
2266 | 0, /* tp_compare */ |
2267 | 0, /* tp_repr */ |
2268 | 0, /* tp_as_number */ |
2269 | 0, /* tp_as_sequence */ |
2270 | 0, /* tp_as_mapping */ |
2271 | 0, /* tp_hash */ |
2272 | encoder_call, /* tp_call */ |
2273 | 0, /* tp_str */ |
2274 | 0, /* tp_getattro */ |
2275 | 0, /* tp_setattro */ |
2276 | 0, /* tp_as_buffer */ |
2277 | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */ |
2278 | encoder_doc, /* tp_doc */ |
2279 | encoder_traverse, /* tp_traverse */ |
2280 | encoder_clear, /* tp_clear */ |
2281 | 0, /* tp_richcompare */ |
2282 | 0, /* tp_weaklistoffset */ |
2283 | 0, /* tp_iter */ |
2284 | 0, /* tp_iternext */ |
2285 | 0, /* tp_methods */ |
2286 | encoder_members, /* tp_members */ |
2287 | 0, /* tp_getset */ |
2288 | 0, /* tp_base */ |
2289 | 0, /* tp_dict */ |
2290 | 0, /* tp_descr_get */ |
2291 | 0, /* tp_descr_set */ |
2292 | 0, /* tp_dictoffset */ |
2293 | encoder_init, /* tp_init */ |
2294 | 0, /* tp_alloc */ |
2295 | encoder_new, /* tp_new */ |
2296 | 0, /* tp_free */ |
2297 | }; |
2298 | |
2299 | static PyMethodDef speedups_methods[] = { |
2300 | {"encode_basestring_ascii", |
2301 | (PyCFunction)py_encode_basestring_ascii, |
2302 | METH_O, |
2303 | pydoc_encode_basestring_ascii}, |
2304 | {"scanstring", |
2305 | (PyCFunction)py_scanstring, |
2306 | METH_VARARGS, |
2307 | pydoc_scanstring}, |
2308 | {NULL, NULL, 0, NULL} |
2309 | }; |
2310 | |
2311 | PyDoc_STRVAR(module_doc, |
2312 | "simplejson speedups\n"); |
2313 | |
2314 | void |
2315 | init_speedups(void) |
2316 | { |
2317 | PyObject *m; |
2318 | PyScannerType.tp_new = PyType_GenericNew; |
2319 | if (PyType_Ready(&PyScannerType) < 0) |
2320 | return; |
2321 | PyEncoderType.tp_new = PyType_GenericNew; |
2322 | if (PyType_Ready(&PyEncoderType) < 0) |
2323 | return; |
2324 | m = Py_InitModule3("_speedups", speedups_methods, module_doc); |
2325 | Py_INCREF((PyObject*)&PyScannerType); |
2326 | PyModule_AddObject(m, "make_scanner", (PyObject*)&PyScannerType); |
2327 | Py_INCREF((PyObject*)&PyEncoderType); |
2328 | PyModule_AddObject(m, "make_encoder", (PyObject*)&PyEncoderType); |
2329 | } |