Line data Source code
1 :
2 : /* Write Python objects to files and read them back.
3 : This is primarily intended for writing and reading compiled Python code,
4 : even though dicts, lists, sets and frozensets, not commonly seen in
5 : code objects, are supported.
6 : Version 3 of this protocol properly supports circular links
7 : and sharing. */
8 :
9 : #define PY_SSIZE_T_CLEAN
10 :
11 : #include "Python.h"
12 : #include "pycore_call.h" // _PyObject_CallNoArgs()
13 : #include "pycore_code.h" // _PyCode_New()
14 : #include "pycore_hashtable.h" // _Py_hashtable_t
15 : #include "marshal.h" // Py_MARSHAL_VERSION
16 :
17 : /*[clinic input]
18 : module marshal
19 : [clinic start generated code]*/
20 : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=c982b7930dee17db]*/
21 :
22 : #include "clinic/marshal.c.h"
23 :
24 : /* High water mark to determine when the marshalled object is dangerously deep
25 : * and risks coring the interpreter. When the object stack gets this deep,
26 : * raise an exception instead of continuing.
27 : * On Windows debug builds, reduce this value.
28 : *
29 : * BUG: https://bugs.python.org/issue33720
30 : * On Windows PGO builds, the r_object function overallocates its stack and
31 : * can cause a stack overflow. We reduce the maximum depth for all Windows
32 : * releases to protect against this.
33 : * #if defined(MS_WINDOWS) && defined(_DEBUG)
34 : */
35 : #if defined(MS_WINDOWS)
36 : #define MAX_MARSHAL_STACK_DEPTH 1000
37 : #else
38 : #define MAX_MARSHAL_STACK_DEPTH 2000
39 : #endif
40 :
41 : #define TYPE_NULL '0'
42 : #define TYPE_NONE 'N'
43 : #define TYPE_FALSE 'F'
44 : #define TYPE_TRUE 'T'
45 : #define TYPE_STOPITER 'S'
46 : #define TYPE_ELLIPSIS '.'
47 : #define TYPE_INT 'i'
48 : /* TYPE_INT64 is not generated anymore.
49 : Supported for backward compatibility only. */
50 : #define TYPE_INT64 'I'
51 : #define TYPE_FLOAT 'f'
52 : #define TYPE_BINARY_FLOAT 'g'
53 : #define TYPE_COMPLEX 'x'
54 : #define TYPE_BINARY_COMPLEX 'y'
55 : #define TYPE_LONG 'l'
56 : #define TYPE_STRING 's'
57 : #define TYPE_INTERNED 't'
58 : #define TYPE_REF 'r'
59 : #define TYPE_TUPLE '('
60 : #define TYPE_LIST '['
61 : #define TYPE_DICT '{'
62 : #define TYPE_CODE 'c'
63 : #define TYPE_UNICODE 'u'
64 : #define TYPE_UNKNOWN '?'
65 : #define TYPE_SET '<'
66 : #define TYPE_FROZENSET '>'
67 : #define FLAG_REF '\x80' /* with a type, add obj to index */
68 :
69 : #define TYPE_ASCII 'a'
70 : #define TYPE_ASCII_INTERNED 'A'
71 : #define TYPE_SMALL_TUPLE ')'
72 : #define TYPE_SHORT_ASCII 'z'
73 : #define TYPE_SHORT_ASCII_INTERNED 'Z'
74 :
75 : #define WFERR_OK 0
76 : #define WFERR_UNMARSHALLABLE 1
77 : #define WFERR_NESTEDTOODEEP 2
78 : #define WFERR_NOMEMORY 3
79 :
80 : typedef struct {
81 : FILE *fp;
82 : int error; /* see WFERR_* values */
83 : int depth;
84 : PyObject *str;
85 : char *ptr;
86 : const char *end;
87 : char *buf;
88 : _Py_hashtable_t *hashtable;
89 : int version;
90 : } WFILE;
91 :
92 : #define w_byte(c, p) do { \
93 : if ((p)->ptr != (p)->end || w_reserve((p), 1)) \
94 : *(p)->ptr++ = (c); \
95 : } while(0)
96 :
97 : static void
98 15 : w_flush(WFILE *p)
99 : {
100 15 : assert(p->fp != NULL);
101 15 : fwrite(p->buf, 1, p->ptr - p->buf, p->fp);
102 15 : p->ptr = p->buf;
103 15 : }
104 :
105 : static int
106 26071 : w_reserve(WFILE *p, Py_ssize_t needed)
107 : {
108 : Py_ssize_t pos, size, delta;
109 26071 : if (p->ptr == NULL)
110 0 : return 0; /* An error already occurred */
111 26071 : if (p->fp != NULL) {
112 0 : w_flush(p);
113 0 : return needed <= p->end - p->ptr;
114 : }
115 26071 : assert(p->str != NULL);
116 26071 : pos = p->ptr - p->buf;
117 26071 : size = PyBytes_GET_SIZE(p->str);
118 26071 : if (size > 16*1024*1024)
119 0 : delta = (size >> 3); /* 12.5% overallocation */
120 : else
121 26071 : delta = size + 1024;
122 26071 : delta = Py_MAX(delta, needed);
123 26071 : if (delta > PY_SSIZE_T_MAX - size) {
124 0 : p->error = WFERR_NOMEMORY;
125 0 : return 0;
126 : }
127 26071 : size += delta;
128 26071 : if (_PyBytes_Resize(&p->str, size) != 0) {
129 0 : p->end = p->ptr = p->buf = NULL;
130 0 : return 0;
131 : }
132 : else {
133 26071 : p->buf = PyBytes_AS_STRING(p->str);
134 26071 : p->ptr = p->buf + pos;
135 26071 : p->end = p->buf + size;
136 26071 : return 1;
137 : }
138 : }
139 :
140 : static void
141 2127360 : w_string(const void *s, Py_ssize_t n, WFILE *p)
142 : {
143 : Py_ssize_t m;
144 2127360 : if (!n || p->ptr == NULL)
145 11299 : return;
146 2116060 : m = p->end - p->ptr;
147 2116060 : if (p->fp != NULL) {
148 30 : if (n <= m) {
149 25 : memcpy(p->ptr, s, n);
150 25 : p->ptr += n;
151 : }
152 : else {
153 5 : w_flush(p);
154 5 : fwrite(s, 1, n, p->fp);
155 : }
156 : }
157 : else {
158 2116030 : if (n <= m || w_reserve(p, n - m)) {
159 2116030 : memcpy(p->ptr, s, n);
160 2116030 : p->ptr += n;
161 : }
162 : }
163 : }
164 :
165 : static void
166 24372 : w_short(int x, WFILE *p)
167 : {
168 24372 : w_byte((char)( x & 0xff), p);
169 24372 : w_byte((char)((x>> 8) & 0xff), p);
170 24372 : }
171 :
172 : static void
173 5074130 : w_long(long x, WFILE *p)
174 : {
175 5074130 : w_byte((char)( x & 0xff), p);
176 5074130 : w_byte((char)((x>> 8) & 0xff), p);
177 5074130 : w_byte((char)((x>>16) & 0xff), p);
178 5074130 : w_byte((char)((x>>24) & 0xff), p);
179 5074130 : }
180 :
181 : #define SIZE32_MAX 0x7FFFFFFF
182 :
183 : #if SIZEOF_SIZE_T > 4
184 : # define W_SIZE(n, p) do { \
185 : if ((n) > SIZE32_MAX) { \
186 : (p)->depth--; \
187 : (p)->error = WFERR_UNMARSHALLABLE; \
188 : return; \
189 : } \
190 : w_long((long)(n), p); \
191 : } while(0)
192 : #else
193 : # define W_SIZE w_long
194 : #endif
195 :
196 : static void
197 748904 : w_pstring(const void *s, Py_ssize_t n, WFILE *p)
198 : {
199 748904 : W_SIZE(n, p);
200 748904 : w_string(s, n, p);
201 : }
202 :
203 : static void
204 1372070 : w_short_pstring(const void *s, Py_ssize_t n, WFILE *p)
205 : {
206 1372070 : w_byte(Py_SAFE_DOWNCAST(n, Py_ssize_t, unsigned char), p);
207 1372070 : w_string(s, n, p);
208 1372070 : }
209 :
210 : /* We assume that Python ints are stored internally in base some power of
211 : 2**15; for the sake of portability we'll always read and write them in base
212 : exactly 2**15. */
213 :
214 : #define PyLong_MARSHAL_SHIFT 15
215 : #define PyLong_MARSHAL_BASE ((short)1 << PyLong_MARSHAL_SHIFT)
216 : #define PyLong_MARSHAL_MASK (PyLong_MARSHAL_BASE - 1)
217 : #if PyLong_SHIFT % PyLong_MARSHAL_SHIFT != 0
218 : #error "PyLong_SHIFT must be a multiple of PyLong_MARSHAL_SHIFT"
219 : #endif
220 : #define PyLong_MARSHAL_RATIO (PyLong_SHIFT / PyLong_MARSHAL_SHIFT)
221 :
222 : #define W_TYPE(t, p) do { \
223 : w_byte((t) | flag, (p)); \
224 : } while(0)
225 :
226 : static void
227 6615 : w_PyLong(const PyLongObject *ob, char flag, WFILE *p)
228 : {
229 : Py_ssize_t i, j, n, l;
230 : digit d;
231 :
232 6615 : W_TYPE(TYPE_LONG, p);
233 6615 : if (Py_SIZE(ob) == 0) {
234 0 : w_long((long)0, p);
235 0 : return;
236 : }
237 :
238 : /* set l to number of base PyLong_MARSHAL_BASE digits */
239 6615 : n = Py_ABS(Py_SIZE(ob));
240 6615 : l = (n-1) * PyLong_MARSHAL_RATIO;
241 6615 : d = ob->ob_digit[n-1];
242 6615 : assert(d != 0); /* a PyLong is always normalized */
243 : do {
244 9120 : d >>= PyLong_MARSHAL_SHIFT;
245 9120 : l++;
246 9120 : } while (d != 0);
247 6615 : if (l > SIZE32_MAX) {
248 0 : p->depth--;
249 0 : p->error = WFERR_UNMARSHALLABLE;
250 0 : return;
251 : }
252 6615 : w_long((long)(Py_SIZE(ob) > 0 ? l : -l), p);
253 :
254 14241 : for (i=0; i < n-1; i++) {
255 7626 : d = ob->ob_digit[i];
256 22878 : for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
257 15252 : w_short(d & PyLong_MARSHAL_MASK, p);
258 15252 : d >>= PyLong_MARSHAL_SHIFT;
259 : }
260 7626 : assert (d == 0);
261 : }
262 6615 : d = ob->ob_digit[n-1];
263 : do {
264 9120 : w_short(d & PyLong_MARSHAL_MASK, p);
265 9120 : d >>= PyLong_MARSHAL_SHIFT;
266 9120 : } while (d != 0);
267 : }
268 :
269 : static void
270 6380 : w_float_bin(double v, WFILE *p)
271 : {
272 : char buf[8];
273 6380 : if (PyFloat_Pack8(v, buf, 1) < 0) {
274 0 : p->error = WFERR_UNMARSHALLABLE;
275 0 : return;
276 : }
277 6380 : w_string(buf, 8, p);
278 : }
279 :
280 : static void
281 461 : w_float_str(double v, WFILE *p)
282 : {
283 461 : char *buf = PyOS_double_to_string(v, 'g', 17, 0, NULL);
284 461 : if (!buf) {
285 0 : p->error = WFERR_NOMEMORY;
286 0 : return;
287 : }
288 461 : w_short_pstring(buf, strlen(buf), p);
289 461 : PyMem_Free(buf);
290 : }
291 :
292 : static int
293 5922800 : w_ref(PyObject *v, char *flag, WFILE *p)
294 : {
295 : _Py_hashtable_entry_t *entry;
296 : int w;
297 :
298 5922800 : if (p->version < 3 || p->hashtable == NULL)
299 11476 : return 0; /* not writing object references */
300 :
301 : /* If it has only one reference, it definitely isn't shared.
302 : * But we use TYPE_REF always for interned string, to PYC file stable
303 : * as possible.
304 : */
305 7820020 : if (Py_REFCNT(v) == 1 &&
306 2470630 : !(PyUnicode_CheckExact(v) && PyUnicode_CHECK_INTERNED(v))) {
307 1780060 : return 0;
308 : }
309 :
310 4131270 : entry = _Py_hashtable_get_entry(p->hashtable, v);
311 4131270 : if (entry != NULL) {
312 : /* write the reference index to the stream */
313 2741930 : w = (int)(uintptr_t)entry->value;
314 : /* we don't store "long" indices in the dict */
315 2741930 : assert(0 <= w && w <= 0x7fffffff);
316 2741930 : w_byte(TYPE_REF, p);
317 2741930 : w_long(w, p);
318 2741930 : return 1;
319 : } else {
320 1389340 : size_t s = p->hashtable->nentries;
321 : /* we don't support long indices */
322 1389340 : if (s >= 0x7fffffff) {
323 0 : PyErr_SetString(PyExc_ValueError, "too many objects");
324 0 : goto err;
325 : }
326 1389340 : w = (int)s;
327 1389340 : Py_INCREF(v);
328 1389340 : if (_Py_hashtable_set(p->hashtable, v, (void *)(uintptr_t)w) < 0) {
329 0 : Py_DECREF(v);
330 0 : goto err;
331 : }
332 1389340 : *flag |= FLAG_REF;
333 1389340 : return 0;
334 : }
335 0 : err:
336 0 : p->error = WFERR_UNMARSHALLABLE;
337 0 : return 1;
338 : }
339 :
340 : static void
341 : w_complex_object(PyObject *v, char flag, WFILE *p);
342 :
343 : static void
344 6116770 : w_object(PyObject *v, WFILE *p)
345 : {
346 6116770 : char flag = '\0';
347 :
348 6116770 : p->depth++;
349 :
350 6116770 : if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
351 1 : p->error = WFERR_NESTEDTOODEEP;
352 : }
353 6116770 : else if (v == NULL) {
354 121 : w_byte(TYPE_NULL, p);
355 : }
356 6116650 : else if (v == Py_None) {
357 155754 : w_byte(TYPE_NONE, p);
358 : }
359 5960890 : else if (v == PyExc_StopIteration) {
360 1 : w_byte(TYPE_STOPITER, p);
361 : }
362 5960890 : else if (v == Py_Ellipsis) {
363 591 : w_byte(TYPE_ELLIPSIS, p);
364 : }
365 5960300 : else if (v == Py_False) {
366 17902 : w_byte(TYPE_FALSE, p);
367 : }
368 5942400 : else if (v == Py_True) {
369 19594 : w_byte(TYPE_TRUE, p);
370 : }
371 5922800 : else if (!w_ref(v, &flag, p))
372 3180880 : w_complex_object(v, flag, p);
373 :
374 6116770 : p->depth--;
375 6116770 : }
376 :
377 : static void
378 3180880 : w_complex_object(PyObject *v, char flag, WFILE *p)
379 : {
380 : Py_ssize_t i, n;
381 :
382 3180880 : if (PyLong_CheckExact(v)) {
383 : int overflow;
384 206925 : long x = PyLong_AsLongAndOverflow(v, &overflow);
385 206925 : if (overflow) {
386 527 : w_PyLong((PyLongObject *)v, flag, p);
387 : }
388 : else {
389 : #if SIZEOF_LONG > 4
390 206398 : long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);
391 206398 : if (y && y != -1) {
392 : /* Too large for TYPE_INT */
393 6088 : w_PyLong((PyLongObject*)v, flag, p);
394 : }
395 : else
396 : #endif
397 : {
398 200310 : W_TYPE(TYPE_INT, p);
399 200310 : w_long(x, p);
400 : }
401 : }
402 : }
403 2973950 : else if (PyFloat_CheckExact(v)) {
404 6307 : if (p->version > 1) {
405 5874 : W_TYPE(TYPE_BINARY_FLOAT, p);
406 5874 : w_float_bin(PyFloat_AS_DOUBLE(v), p);
407 : }
408 : else {
409 433 : W_TYPE(TYPE_FLOAT, p);
410 433 : w_float_str(PyFloat_AS_DOUBLE(v), p);
411 : }
412 : }
413 2967640 : else if (PyComplex_CheckExact(v)) {
414 267 : if (p->version > 1) {
415 253 : W_TYPE(TYPE_BINARY_COMPLEX, p);
416 253 : w_float_bin(PyComplex_RealAsDouble(v), p);
417 253 : w_float_bin(PyComplex_ImagAsDouble(v), p);
418 : }
419 : else {
420 14 : W_TYPE(TYPE_COMPLEX, p);
421 14 : w_float_str(PyComplex_RealAsDouble(v), p);
422 14 : w_float_str(PyComplex_ImagAsDouble(v), p);
423 : }
424 : }
425 2967380 : else if (PyBytes_CheckExact(v)) {
426 678450 : W_TYPE(TYPE_STRING, p);
427 678450 : w_pstring(PyBytes_AS_STRING(v), PyBytes_GET_SIZE(v), p);
428 : }
429 2288930 : else if (PyUnicode_CheckExact(v)) {
430 2834140 : if (p->version >= 4 && PyUnicode_IS_ASCII(v)) {
431 1392080 : int is_short = PyUnicode_GET_LENGTH(v) < 256;
432 1392080 : if (is_short) {
433 1371610 : if (PyUnicode_CHECK_INTERNED(v))
434 937744 : W_TYPE(TYPE_SHORT_ASCII_INTERNED, p);
435 : else
436 433868 : W_TYPE(TYPE_SHORT_ASCII, p);
437 1371610 : w_short_pstring(PyUnicode_1BYTE_DATA(v),
438 : PyUnicode_GET_LENGTH(v), p);
439 : }
440 : else {
441 20466 : if (PyUnicode_CHECK_INTERNED(v))
442 34 : W_TYPE(TYPE_ASCII_INTERNED, p);
443 : else
444 20432 : W_TYPE(TYPE_ASCII, p);
445 20466 : w_pstring(PyUnicode_1BYTE_DATA(v),
446 : PyUnicode_GET_LENGTH(v), p);
447 : }
448 : }
449 : else {
450 : PyObject *utf8;
451 49981 : utf8 = PyUnicode_AsEncodedString(v, "utf8", "surrogatepass");
452 49981 : if (utf8 == NULL) {
453 0 : p->depth--;
454 0 : p->error = WFERR_UNMARSHALLABLE;
455 0 : return;
456 : }
457 49981 : if (p->version >= 3 && PyUnicode_CHECK_INTERNED(v))
458 714 : W_TYPE(TYPE_INTERNED, p);
459 : else
460 49267 : W_TYPE(TYPE_UNICODE, p);
461 49981 : w_pstring(PyBytes_AS_STRING(utf8), PyBytes_GET_SIZE(utf8), p);
462 49981 : Py_DECREF(utf8);
463 : }
464 : }
465 846869 : else if (PyTuple_CheckExact(v)) {
466 613523 : n = PyTuple_GET_SIZE(v);
467 613523 : if (p->version >= 4 && n < 256) {
468 611135 : W_TYPE(TYPE_SMALL_TUPLE, p);
469 611135 : w_byte((unsigned char)n, p);
470 : }
471 : else {
472 2388 : W_TYPE(TYPE_TUPLE, p);
473 2388 : W_SIZE(n, p);
474 : }
475 4417580 : for (i = 0; i < n; i++) {
476 3804050 : w_object(PyTuple_GET_ITEM(v, i), p);
477 : }
478 : }
479 233346 : else if (PyList_CheckExact(v)) {
480 4040 : W_TYPE(TYPE_LIST, p);
481 4040 : n = PyList_GET_SIZE(v);
482 4040 : W_SIZE(n, p);
483 13124 : for (i = 0; i < n; i++) {
484 9084 : w_object(PyList_GET_ITEM(v, i), p);
485 : }
486 : }
487 229306 : else if (PyDict_CheckExact(v)) {
488 : Py_ssize_t pos;
489 : PyObject *key, *value;
490 121 : W_TYPE(TYPE_DICT, p);
491 : /* This one is NULL object terminated! */
492 121 : pos = 0;
493 394 : while (PyDict_Next(v, &pos, &key, &value)) {
494 273 : w_object(key, p);
495 273 : w_object(value, p);
496 : }
497 121 : w_object((PyObject *)NULL, p);
498 : }
499 230201 : else if (PyAnySet_CheckExact(v)) {
500 : PyObject *value;
501 1016 : Py_ssize_t pos = 0;
502 : Py_hash_t hash;
503 :
504 1016 : if (PyFrozenSet_CheckExact(v))
505 980 : W_TYPE(TYPE_FROZENSET, p);
506 : else
507 36 : W_TYPE(TYPE_SET, p);
508 1016 : n = PySet_GET_SIZE(v);
509 1016 : W_SIZE(n, p);
510 : // bpo-37596: To support reproducible builds, sets and frozensets need
511 : // to have their elements serialized in a consistent order (even when
512 : // they have been scrambled by hash randomization). To ensure this, we
513 : // use an order equivalent to sorted(v, key=marshal.dumps):
514 1016 : PyObject *pairs = PyList_New(n);
515 1016 : if (pairs == NULL) {
516 0 : p->error = WFERR_NOMEMORY;
517 0 : return;
518 : }
519 1016 : Py_ssize_t i = 0;
520 6855 : while (_PySet_NextEntry(v, &pos, &value, &hash)) {
521 5839 : PyObject *dump = PyMarshal_WriteObjectToString(value, p->version);
522 5839 : if (dump == NULL) {
523 0 : p->error = WFERR_UNMARSHALLABLE;
524 0 : Py_DECREF(pairs);
525 0 : return;
526 : }
527 5839 : PyObject *pair = PyTuple_Pack(2, dump, value);
528 5839 : Py_DECREF(dump);
529 5839 : if (pair == NULL) {
530 0 : p->error = WFERR_NOMEMORY;
531 0 : Py_DECREF(pairs);
532 0 : return;
533 : }
534 5839 : PyList_SET_ITEM(pairs, i++, pair);
535 : }
536 1016 : assert(i == n);
537 1016 : if (PyList_Sort(pairs)) {
538 0 : p->error = WFERR_NOMEMORY;
539 0 : Py_DECREF(pairs);
540 0 : return;
541 : }
542 6855 : for (Py_ssize_t i = 0; i < n; i++) {
543 5839 : PyObject *pair = PyList_GET_ITEM(pairs, i);
544 5839 : value = PyTuple_GET_ITEM(pair, 1);
545 5839 : w_object(value, p);
546 : }
547 1016 : Py_DECREF(pairs);
548 : }
549 228169 : else if (PyCode_Check(v)) {
550 228154 : PyCodeObject *co = (PyCodeObject *)v;
551 228154 : PyObject *co_code = _PyCode_GetCode(co);
552 228154 : if (co_code == NULL) {
553 0 : p->error = WFERR_NOMEMORY;
554 0 : return;
555 : }
556 228154 : W_TYPE(TYPE_CODE, p);
557 228154 : w_long(co->co_argcount, p);
558 228154 : w_long(co->co_posonlyargcount, p);
559 228154 : w_long(co->co_kwonlyargcount, p);
560 228154 : w_long(co->co_stacksize, p);
561 228154 : w_long(co->co_flags, p);
562 228154 : w_object(co_code, p);
563 228154 : w_object(co->co_consts, p);
564 228154 : w_object(co->co_names, p);
565 228154 : w_object(co->co_localsplusnames, p);
566 228154 : w_object(co->co_localspluskinds, p);
567 228154 : w_object(co->co_filename, p);
568 228154 : w_object(co->co_name, p);
569 228154 : w_object(co->co_qualname, p);
570 228154 : w_long(co->co_firstlineno, p);
571 228154 : w_object(co->co_linetable, p);
572 228154 : w_object(co->co_exceptiontable, p);
573 228154 : Py_DECREF(co_code);
574 : }
575 15 : else if (PyObject_CheckBuffer(v)) {
576 : /* Write unknown bytes-like objects as a bytes object */
577 : Py_buffer view;
578 7 : if (PyObject_GetBuffer(v, &view, PyBUF_SIMPLE) != 0) {
579 0 : w_byte(TYPE_UNKNOWN, p);
580 0 : p->depth--;
581 0 : p->error = WFERR_UNMARSHALLABLE;
582 0 : return;
583 : }
584 7 : W_TYPE(TYPE_STRING, p);
585 7 : w_pstring(view.buf, view.len, p);
586 7 : PyBuffer_Release(&view);
587 : }
588 : else {
589 8 : W_TYPE(TYPE_UNKNOWN, p);
590 8 : p->error = WFERR_UNMARSHALLABLE;
591 : }
592 : }
593 :
594 : static void
595 1389340 : w_decref_entry(void *key)
596 : {
597 1389340 : PyObject *entry_key = (PyObject *)key;
598 1389340 : Py_XDECREF(entry_key);
599 1389340 : }
600 :
601 : static int
602 15586 : w_init_refs(WFILE *wf, int version)
603 : {
604 15586 : if (version >= 3) {
605 15033 : wf->hashtable = _Py_hashtable_new_full(_Py_hashtable_hash_ptr,
606 : _Py_hashtable_compare_direct,
607 : w_decref_entry, NULL, NULL);
608 15033 : if (wf->hashtable == NULL) {
609 0 : PyErr_NoMemory();
610 0 : return -1;
611 : }
612 : }
613 15586 : return 0;
614 : }
615 :
616 : static void
617 15586 : w_clear_refs(WFILE *wf)
618 : {
619 15586 : if (wf->hashtable != NULL) {
620 15033 : _Py_hashtable_destroy(wf->hashtable);
621 : }
622 15586 : }
623 :
624 : /* version currently has no effect for writing ints. */
625 : void
626 5 : PyMarshal_WriteLongToFile(long x, FILE *fp, int version)
627 : {
628 : char buf[4];
629 : WFILE wf;
630 5 : memset(&wf, 0, sizeof(wf));
631 5 : wf.fp = fp;
632 5 : wf.ptr = wf.buf = buf;
633 5 : wf.end = wf.ptr + sizeof(buf);
634 5 : wf.error = WFERR_OK;
635 5 : wf.version = version;
636 5 : w_long(x, &wf);
637 5 : w_flush(&wf);
638 5 : }
639 :
640 : void
641 5 : PyMarshal_WriteObjectToFile(PyObject *x, FILE *fp, int version)
642 : {
643 : char buf[BUFSIZ];
644 : WFILE wf;
645 5 : if (PySys_Audit("marshal.dumps", "Oi", x, version) < 0) {
646 0 : return; /* caller must check PyErr_Occurred() */
647 : }
648 5 : memset(&wf, 0, sizeof(wf));
649 5 : wf.fp = fp;
650 5 : wf.ptr = wf.buf = buf;
651 5 : wf.end = wf.ptr + sizeof(buf);
652 5 : wf.error = WFERR_OK;
653 5 : wf.version = version;
654 5 : if (w_init_refs(&wf, version)) {
655 0 : return; /* caller must check PyErr_Occurred() */
656 : }
657 5 : w_object(x, &wf);
658 5 : w_clear_refs(&wf);
659 5 : w_flush(&wf);
660 : }
661 :
662 : typedef struct {
663 : FILE *fp;
664 : int depth;
665 : PyObject *readable; /* Stream-like object being read from */
666 : const char *ptr;
667 : const char *end;
668 : char *buf;
669 : Py_ssize_t buf_size;
670 : PyObject *refs; /* a list */
671 : } RFILE;
672 :
673 : static const char *
674 252353000 : r_string(Py_ssize_t n, RFILE *p)
675 : {
676 252353000 : Py_ssize_t read = -1;
677 :
678 252353000 : if (p->ptr != NULL) {
679 : /* Fast path for loads() */
680 252232000 : const char *res = p->ptr;
681 252232000 : Py_ssize_t left = p->end - p->ptr;
682 252232000 : if (left < n) {
683 51 : PyErr_SetString(PyExc_EOFError,
684 : "marshal data too short");
685 51 : return NULL;
686 : }
687 252232000 : p->ptr += n;
688 252232000 : return res;
689 : }
690 120877 : if (p->buf == NULL) {
691 1151 : p->buf = PyMem_Malloc(n);
692 1151 : if (p->buf == NULL) {
693 0 : PyErr_NoMemory();
694 0 : return NULL;
695 : }
696 1151 : p->buf_size = n;
697 : }
698 119726 : else if (p->buf_size < n) {
699 1113 : char *tmp = PyMem_Realloc(p->buf, n);
700 1113 : if (tmp == NULL) {
701 0 : PyErr_NoMemory();
702 0 : return NULL;
703 : }
704 1113 : p->buf = tmp;
705 1113 : p->buf_size = n;
706 : }
707 :
708 120877 : if (!p->readable) {
709 164 : assert(p->fp != NULL);
710 164 : read = fread(p->buf, 1, n, p->fp);
711 : }
712 : else {
713 : PyObject *res, *mview;
714 : Py_buffer buf;
715 :
716 120713 : if (PyBuffer_FillInfo(&buf, NULL, p->buf, n, 0, PyBUF_CONTIG) == -1)
717 0 : return NULL;
718 120713 : mview = PyMemoryView_FromBuffer(&buf);
719 120713 : if (mview == NULL)
720 0 : return NULL;
721 :
722 120713 : res = _PyObject_CallMethod(p->readable, &_Py_ID(readinto), "N", mview);
723 120713 : if (res != NULL) {
724 120713 : read = PyNumber_AsSsize_t(res, PyExc_ValueError);
725 120713 : Py_DECREF(res);
726 : }
727 : }
728 120877 : if (read != n) {
729 10 : if (!PyErr_Occurred()) {
730 10 : if (read > n)
731 4 : PyErr_Format(PyExc_ValueError,
732 : "read() returned too much data: "
733 : "%zd bytes requested, %zd returned",
734 : n, read);
735 : else
736 6 : PyErr_SetString(PyExc_EOFError,
737 : "EOF read where not expected");
738 : }
739 10 : return NULL;
740 : }
741 120867 : return p->buf;
742 : }
743 :
744 : static int
745 282278000 : r_byte(RFILE *p)
746 : {
747 282278000 : int c = EOF;
748 :
749 282278000 : if (p->ptr != NULL) {
750 282221000 : if (p->ptr < p->end)
751 282221000 : c = (unsigned char) *p->ptr++;
752 282221000 : return c;
753 : }
754 56888 : if (!p->readable) {
755 44 : assert(p->fp);
756 44 : c = getc(p->fp);
757 : }
758 : else {
759 56844 : const char *ptr = r_string(1, p);
760 56844 : if (ptr != NULL)
761 56844 : c = *(const unsigned char *) ptr;
762 : }
763 56888 : return c;
764 : }
765 :
766 : static int
767 81609 : r_short(RFILE *p)
768 : {
769 81609 : short x = -1;
770 : const unsigned char *buffer;
771 :
772 81609 : buffer = (const unsigned char *) r_string(2, p);
773 81609 : if (buffer != NULL) {
774 81607 : x = buffer[0];
775 81607 : x |= buffer[1] << 8;
776 : /* Sign-extension, in case short greater than 16 bits */
777 81607 : x |= -(x & 0x8000);
778 : }
779 81609 : return x;
780 : }
781 :
782 : static long
783 174258000 : r_long(RFILE *p)
784 : {
785 174258000 : long x = -1;
786 : const unsigned char *buffer;
787 :
788 174258000 : buffer = (const unsigned char *) r_string(4, p);
789 174258000 : if (buffer != NULL) {
790 174258000 : x = buffer[0];
791 174258000 : x |= (long)buffer[1] << 8;
792 174258000 : x |= (long)buffer[2] << 16;
793 174258000 : x |= (long)buffer[3] << 24;
794 : #if SIZEOF_LONG > 4
795 : /* Sign extension for 64-bit machines */
796 174258000 : x |= -(x & 0x80000000L);
797 : #endif
798 : }
799 174258000 : return x;
800 : }
801 :
802 : /* r_long64 deals with the TYPE_INT64 code. */
803 : static PyObject *
804 260 : r_long64(RFILE *p)
805 : {
806 260 : const unsigned char *buffer = (const unsigned char *) r_string(8, p);
807 260 : if (buffer == NULL) {
808 2 : return NULL;
809 : }
810 258 : return _PyLong_FromByteArray(buffer, 8,
811 : 1 /* little endian */,
812 : 1 /* signed */);
813 : }
814 :
815 : static PyObject *
816 23110 : r_PyLong(RFILE *p)
817 : {
818 : PyLongObject *ob;
819 : long n, size, i;
820 : int j, md, shorts_in_top_digit;
821 : digit d;
822 :
823 23110 : n = r_long(p);
824 23110 : if (PyErr_Occurred())
825 2 : return NULL;
826 23108 : if (n == 0)
827 0 : return (PyObject *)_PyLong_New(0);
828 23108 : if (n < -SIZE32_MAX || n > SIZE32_MAX) {
829 0 : PyErr_SetString(PyExc_ValueError,
830 : "bad marshal data (long size out of range)");
831 0 : return NULL;
832 : }
833 :
834 23108 : size = 1 + (Py_ABS(n) - 1) / PyLong_MARSHAL_RATIO;
835 23108 : shorts_in_top_digit = 1 + (Py_ABS(n) - 1) % PyLong_MARSHAL_RATIO;
836 23108 : ob = _PyLong_New(size);
837 23108 : if (ob == NULL)
838 0 : return NULL;
839 :
840 23108 : Py_SET_SIZE(ob, n > 0 ? size : -size);
841 :
842 51113 : for (i = 0; i < size-1; i++) {
843 28005 : d = 0;
844 84015 : for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
845 56010 : md = r_short(p);
846 56010 : if (PyErr_Occurred()) {
847 0 : Py_DECREF(ob);
848 0 : return NULL;
849 : }
850 56010 : if (md < 0 || md > PyLong_MARSHAL_BASE)
851 0 : goto bad_digit;
852 56010 : d += (digit)md << j*PyLong_MARSHAL_SHIFT;
853 : }
854 28005 : ob->ob_digit[i] = d;
855 : }
856 :
857 23108 : d = 0;
858 48703 : for (j=0; j < shorts_in_top_digit; j++) {
859 25597 : md = r_short(p);
860 25597 : if (PyErr_Occurred()) {
861 1 : Py_DECREF(ob);
862 1 : return NULL;
863 : }
864 25596 : if (md < 0 || md > PyLong_MARSHAL_BASE)
865 0 : goto bad_digit;
866 : /* topmost marshal digit should be nonzero */
867 25596 : if (md == 0 && j == shorts_in_top_digit - 1) {
868 1 : Py_DECREF(ob);
869 1 : PyErr_SetString(PyExc_ValueError,
870 : "bad marshal data (unnormalized long data)");
871 1 : return NULL;
872 : }
873 25595 : d += (digit)md << j*PyLong_MARSHAL_SHIFT;
874 : }
875 23106 : if (PyErr_Occurred()) {
876 0 : Py_DECREF(ob);
877 0 : return NULL;
878 : }
879 : /* top digit should be nonzero, else the resulting PyLong won't be
880 : normalized */
881 23106 : ob->ob_digit[size-1] = d;
882 23106 : return (PyObject *)ob;
883 0 : bad_digit:
884 0 : Py_DECREF(ob);
885 0 : PyErr_SetString(PyExc_ValueError,
886 : "bad marshal data (digit out of range in long)");
887 0 : return NULL;
888 : }
889 :
890 : static double
891 89299 : r_float_bin(RFILE *p)
892 : {
893 89299 : const char *buf = r_string(8, p);
894 89299 : if (buf == NULL)
895 6 : return -1;
896 89293 : return PyFloat_Unpack8(buf, 1);
897 : }
898 :
899 : /* Issue #33720: Disable inlining for reducing the C stack consumption
900 : on PGO builds. */
901 : Py_NO_INLINE static double
902 466 : r_float_str(RFILE *p)
903 : {
904 : int n;
905 : char buf[256];
906 : const char *ptr;
907 466 : n = r_byte(p);
908 466 : if (n == EOF) {
909 5 : PyErr_SetString(PyExc_EOFError,
910 : "EOF read where object expected");
911 5 : return -1;
912 : }
913 461 : ptr = r_string(n, p);
914 461 : if (ptr == NULL) {
915 0 : return -1;
916 : }
917 461 : memcpy(buf, ptr, n);
918 461 : buf[n] = '\0';
919 461 : return PyOS_string_to_double(buf, NULL, NULL);
920 : }
921 :
922 : /* allocate the reflist index for a new object. Return -1 on failure */
923 : static Py_ssize_t
924 8574600 : r_ref_reserve(int flag, RFILE *p)
925 : {
926 8574600 : if (flag) { /* currently only FLAG_REF is defined */
927 201979 : Py_ssize_t idx = PyList_GET_SIZE(p->refs);
928 201979 : if (idx >= 0x7ffffffe) {
929 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (index list too large)");
930 0 : return -1;
931 : }
932 201979 : if (PyList_Append(p->refs, Py_None) < 0)
933 0 : return -1;
934 201979 : return idx;
935 : } else
936 8372620 : return 0;
937 : }
938 :
939 : /* insert the new object 'o' to the reflist at previously
940 : * allocated index 'idx'.
941 : * 'o' can be NULL, in which case nothing is done.
942 : * if 'o' was non-NULL, and the function succeeds, 'o' is returned.
943 : * if 'o' was non-NULL, and the function fails, 'o' is released and
944 : * NULL returned. This simplifies error checking at the call site since
945 : * a single test for NULL for the function result is enough.
946 : */
947 : static PyObject *
948 8574600 : r_ref_insert(PyObject *o, Py_ssize_t idx, int flag, RFILE *p)
949 : {
950 8574600 : if (o != NULL && flag) { /* currently only FLAG_REF is defined */
951 201978 : PyObject *tmp = PyList_GET_ITEM(p->refs, idx);
952 201978 : Py_INCREF(o);
953 201978 : PyList_SET_ITEM(p->refs, idx, o);
954 201978 : Py_DECREF(tmp);
955 : }
956 8574600 : return o;
957 : }
958 :
959 : /* combination of both above, used when an object can be
960 : * created whenever it is seen in the file, as opposed to
961 : * after having loaded its sub-objects.
962 : */
963 : static PyObject *
964 51569400 : r_ref(PyObject *o, int flag, RFILE *p)
965 : {
966 51569400 : assert(flag & FLAG_REF);
967 51569400 : if (o == NULL)
968 3 : return NULL;
969 51569400 : if (PyList_Append(p->refs, o) < 0) {
970 0 : Py_DECREF(o); /* release the new object */
971 0 : return NULL;
972 : }
973 51569400 : return o;
974 : }
975 :
976 : static PyObject *
977 210347000 : r_object(RFILE *p)
978 : {
979 : /* NULL is a valid return value, it does not necessarily means that
980 : an exception is set. */
981 : PyObject *v, *v2;
982 210347000 : Py_ssize_t idx = 0;
983 : long i, n;
984 210347000 : int type, code = r_byte(p);
985 210347000 : int flag, is_interned = 0;
986 210347000 : PyObject *retval = NULL;
987 :
988 210347000 : if (code == EOF) {
989 20 : PyErr_SetString(PyExc_EOFError,
990 : "EOF read where object expected");
991 20 : return NULL;
992 : }
993 :
994 210347000 : p->depth++;
995 :
996 210347000 : if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
997 5 : p->depth--;
998 5 : PyErr_SetString(PyExc_ValueError, "recursion limit exceeded");
999 5 : return NULL;
1000 : }
1001 :
1002 210347000 : flag = code & FLAG_REF;
1003 210347000 : type = code & ~FLAG_REF;
1004 :
1005 : #define R_REF(O) do{\
1006 : if (flag) \
1007 : O = r_ref(O, flag, p);\
1008 : } while (0)
1009 :
1010 210347000 : switch (type) {
1011 :
1012 2185 : case TYPE_NULL:
1013 2185 : break;
1014 :
1015 5153060 : case TYPE_NONE:
1016 5153060 : Py_INCREF(Py_None);
1017 5153060 : retval = Py_None;
1018 5153060 : break;
1019 :
1020 3 : case TYPE_STOPITER:
1021 3 : Py_INCREF(PyExc_StopIteration);
1022 3 : retval = PyExc_StopIteration;
1023 3 : break;
1024 :
1025 17561 : case TYPE_ELLIPSIS:
1026 17561 : Py_INCREF(Py_Ellipsis);
1027 17561 : retval = Py_Ellipsis;
1028 17561 : break;
1029 :
1030 786106 : case TYPE_FALSE:
1031 786106 : Py_INCREF(Py_False);
1032 786106 : retval = Py_False;
1033 786106 : break;
1034 :
1035 797070 : case TYPE_TRUE:
1036 797070 : Py_INCREF(Py_True);
1037 797070 : retval = Py_True;
1038 797070 : break;
1039 :
1040 2194930 : case TYPE_INT:
1041 2194930 : n = r_long(p);
1042 2194930 : retval = PyErr_Occurred() ? NULL : PyLong_FromLong(n);
1043 2194930 : R_REF(retval);
1044 2194930 : break;
1045 :
1046 260 : case TYPE_INT64:
1047 260 : retval = r_long64(p);
1048 260 : R_REF(retval);
1049 260 : break;
1050 :
1051 23110 : case TYPE_LONG:
1052 23110 : retval = r_PyLong(p);
1053 23110 : R_REF(retval);
1054 23110 : break;
1055 :
1056 436 : case TYPE_FLOAT:
1057 : {
1058 436 : double x = r_float_str(p);
1059 436 : if (x == -1.0 && PyErr_Occurred())
1060 3 : break;
1061 433 : retval = PyFloat_FromDouble(x);
1062 433 : R_REF(retval);
1063 433 : break;
1064 : }
1065 :
1066 88284 : case TYPE_BINARY_FLOAT:
1067 : {
1068 88284 : double x = r_float_bin(p);
1069 88284 : if (x == -1.0 && PyErr_Occurred())
1070 3 : break;
1071 88281 : retval = PyFloat_FromDouble(x);
1072 88281 : R_REF(retval);
1073 88281 : break;
1074 : }
1075 :
1076 16 : case TYPE_COMPLEX:
1077 : {
1078 : Py_complex c;
1079 16 : c.real = r_float_str(p);
1080 16 : if (c.real == -1.0 && PyErr_Occurred())
1081 2 : break;
1082 14 : c.imag = r_float_str(p);
1083 14 : if (c.imag == -1.0 && PyErr_Occurred())
1084 0 : break;
1085 14 : retval = PyComplex_FromCComplex(c);
1086 14 : R_REF(retval);
1087 14 : break;
1088 : }
1089 :
1090 509 : case TYPE_BINARY_COMPLEX:
1091 : {
1092 : Py_complex c;
1093 509 : c.real = r_float_bin(p);
1094 509 : if (c.real == -1.0 && PyErr_Occurred())
1095 3 : break;
1096 506 : c.imag = r_float_bin(p);
1097 506 : if (c.imag == -1.0 && PyErr_Occurred())
1098 0 : break;
1099 506 : retval = PyComplex_FromCComplex(c);
1100 506 : R_REF(retval);
1101 506 : break;
1102 : }
1103 :
1104 25464500 : case TYPE_STRING:
1105 : {
1106 : const char *ptr;
1107 25464500 : n = r_long(p);
1108 25464500 : if (PyErr_Occurred())
1109 2 : break;
1110 25464500 : if (n < 0 || n > SIZE32_MAX) {
1111 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (bytes object size out of range)");
1112 0 : break;
1113 : }
1114 25464500 : v = PyBytes_FromStringAndSize((char *)NULL, n);
1115 25464500 : if (v == NULL)
1116 0 : break;
1117 25464500 : ptr = r_string(n, p);
1118 25464500 : if (ptr == NULL) {
1119 1 : Py_DECREF(v);
1120 1 : break;
1121 : }
1122 25464500 : memcpy(PyBytes_AS_STRING(v), ptr, n);
1123 25464500 : retval = v;
1124 25464500 : R_REF(retval);
1125 25464500 : break;
1126 : }
1127 :
1128 30 : case TYPE_ASCII_INTERNED:
1129 30 : is_interned = 1;
1130 : /* fall through */
1131 885499 : case TYPE_ASCII:
1132 885499 : n = r_long(p);
1133 885499 : if (PyErr_Occurred())
1134 4 : break;
1135 885495 : if (n < 0 || n > SIZE32_MAX) {
1136 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (string size out of range)");
1137 0 : break;
1138 : }
1139 885495 : goto _read_ascii;
1140 :
1141 36876400 : case TYPE_SHORT_ASCII_INTERNED:
1142 36876400 : is_interned = 1;
1143 : /* fall through */
1144 51386900 : case TYPE_SHORT_ASCII:
1145 51386900 : n = r_byte(p);
1146 51386900 : if (n == EOF) {
1147 6 : PyErr_SetString(PyExc_EOFError,
1148 : "EOF read where object expected");
1149 6 : break;
1150 : }
1151 51386900 : _read_ascii:
1152 : {
1153 : const char *ptr;
1154 52272400 : ptr = r_string(n, p);
1155 52272400 : if (ptr == NULL)
1156 11 : break;
1157 52272400 : v = PyUnicode_FromKindAndData(PyUnicode_1BYTE_KIND, ptr, n);
1158 52272400 : if (v == NULL)
1159 0 : break;
1160 52272400 : if (is_interned)
1161 36876400 : PyUnicode_InternInPlace(&v);
1162 52272400 : retval = v;
1163 52272400 : R_REF(retval);
1164 52272400 : break;
1165 : }
1166 :
1167 665 : case TYPE_INTERNED:
1168 665 : is_interned = 1;
1169 : /* fall through */
1170 129527 : case TYPE_UNICODE:
1171 : {
1172 : const char *buffer;
1173 :
1174 129527 : n = r_long(p);
1175 129527 : if (PyErr_Occurred())
1176 4 : break;
1177 129523 : if (n < 0 || n > SIZE32_MAX) {
1178 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (string size out of range)");
1179 0 : break;
1180 : }
1181 129523 : if (n != 0) {
1182 129511 : buffer = r_string(n, p);
1183 129511 : if (buffer == NULL)
1184 0 : break;
1185 129511 : v = PyUnicode_DecodeUTF8(buffer, n, "surrogatepass");
1186 : }
1187 : else {
1188 12 : v = PyUnicode_New(0, 0);
1189 : }
1190 129523 : if (v == NULL)
1191 0 : break;
1192 129523 : if (is_interned)
1193 663 : PyUnicode_InternInPlace(&v);
1194 129523 : retval = v;
1195 129523 : R_REF(retval);
1196 129523 : break;
1197 : }
1198 :
1199 20543600 : case TYPE_SMALL_TUPLE:
1200 20543600 : n = (unsigned char) r_byte(p);
1201 20543600 : if (PyErr_Occurred())
1202 0 : break;
1203 20543600 : goto _read_tuple;
1204 22163 : case TYPE_TUPLE:
1205 22163 : n = r_long(p);
1206 22163 : if (PyErr_Occurred())
1207 10 : break;
1208 22153 : if (n < 0 || n > SIZE32_MAX) {
1209 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (tuple size out of range)");
1210 0 : break;
1211 : }
1212 22153 : _read_tuple:
1213 20565700 : v = PyTuple_New(n);
1214 20565700 : R_REF(v);
1215 20565700 : if (v == NULL)
1216 0 : break;
1217 :
1218 145180000 : for (i = 0; i < n; i++) {
1219 124618000 : v2 = r_object(p);
1220 124618000 : if ( v2 == NULL ) {
1221 4020 : if (!PyErr_Occurred())
1222 0 : PyErr_SetString(PyExc_TypeError,
1223 : "NULL object in marshal data for tuple");
1224 4020 : Py_DECREF(v);
1225 4020 : v = NULL;
1226 4020 : break;
1227 : }
1228 124614000 : PyTuple_SET_ITEM(v, i, v2);
1229 : }
1230 20565700 : retval = v;
1231 20565700 : break;
1232 :
1233 4141 : case TYPE_LIST:
1234 4141 : n = r_long(p);
1235 4141 : if (PyErr_Occurred())
1236 2 : break;
1237 4139 : if (n < 0 || n > SIZE32_MAX) {
1238 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (list size out of range)");
1239 0 : break;
1240 : }
1241 4139 : v = PyList_New(n);
1242 4139 : R_REF(v);
1243 4139 : if (v == NULL)
1244 0 : break;
1245 8325 : for (i = 0; i < n; i++) {
1246 6186 : v2 = r_object(p);
1247 6186 : if ( v2 == NULL ) {
1248 2000 : if (!PyErr_Occurred())
1249 0 : PyErr_SetString(PyExc_TypeError,
1250 : "NULL object in marshal data for list");
1251 2000 : Py_DECREF(v);
1252 2000 : v = NULL;
1253 2000 : break;
1254 : }
1255 4186 : PyList_SET_ITEM(v, i, v2);
1256 : }
1257 4139 : retval = v;
1258 4139 : break;
1259 :
1260 4184 : case TYPE_DICT:
1261 4184 : v = PyDict_New();
1262 4184 : R_REF(v);
1263 4184 : if (v == NULL)
1264 0 : break;
1265 5502 : for (;;) {
1266 : PyObject *key, *val;
1267 9686 : key = r_object(p);
1268 9686 : if (key == NULL)
1269 2185 : break;
1270 7501 : val = r_object(p);
1271 7501 : if (val == NULL) {
1272 1999 : Py_DECREF(key);
1273 1999 : break;
1274 : }
1275 5502 : if (PyDict_SetItem(v, key, val) < 0) {
1276 0 : Py_DECREF(key);
1277 0 : Py_DECREF(val);
1278 0 : break;
1279 : }
1280 5502 : Py_DECREF(key);
1281 5502 : Py_DECREF(val);
1282 : }
1283 4184 : if (PyErr_Occurred()) {
1284 2002 : Py_DECREF(v);
1285 2002 : v = NULL;
1286 : }
1287 4184 : retval = v;
1288 4184 : break;
1289 :
1290 36362 : case TYPE_SET:
1291 : case TYPE_FROZENSET:
1292 36362 : n = r_long(p);
1293 36362 : if (PyErr_Occurred())
1294 8 : break;
1295 36354 : if (n < 0 || n > SIZE32_MAX) {
1296 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (set size out of range)");
1297 0 : break;
1298 : }
1299 :
1300 36354 : if (n == 0 && type == TYPE_FROZENSET) {
1301 : /* call frozenset() to get the empty frozenset singleton */
1302 0 : v = _PyObject_CallNoArgs((PyObject*)&PyFrozenSet_Type);
1303 0 : if (v == NULL)
1304 0 : break;
1305 0 : R_REF(v);
1306 0 : retval = v;
1307 : }
1308 : else {
1309 36354 : v = (type == TYPE_SET) ? PySet_New(NULL) : PyFrozenSet_New(NULL);
1310 36354 : if (type == TYPE_SET) {
1311 36 : R_REF(v);
1312 : } else {
1313 : /* must use delayed registration of frozensets because they must
1314 : * be init with a refcount of 1
1315 : */
1316 36318 : idx = r_ref_reserve(flag, p);
1317 36318 : if (idx < 0)
1318 0 : Py_CLEAR(v); /* signal error */
1319 : }
1320 36354 : if (v == NULL)
1321 0 : break;
1322 :
1323 148954 : for (i = 0; i < n; i++) {
1324 114604 : v2 = r_object(p);
1325 114604 : if ( v2 == NULL ) {
1326 2004 : if (!PyErr_Occurred())
1327 0 : PyErr_SetString(PyExc_TypeError,
1328 : "NULL object in marshal data for set");
1329 2004 : Py_DECREF(v);
1330 2004 : v = NULL;
1331 2004 : break;
1332 : }
1333 112600 : if (PySet_Add(v, v2) == -1) {
1334 0 : Py_DECREF(v);
1335 0 : Py_DECREF(v2);
1336 0 : v = NULL;
1337 0 : break;
1338 : }
1339 112600 : Py_DECREF(v2);
1340 : }
1341 36354 : if (type != TYPE_SET)
1342 36318 : v = r_ref_insert(v, idx, flag, p);
1343 36354 : retval = v;
1344 : }
1345 36354 : break;
1346 :
1347 8538280 : case TYPE_CODE:
1348 : {
1349 : int argcount;
1350 : int posonlyargcount;
1351 : int kwonlyargcount;
1352 : int stacksize;
1353 : int flags;
1354 8538280 : PyObject *code = NULL;
1355 8538280 : PyObject *consts = NULL;
1356 8538280 : PyObject *names = NULL;
1357 8538280 : PyObject *localsplusnames = NULL;
1358 8538280 : PyObject *localspluskinds = NULL;
1359 8538280 : PyObject *filename = NULL;
1360 8538280 : PyObject *name = NULL;
1361 8538280 : PyObject *qualname = NULL;
1362 : int firstlineno;
1363 8538280 : PyObject* linetable = NULL;
1364 8538280 : PyObject *exceptiontable = NULL;
1365 :
1366 8538280 : idx = r_ref_reserve(flag, p);
1367 8538280 : if (idx < 0)
1368 0 : break;
1369 :
1370 8538280 : v = NULL;
1371 :
1372 : /* XXX ignore long->int overflows for now */
1373 8538280 : argcount = (int)r_long(p);
1374 8538280 : if (PyErr_Occurred())
1375 2 : goto code_error;
1376 8538280 : posonlyargcount = (int)r_long(p);
1377 8538280 : if (PyErr_Occurred()) {
1378 0 : goto code_error;
1379 : }
1380 8538280 : kwonlyargcount = (int)r_long(p);
1381 8538280 : if (PyErr_Occurred())
1382 0 : goto code_error;
1383 8538280 : stacksize = (int)r_long(p);
1384 8538280 : if (PyErr_Occurred())
1385 0 : goto code_error;
1386 8538280 : flags = (int)r_long(p);
1387 8538280 : if (PyErr_Occurred())
1388 0 : goto code_error;
1389 8538280 : code = r_object(p);
1390 8538280 : if (code == NULL)
1391 0 : goto code_error;
1392 8538280 : consts = r_object(p);
1393 8538280 : if (consts == NULL)
1394 0 : goto code_error;
1395 8538280 : names = r_object(p);
1396 8538280 : if (names == NULL)
1397 0 : goto code_error;
1398 8538280 : localsplusnames = r_object(p);
1399 8538280 : if (localsplusnames == NULL)
1400 0 : goto code_error;
1401 8538280 : localspluskinds = r_object(p);
1402 8538280 : if (localspluskinds == NULL)
1403 0 : goto code_error;
1404 8538280 : filename = r_object(p);
1405 8538280 : if (filename == NULL)
1406 0 : goto code_error;
1407 8538280 : name = r_object(p);
1408 8538280 : if (name == NULL)
1409 0 : goto code_error;
1410 8538280 : qualname = r_object(p);
1411 8538280 : if (qualname == NULL)
1412 0 : goto code_error;
1413 8538280 : firstlineno = (int)r_long(p);
1414 8538280 : if (firstlineno == -1 && PyErr_Occurred())
1415 0 : break;
1416 8538280 : linetable = r_object(p);
1417 8538280 : if (linetable == NULL)
1418 0 : goto code_error;
1419 8538280 : exceptiontable = r_object(p);
1420 8538280 : if (exceptiontable == NULL)
1421 0 : goto code_error;
1422 :
1423 8538280 : struct _PyCodeConstructor con = {
1424 : .filename = filename,
1425 : .name = name,
1426 : .qualname = qualname,
1427 : .flags = flags,
1428 :
1429 : .code = code,
1430 : .firstlineno = firstlineno,
1431 : .linetable = linetable,
1432 :
1433 : .consts = consts,
1434 : .names = names,
1435 :
1436 : .localsplusnames = localsplusnames,
1437 : .localspluskinds = localspluskinds,
1438 :
1439 : .argcount = argcount,
1440 : .posonlyargcount = posonlyargcount,
1441 : .kwonlyargcount = kwonlyargcount,
1442 :
1443 : .stacksize = stacksize,
1444 :
1445 : .exceptiontable = exceptiontable,
1446 : };
1447 :
1448 8538280 : if (_PyCode_Validate(&con) < 0) {
1449 0 : goto code_error;
1450 : }
1451 :
1452 8538280 : v = (PyObject *)_PyCode_New(&con);
1453 8538280 : if (v == NULL) {
1454 0 : goto code_error;
1455 : }
1456 :
1457 8538280 : v = r_ref_insert(v, idx, flag, p);
1458 :
1459 8538280 : code_error:
1460 8538280 : Py_XDECREF(code);
1461 8538280 : Py_XDECREF(consts);
1462 8538280 : Py_XDECREF(names);
1463 8538280 : Py_XDECREF(localsplusnames);
1464 8538280 : Py_XDECREF(localspluskinds);
1465 8538280 : Py_XDECREF(filename);
1466 8538280 : Py_XDECREF(name);
1467 8538280 : Py_XDECREF(qualname);
1468 8538280 : Py_XDECREF(linetable);
1469 8538280 : Py_XDECREF(exceptiontable);
1470 : }
1471 8538280 : retval = v;
1472 8538280 : break;
1473 :
1474 94267700 : case TYPE_REF:
1475 94267700 : n = r_long(p);
1476 94267700 : if (n < 0 || n >= PyList_GET_SIZE(p->refs)) {
1477 2 : if (n == -1 && PyErr_Occurred())
1478 2 : break;
1479 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (invalid reference)");
1480 0 : break;
1481 : }
1482 94267700 : v = PyList_GET_ITEM(p->refs, n);
1483 94267700 : if (v == Py_None) {
1484 0 : PyErr_SetString(PyExc_ValueError, "bad marshal data (invalid reference)");
1485 0 : break;
1486 : }
1487 94267700 : Py_INCREF(v);
1488 94267700 : retval = v;
1489 94267700 : break;
1490 :
1491 200 : default:
1492 : /* Bogus data got written, which isn't ideal.
1493 : This will let you keep working and recover. */
1494 200 : PyErr_SetString(PyExc_ValueError, "bad marshal data (unknown type code)");
1495 200 : break;
1496 :
1497 : }
1498 210347000 : p->depth--;
1499 210347000 : return retval;
1500 : }
1501 :
1502 : static PyObject *
1503 207821 : read_object(RFILE *p)
1504 : {
1505 : PyObject *v;
1506 207821 : if (PyErr_Occurred()) {
1507 0 : fprintf(stderr, "XXX readobject called with exception set\n");
1508 0 : return NULL;
1509 : }
1510 207821 : if (p->ptr && p->end) {
1511 206785 : if (PySys_Audit("marshal.loads", "y#", p->ptr, (Py_ssize_t)(p->end - p->ptr)) < 0) {
1512 0 : return NULL;
1513 : }
1514 1036 : } else if (p->fp || p->readable) {
1515 1036 : if (PySys_Audit("marshal.load", NULL) < 0) {
1516 0 : return NULL;
1517 : }
1518 : }
1519 207821 : v = r_object(p);
1520 207821 : if (v == NULL && !PyErr_Occurred())
1521 3 : PyErr_SetString(PyExc_TypeError, "NULL object in marshal data for object");
1522 207821 : return v;
1523 : }
1524 :
1525 : int
1526 2 : PyMarshal_ReadShortFromFile(FILE *fp)
1527 : {
1528 : RFILE rf;
1529 : int res;
1530 2 : assert(fp);
1531 2 : rf.readable = NULL;
1532 2 : rf.fp = fp;
1533 2 : rf.end = rf.ptr = NULL;
1534 2 : rf.buf = NULL;
1535 2 : res = r_short(&rf);
1536 2 : if (rf.buf != NULL)
1537 2 : PyMem_Free(rf.buf);
1538 2 : return res;
1539 : }
1540 :
1541 : long
1542 114 : PyMarshal_ReadLongFromFile(FILE *fp)
1543 : {
1544 : RFILE rf;
1545 : long res;
1546 114 : rf.fp = fp;
1547 114 : rf.readable = NULL;
1548 114 : rf.ptr = rf.end = NULL;
1549 114 : rf.buf = NULL;
1550 114 : res = r_long(&rf);
1551 114 : if (rf.buf != NULL)
1552 114 : PyMem_Free(rf.buf);
1553 114 : return res;
1554 : }
1555 :
1556 : /* Return size of file in bytes; < 0 if unknown or INT_MAX if too big */
1557 : static off_t
1558 38 : getfilesize(FILE *fp)
1559 : {
1560 : struct _Py_stat_struct st;
1561 38 : if (_Py_fstat_noraise(fileno(fp), &st) != 0)
1562 0 : return -1;
1563 : #if SIZEOF_OFF_T == 4
1564 : else if (st.st_size >= INT_MAX)
1565 : return (off_t)INT_MAX;
1566 : #endif
1567 : else
1568 38 : return (off_t)st.st_size;
1569 : }
1570 :
1571 : /* If we can get the size of the file up-front, and it's reasonably small,
1572 : * read it in one gulp and delegate to ...FromString() instead. Much quicker
1573 : * than reading a byte at a time from file; speeds .pyc imports.
1574 : * CAUTION: since this may read the entire remainder of the file, don't
1575 : * call it unless you know you're done with the file.
1576 : */
1577 : PyObject *
1578 38 : PyMarshal_ReadLastObjectFromFile(FILE *fp)
1579 : {
1580 : /* REASONABLE_FILE_LIMIT is by defn something big enough for Tkinter.pyc. */
1581 : #define REASONABLE_FILE_LIMIT (1L << 18)
1582 : off_t filesize;
1583 38 : filesize = getfilesize(fp);
1584 38 : if (filesize > 0 && filesize <= REASONABLE_FILE_LIMIT) {
1585 38 : char* pBuf = (char *)PyMem_Malloc(filesize);
1586 38 : if (pBuf != NULL) {
1587 38 : size_t n = fread(pBuf, 1, (size_t)filesize, fp);
1588 38 : PyObject* v = PyMarshal_ReadObjectFromString(pBuf, n);
1589 38 : PyMem_Free(pBuf);
1590 38 : return v;
1591 : }
1592 :
1593 : }
1594 : /* We don't have fstat, or we do but the file is larger than
1595 : * REASONABLE_FILE_LIMIT or malloc failed -- read a byte at a time.
1596 : */
1597 0 : return PyMarshal_ReadObjectFromFile(fp);
1598 :
1599 : #undef REASONABLE_FILE_LIMIT
1600 : }
1601 :
1602 : PyObject *
1603 10 : PyMarshal_ReadObjectFromFile(FILE *fp)
1604 : {
1605 : RFILE rf;
1606 : PyObject *result;
1607 10 : rf.fp = fp;
1608 10 : rf.readable = NULL;
1609 10 : rf.depth = 0;
1610 10 : rf.ptr = rf.end = NULL;
1611 10 : rf.buf = NULL;
1612 10 : rf.refs = PyList_New(0);
1613 10 : if (rf.refs == NULL)
1614 0 : return NULL;
1615 10 : result = read_object(&rf);
1616 10 : Py_DECREF(rf.refs);
1617 10 : if (rf.buf != NULL)
1618 9 : PyMem_Free(rf.buf);
1619 10 : return result;
1620 : }
1621 :
1622 : PyObject *
1623 3253 : PyMarshal_ReadObjectFromString(const char *str, Py_ssize_t len)
1624 : {
1625 : RFILE rf;
1626 : PyObject *result;
1627 3253 : rf.fp = NULL;
1628 3253 : rf.readable = NULL;
1629 3253 : rf.ptr = str;
1630 3253 : rf.end = str + len;
1631 3253 : rf.buf = NULL;
1632 3253 : rf.depth = 0;
1633 3253 : rf.refs = PyList_New(0);
1634 3253 : if (rf.refs == NULL)
1635 0 : return NULL;
1636 3253 : result = read_object(&rf);
1637 3253 : Py_DECREF(rf.refs);
1638 3253 : if (rf.buf != NULL)
1639 0 : PyMem_Free(rf.buf);
1640 3253 : return result;
1641 : }
1642 :
1643 : PyObject *
1644 15581 : PyMarshal_WriteObjectToString(PyObject *x, int version)
1645 : {
1646 : WFILE wf;
1647 :
1648 15581 : if (PySys_Audit("marshal.dumps", "Oi", x, version) < 0) {
1649 0 : return NULL;
1650 : }
1651 15581 : memset(&wf, 0, sizeof(wf));
1652 15581 : wf.str = PyBytes_FromStringAndSize((char *)NULL, 50);
1653 15581 : if (wf.str == NULL)
1654 0 : return NULL;
1655 15581 : wf.ptr = wf.buf = PyBytes_AS_STRING(wf.str);
1656 15581 : wf.end = wf.ptr + PyBytes_GET_SIZE(wf.str);
1657 15581 : wf.error = WFERR_OK;
1658 15581 : wf.version = version;
1659 15581 : if (w_init_refs(&wf, version)) {
1660 0 : Py_DECREF(wf.str);
1661 0 : return NULL;
1662 : }
1663 15581 : w_object(x, &wf);
1664 15581 : w_clear_refs(&wf);
1665 15581 : if (wf.str != NULL) {
1666 15581 : const char *base = PyBytes_AS_STRING(wf.str);
1667 15581 : if (_PyBytes_Resize(&wf.str, (Py_ssize_t)(wf.ptr - base)) < 0)
1668 0 : return NULL;
1669 : }
1670 15581 : if (wf.error != WFERR_OK) {
1671 9 : Py_XDECREF(wf.str);
1672 9 : if (wf.error == WFERR_NOMEMORY)
1673 0 : PyErr_NoMemory();
1674 : else
1675 9 : PyErr_SetString(PyExc_ValueError,
1676 9 : (wf.error==WFERR_UNMARSHALLABLE)?"unmarshallable object"
1677 : :"object too deeply nested to marshal");
1678 9 : return NULL;
1679 : }
1680 15572 : return wf.str;
1681 : }
1682 :
1683 : /* And an interface for Python programs... */
1684 : /*[clinic input]
1685 : marshal.dump
1686 :
1687 : value: object
1688 : Must be a supported type.
1689 : file: object
1690 : Must be a writeable binary file.
1691 : version: int(c_default="Py_MARSHAL_VERSION") = version
1692 : Indicates the data format that dump should use.
1693 : /
1694 :
1695 : Write the value on the open file.
1696 :
1697 : If the value has (or contains an object that has) an unsupported type, a
1698 : ValueError exception is raised - but garbage data will also be written
1699 : to the file. The object will not be properly read back by load().
1700 : [clinic start generated code]*/
1701 :
1702 : static PyObject *
1703 1003 : marshal_dump_impl(PyObject *module, PyObject *value, PyObject *file,
1704 : int version)
1705 : /*[clinic end generated code: output=aaee62c7028a7cb2 input=6c7a3c23c6fef556]*/
1706 : {
1707 : /* XXX Quick hack -- need to do this differently */
1708 : PyObject *s;
1709 : PyObject *res;
1710 :
1711 1003 : s = PyMarshal_WriteObjectToString(value, version);
1712 1003 : if (s == NULL)
1713 0 : return NULL;
1714 1003 : res = _PyObject_CallMethodOneArg(file, &_Py_ID(write), s);
1715 1003 : Py_DECREF(s);
1716 1003 : return res;
1717 : }
1718 :
1719 : /*[clinic input]
1720 : marshal.load
1721 :
1722 : file: object
1723 : Must be readable binary file.
1724 : /
1725 :
1726 : Read one value from the open file and return it.
1727 :
1728 : If no valid value is read (e.g. because the data has a different Python
1729 : version's incompatible marshal format), raise EOFError, ValueError or
1730 : TypeError.
1731 :
1732 : Note: If an object containing an unsupported type was marshalled with
1733 : dump(), load() will substitute None for the unmarshallable type.
1734 : [clinic start generated code]*/
1735 :
1736 : static PyObject *
1737 1026 : marshal_load(PyObject *module, PyObject *file)
1738 : /*[clinic end generated code: output=f8e5c33233566344 input=c85c2b594cd8124a]*/
1739 : {
1740 : PyObject *data, *result;
1741 : RFILE rf;
1742 :
1743 : /*
1744 : * Make a call to the read method, but read zero bytes.
1745 : * This is to ensure that the object passed in at least
1746 : * has a read method which returns bytes.
1747 : * This can be removed if we guarantee good error handling
1748 : * for r_string()
1749 : */
1750 1026 : data = _PyObject_CallMethod(file, &_Py_ID(read), "i", 0);
1751 1026 : if (data == NULL)
1752 0 : return NULL;
1753 1026 : if (!PyBytes_Check(data)) {
1754 0 : PyErr_Format(PyExc_TypeError,
1755 : "file.read() returned not bytes but %.100s",
1756 0 : Py_TYPE(data)->tp_name);
1757 0 : result = NULL;
1758 : }
1759 : else {
1760 1026 : rf.depth = 0;
1761 1026 : rf.fp = NULL;
1762 1026 : rf.readable = file;
1763 1026 : rf.ptr = rf.end = NULL;
1764 1026 : rf.buf = NULL;
1765 1026 : if ((rf.refs = PyList_New(0)) != NULL) {
1766 1026 : result = read_object(&rf);
1767 1026 : Py_DECREF(rf.refs);
1768 1026 : if (rf.buf != NULL)
1769 1026 : PyMem_Free(rf.buf);
1770 : } else
1771 0 : result = NULL;
1772 : }
1773 1026 : Py_DECREF(data);
1774 1026 : return result;
1775 : }
1776 :
1777 : /*[clinic input]
1778 : marshal.dumps
1779 :
1780 : value: object
1781 : Must be a supported type.
1782 : version: int(c_default="Py_MARSHAL_VERSION") = version
1783 : Indicates the data format that dumps should use.
1784 : /
1785 :
1786 : Return the bytes object that would be written to a file by dump(value, file).
1787 :
1788 : Raise a ValueError exception if value has (or contains an object that has) an
1789 : unsupported type.
1790 : [clinic start generated code]*/
1791 :
1792 : static PyObject *
1793 8735 : marshal_dumps_impl(PyObject *module, PyObject *value, int version)
1794 : /*[clinic end generated code: output=9c200f98d7256cad input=a2139ea8608e9b27]*/
1795 : {
1796 8735 : return PyMarshal_WriteObjectToString(value, version);
1797 : }
1798 :
1799 : /*[clinic input]
1800 : marshal.loads
1801 :
1802 : bytes: Py_buffer
1803 : /
1804 :
1805 : Convert the bytes-like object to a value.
1806 :
1807 : If no valid value is found, raise EOFError, ValueError or TypeError. Extra
1808 : bytes in the input are ignored.
1809 : [clinic start generated code]*/
1810 :
1811 : static PyObject *
1812 203532 : marshal_loads_impl(PyObject *module, Py_buffer *bytes)
1813 : /*[clinic end generated code: output=9fc65985c93d1bb1 input=6f426518459c8495]*/
1814 : {
1815 : RFILE rf;
1816 203532 : char *s = bytes->buf;
1817 203532 : Py_ssize_t n = bytes->len;
1818 : PyObject* result;
1819 203532 : rf.fp = NULL;
1820 203532 : rf.readable = NULL;
1821 203532 : rf.ptr = s;
1822 203532 : rf.end = s + n;
1823 203532 : rf.depth = 0;
1824 203532 : if ((rf.refs = PyList_New(0)) == NULL)
1825 0 : return NULL;
1826 203532 : result = read_object(&rf);
1827 203532 : Py_DECREF(rf.refs);
1828 203532 : return result;
1829 : }
1830 :
1831 : static PyMethodDef marshal_methods[] = {
1832 : MARSHAL_DUMP_METHODDEF
1833 : MARSHAL_LOAD_METHODDEF
1834 : MARSHAL_DUMPS_METHODDEF
1835 : MARSHAL_LOADS_METHODDEF
1836 : {NULL, NULL} /* sentinel */
1837 : };
1838 :
1839 :
1840 : PyDoc_STRVAR(module_doc,
1841 : "This module contains functions that can read and write Python values in\n\
1842 : a binary format. The format is specific to Python, but independent of\n\
1843 : machine architecture issues.\n\
1844 : \n\
1845 : Not all Python object types are supported; in general, only objects\n\
1846 : whose value is independent from a particular invocation of Python can be\n\
1847 : written and read by this module. The following types are supported:\n\
1848 : None, integers, floating point numbers, strings, bytes, bytearrays,\n\
1849 : tuples, lists, sets, dictionaries, and code objects, where it\n\
1850 : should be understood that tuples, lists and dictionaries are only\n\
1851 : supported as long as the values contained therein are themselves\n\
1852 : supported; and recursive lists and dictionaries should not be written\n\
1853 : (they will cause infinite loops).\n\
1854 : \n\
1855 : Variables:\n\
1856 : \n\
1857 : version -- indicates the format that the module uses. Version 0 is the\n\
1858 : historical format, version 1 shares interned strings and version 2\n\
1859 : uses a binary format for floating point numbers.\n\
1860 : Version 3 shares common object references (New in version 3.4).\n\
1861 : \n\
1862 : Functions:\n\
1863 : \n\
1864 : dump() -- write value to a file\n\
1865 : load() -- read value from a file\n\
1866 : dumps() -- marshal value as a bytes object\n\
1867 : loads() -- read value from a bytes-like object");
1868 :
1869 :
1870 : static int
1871 3133 : marshal_module_exec(PyObject *mod)
1872 : {
1873 3133 : if (PyModule_AddIntConstant(mod, "version", Py_MARSHAL_VERSION) < 0) {
1874 0 : return -1;
1875 : }
1876 3133 : return 0;
1877 : }
1878 :
1879 : static PyModuleDef_Slot marshalmodule_slots[] = {
1880 : {Py_mod_exec, marshal_module_exec},
1881 : {0, NULL}
1882 : };
1883 :
1884 : static struct PyModuleDef marshalmodule = {
1885 : PyModuleDef_HEAD_INIT,
1886 : .m_name = "marshal",
1887 : .m_doc = module_doc,
1888 : .m_methods = marshal_methods,
1889 : .m_slots = marshalmodule_slots,
1890 : };
1891 :
1892 : PyMODINIT_FUNC
1893 3133 : PyMarshal_Init(void)
1894 : {
1895 3133 : return PyModuleDef_Init(&marshalmodule);
1896 : }
|
