]>
Commit | Line | Data |
---|---|---|
41b152c5 | 1 | /** @file\r |
2 | Write Python objects to files and read them back.\r | |
3 | This is intended for writing and reading compiled Python code only;\r | |
4 | a true persistent storage facility would be much harder, since\r | |
5 | it would have to take circular links and sharing into account.\r | |
6c0ebd5f | 6 | \r |
41b152c5 | 7 | Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r |
8 | This program and the accompanying materials are licensed and made available under\r | |
9 | the terms and conditions of the BSD License that accompanies this distribution.\r | |
10 | The full text of the license may be found at\r | |
11 | http://opensource.org/licenses/bsd-license.\r | |
12 | \r | |
13 | THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r | |
14 | WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r | |
15 | **/\r | |
6c0ebd5f | 16 | \r |
17 | #define PY_SSIZE_T_CLEAN\r | |
18 | \r | |
19 | #include "Python.h"\r | |
20 | #include "longintrepr.h"\r | |
21 | #include "code.h"\r | |
22 | #include "marshal.h"\r | |
23 | \r | |
24 | #ifndef ABS\r | |
25 | #define ABS(x) ((x) < 0 ? -(x) : (x))\r | |
26 | #endif\r | |
27 | \r | |
28 | /* High water mark to determine when the marshalled object is dangerously deep\r | |
29 | * and risks coring the interpreter. When the object stack gets this deep,\r | |
30 | * raise an exception instead of continuing.\r | |
31 | */\r | |
32 | #define MAX_MARSHAL_STACK_DEPTH 2000\r | |
33 | \r | |
34 | #define TYPE_NULL '0'\r | |
35 | #define TYPE_NONE 'N'\r | |
36 | #define TYPE_FALSE 'F'\r | |
37 | #define TYPE_TRUE 'T'\r | |
38 | #define TYPE_STOPITER 'S'\r | |
39 | #define TYPE_ELLIPSIS '.'\r | |
40 | #define TYPE_INT 'i'\r | |
41 | #define TYPE_INT64 'I'\r | |
42 | #define TYPE_FLOAT 'f'\r | |
43 | #define TYPE_BINARY_FLOAT 'g'\r | |
44 | #define TYPE_COMPLEX 'x'\r | |
45 | #define TYPE_BINARY_COMPLEX 'y'\r | |
46 | #define TYPE_LONG 'l'\r | |
47 | #define TYPE_STRING 's'\r | |
48 | #define TYPE_INTERNED 't'\r | |
49 | #define TYPE_STRINGREF 'R'\r | |
50 | #define TYPE_TUPLE '('\r | |
51 | #define TYPE_LIST '['\r | |
52 | #define TYPE_DICT '{'\r | |
53 | #define TYPE_CODE 'c'\r | |
54 | #define TYPE_UNICODE 'u'\r | |
55 | #define TYPE_UNKNOWN '?'\r | |
56 | #define TYPE_SET '<'\r | |
57 | #define TYPE_FROZENSET '>'\r | |
58 | \r | |
59 | #define WFERR_OK 0\r | |
60 | #define WFERR_UNMARSHALLABLE 1\r | |
61 | #define WFERR_NESTEDTOODEEP 2\r | |
62 | #define WFERR_NOMEMORY 3\r | |
63 | \r | |
64 | typedef struct {\r | |
65 | FILE *fp;\r | |
66 | int error; /* see WFERR_* values */\r | |
67 | int depth;\r | |
68 | /* If fp == NULL, the following are valid: */\r | |
69 | PyObject *str;\r | |
70 | char *ptr;\r | |
71 | char *end;\r | |
72 | PyObject *strings; /* dict on marshal, list on unmarshal */\r | |
73 | int version;\r | |
74 | } WFILE;\r | |
75 | \r | |
76 | #define w_byte(c, p) if (((p)->fp)) putc((c), (p)->fp); \\r | |
77 | else if ((p)->ptr != (p)->end) *(p)->ptr++ = (c); \\r | |
78 | else w_more(c, p)\r | |
79 | \r | |
80 | static void\r | |
81 | w_more(int c, WFILE *p)\r | |
82 | {\r | |
83 | Py_ssize_t size, newsize;\r | |
84 | if (p->str == NULL)\r | |
85 | return; /* An error already occurred */\r | |
86 | size = PyString_Size(p->str);\r | |
87 | newsize = size + size + 1024;\r | |
88 | if (newsize > 32*1024*1024) {\r | |
89 | newsize = size + (size >> 3); /* 12.5% overallocation */\r | |
90 | }\r | |
91 | if (_PyString_Resize(&p->str, newsize) != 0) {\r | |
92 | p->ptr = p->end = NULL;\r | |
93 | }\r | |
94 | else {\r | |
95 | p->ptr = PyString_AS_STRING((PyStringObject *)p->str) + size;\r | |
96 | p->end =\r | |
97 | PyString_AS_STRING((PyStringObject *)p->str) + newsize;\r | |
98 | *p->ptr++ = Py_SAFE_DOWNCAST(c, int, char);\r | |
99 | }\r | |
100 | }\r | |
101 | \r | |
102 | static void\r | |
103 | w_string(char *s, int n, WFILE *p)\r | |
104 | {\r | |
105 | if (p->fp != NULL) {\r | |
106 | fwrite(s, 1, n, p->fp);\r | |
107 | }\r | |
108 | else {\r | |
109 | while (--n >= 0) {\r | |
110 | w_byte(*s, p);\r | |
111 | s++;\r | |
112 | }\r | |
113 | }\r | |
114 | }\r | |
115 | \r | |
116 | static void\r | |
117 | w_short(int x, WFILE *p)\r | |
118 | {\r | |
119 | w_byte((char)( x & 0xff), p);\r | |
120 | w_byte((char)((x>> 8) & 0xff), p);\r | |
121 | }\r | |
122 | \r | |
123 | static void\r | |
124 | w_long(long x, WFILE *p)\r | |
125 | {\r | |
126 | w_byte((char)( x & 0xff), p);\r | |
127 | w_byte((char)((x>> 8) & 0xff), p);\r | |
128 | w_byte((char)((x>>16) & 0xff), p);\r | |
129 | w_byte((char)((x>>24) & 0xff), p);\r | |
130 | }\r | |
131 | \r | |
132 | #if SIZEOF_LONG > 4\r | |
133 | static void\r | |
134 | w_long64(long x, WFILE *p)\r | |
135 | {\r | |
136 | w_long(x, p);\r | |
137 | w_long(x>>32, p);\r | |
138 | }\r | |
139 | #endif\r | |
140 | \r | |
141 | /* We assume that Python longs are stored internally in base some power of\r | |
142 | 2**15; for the sake of portability we'll always read and write them in base\r | |
143 | exactly 2**15. */\r | |
144 | \r | |
145 | #define PyLong_MARSHAL_SHIFT 15\r | |
146 | #define PyLong_MARSHAL_BASE ((short)1 << PyLong_MARSHAL_SHIFT)\r | |
147 | #define PyLong_MARSHAL_MASK (PyLong_MARSHAL_BASE - 1)\r | |
148 | #if PyLong_SHIFT % PyLong_MARSHAL_SHIFT != 0\r | |
149 | #error "PyLong_SHIFT must be a multiple of PyLong_MARSHAL_SHIFT"\r | |
150 | #endif\r | |
151 | #define PyLong_MARSHAL_RATIO (PyLong_SHIFT / PyLong_MARSHAL_SHIFT)\r | |
152 | \r | |
153 | static void\r | |
154 | w_PyLong(const PyLongObject *ob, WFILE *p)\r | |
155 | {\r | |
156 | Py_ssize_t i, j, n, l;\r | |
157 | digit d;\r | |
158 | \r | |
159 | w_byte(TYPE_LONG, p);\r | |
160 | if (Py_SIZE(ob) == 0) {\r | |
161 | w_long((long)0, p);\r | |
162 | return;\r | |
163 | }\r | |
164 | \r | |
165 | /* set l to number of base PyLong_MARSHAL_BASE digits */\r | |
166 | n = ABS(Py_SIZE(ob));\r | |
167 | l = (n-1) * PyLong_MARSHAL_RATIO;\r | |
168 | d = ob->ob_digit[n-1];\r | |
169 | assert(d != 0); /* a PyLong is always normalized */\r | |
170 | do {\r | |
171 | d >>= PyLong_MARSHAL_SHIFT;\r | |
172 | l++;\r | |
173 | } while (d != 0);\r | |
174 | w_long((long)(Py_SIZE(ob) > 0 ? l : -l), p);\r | |
175 | \r | |
176 | for (i=0; i < n-1; i++) {\r | |
177 | d = ob->ob_digit[i];\r | |
178 | for (j=0; j < PyLong_MARSHAL_RATIO; j++) {\r | |
179 | w_short(d & PyLong_MARSHAL_MASK, p);\r | |
180 | d >>= PyLong_MARSHAL_SHIFT;\r | |
181 | }\r | |
182 | assert (d == 0);\r | |
183 | }\r | |
184 | d = ob->ob_digit[n-1];\r | |
185 | do {\r | |
186 | w_short(d & PyLong_MARSHAL_MASK, p);\r | |
187 | d >>= PyLong_MARSHAL_SHIFT;\r | |
188 | } while (d != 0);\r | |
189 | }\r | |
190 | \r | |
191 | static void\r | |
192 | w_object(PyObject *v, WFILE *p)\r | |
193 | {\r | |
194 | Py_ssize_t i, n;\r | |
195 | \r | |
196 | p->depth++;\r | |
197 | \r | |
198 | if (p->depth > MAX_MARSHAL_STACK_DEPTH) {\r | |
199 | p->error = WFERR_NESTEDTOODEEP;\r | |
200 | }\r | |
201 | else if (v == NULL) {\r | |
202 | w_byte(TYPE_NULL, p);\r | |
203 | }\r | |
204 | else if (v == Py_None) {\r | |
205 | w_byte(TYPE_NONE, p);\r | |
206 | }\r | |
207 | else if (v == PyExc_StopIteration) {\r | |
208 | w_byte(TYPE_STOPITER, p);\r | |
209 | }\r | |
210 | else if (v == Py_Ellipsis) {\r | |
211 | w_byte(TYPE_ELLIPSIS, p);\r | |
212 | }\r | |
213 | else if (v == Py_False) {\r | |
214 | w_byte(TYPE_FALSE, p);\r | |
215 | }\r | |
216 | else if (v == Py_True) {\r | |
217 | w_byte(TYPE_TRUE, p);\r | |
218 | }\r | |
219 | else if (PyInt_CheckExact(v)) {\r | |
220 | long x = PyInt_AS_LONG((PyIntObject *)v);\r | |
221 | #if SIZEOF_LONG > 4\r | |
222 | long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);\r | |
223 | if (y && y != -1) {\r | |
224 | w_byte(TYPE_INT64, p);\r | |
225 | w_long64(x, p);\r | |
226 | }\r | |
227 | else\r | |
228 | #endif\r | |
229 | {\r | |
230 | w_byte(TYPE_INT, p);\r | |
231 | w_long(x, p);\r | |
232 | }\r | |
233 | }\r | |
234 | else if (PyLong_CheckExact(v)) {\r | |
235 | PyLongObject *ob = (PyLongObject *)v;\r | |
236 | w_PyLong(ob, p);\r | |
237 | }\r | |
238 | else if (PyFloat_CheckExact(v)) {\r | |
239 | if (p->version > 1) {\r | |
240 | unsigned char buf[8];\r | |
241 | if (_PyFloat_Pack8(PyFloat_AsDouble(v),\r | |
242 | buf, 1) < 0) {\r | |
243 | p->error = WFERR_UNMARSHALLABLE;\r | |
244 | return;\r | |
245 | }\r | |
246 | w_byte(TYPE_BINARY_FLOAT, p);\r | |
247 | w_string((char*)buf, 8, p);\r | |
248 | }\r | |
249 | else {\r | |
250 | char *buf = PyOS_double_to_string(PyFloat_AS_DOUBLE(v),\r | |
251 | 'g', 17, 0, NULL);\r | |
252 | if (!buf) {\r | |
253 | p->error = WFERR_NOMEMORY;\r | |
254 | return;\r | |
255 | }\r | |
256 | n = strlen(buf);\r | |
257 | w_byte(TYPE_FLOAT, p);\r | |
258 | w_byte((int)n, p);\r | |
259 | w_string(buf, (int)n, p);\r | |
260 | PyMem_Free(buf);\r | |
261 | }\r | |
262 | }\r | |
263 | #ifndef WITHOUT_COMPLEX\r | |
264 | else if (PyComplex_CheckExact(v)) {\r | |
265 | if (p->version > 1) {\r | |
266 | unsigned char buf[8];\r | |
267 | if (_PyFloat_Pack8(PyComplex_RealAsDouble(v),\r | |
268 | buf, 1) < 0) {\r | |
269 | p->error = WFERR_UNMARSHALLABLE;\r | |
270 | return;\r | |
271 | }\r | |
272 | w_byte(TYPE_BINARY_COMPLEX, p);\r | |
273 | w_string((char*)buf, 8, p);\r | |
274 | if (_PyFloat_Pack8(PyComplex_ImagAsDouble(v),\r | |
275 | buf, 1) < 0) {\r | |
276 | p->error = WFERR_UNMARSHALLABLE;\r | |
277 | return;\r | |
278 | }\r | |
279 | w_string((char*)buf, 8, p);\r | |
280 | }\r | |
281 | else {\r | |
282 | char *buf;\r | |
283 | w_byte(TYPE_COMPLEX, p);\r | |
284 | buf = PyOS_double_to_string(PyComplex_RealAsDouble(v),\r | |
285 | 'g', 17, 0, NULL);\r | |
286 | if (!buf) {\r | |
287 | p->error = WFERR_NOMEMORY;\r | |
288 | return;\r | |
289 | }\r | |
290 | n = strlen(buf);\r | |
291 | w_byte((int)n, p);\r | |
292 | w_string(buf, (int)n, p);\r | |
293 | PyMem_Free(buf);\r | |
294 | buf = PyOS_double_to_string(PyComplex_ImagAsDouble(v),\r | |
295 | 'g', 17, 0, NULL);\r | |
296 | if (!buf) {\r | |
297 | p->error = WFERR_NOMEMORY;\r | |
298 | return;\r | |
299 | }\r | |
300 | n = strlen(buf);\r | |
301 | w_byte((int)n, p);\r | |
302 | w_string(buf, (int)n, p);\r | |
303 | PyMem_Free(buf);\r | |
304 | }\r | |
305 | }\r | |
306 | #endif\r | |
307 | else if (PyString_CheckExact(v)) {\r | |
308 | if (p->strings && PyString_CHECK_INTERNED(v)) {\r | |
309 | PyObject *o = PyDict_GetItem(p->strings, v);\r | |
310 | if (o) {\r | |
311 | long w = PyInt_AsLong(o);\r | |
312 | w_byte(TYPE_STRINGREF, p);\r | |
313 | w_long(w, p);\r | |
314 | goto exit;\r | |
315 | }\r | |
316 | else {\r | |
317 | int ok;\r | |
318 | o = PyInt_FromSsize_t(PyDict_Size(p->strings));\r | |
319 | ok = o &&\r | |
320 | PyDict_SetItem(p->strings, v, o) >= 0;\r | |
321 | Py_XDECREF(o);\r | |
322 | if (!ok) {\r | |
323 | p->depth--;\r | |
324 | p->error = WFERR_UNMARSHALLABLE;\r | |
325 | return;\r | |
326 | }\r | |
327 | w_byte(TYPE_INTERNED, p);\r | |
328 | }\r | |
329 | }\r | |
330 | else {\r | |
331 | w_byte(TYPE_STRING, p);\r | |
332 | }\r | |
333 | n = PyString_GET_SIZE(v);\r | |
334 | if (n > INT_MAX) {\r | |
335 | /* huge strings are not supported */\r | |
336 | p->depth--;\r | |
337 | p->error = WFERR_UNMARSHALLABLE;\r | |
338 | return;\r | |
339 | }\r | |
340 | w_long((long)n, p);\r | |
341 | w_string(PyString_AS_STRING(v), (int)n, p);\r | |
342 | }\r | |
343 | #ifdef Py_USING_UNICODE\r | |
344 | else if (PyUnicode_CheckExact(v)) {\r | |
345 | PyObject *utf8;\r | |
346 | utf8 = PyUnicode_AsUTF8String(v);\r | |
347 | if (utf8 == NULL) {\r | |
348 | p->depth--;\r | |
349 | p->error = WFERR_UNMARSHALLABLE;\r | |
350 | return;\r | |
351 | }\r | |
352 | w_byte(TYPE_UNICODE, p);\r | |
353 | n = PyString_GET_SIZE(utf8);\r | |
354 | if (n > INT_MAX) {\r | |
355 | p->depth--;\r | |
356 | p->error = WFERR_UNMARSHALLABLE;\r | |
357 | return;\r | |
358 | }\r | |
359 | w_long((long)n, p);\r | |
360 | w_string(PyString_AS_STRING(utf8), (int)n, p);\r | |
361 | Py_DECREF(utf8);\r | |
362 | }\r | |
363 | #endif\r | |
364 | else if (PyTuple_CheckExact(v)) {\r | |
365 | w_byte(TYPE_TUPLE, p);\r | |
366 | n = PyTuple_Size(v);\r | |
367 | w_long((long)n, p);\r | |
368 | for (i = 0; i < n; i++) {\r | |
369 | w_object(PyTuple_GET_ITEM(v, i), p);\r | |
370 | }\r | |
371 | }\r | |
372 | else if (PyList_CheckExact(v)) {\r | |
373 | w_byte(TYPE_LIST, p);\r | |
374 | n = PyList_GET_SIZE(v);\r | |
375 | w_long((long)n, p);\r | |
376 | for (i = 0; i < n; i++) {\r | |
377 | w_object(PyList_GET_ITEM(v, i), p);\r | |
378 | }\r | |
379 | }\r | |
380 | else if (PyDict_CheckExact(v)) {\r | |
381 | Py_ssize_t pos;\r | |
382 | PyObject *key, *value;\r | |
383 | w_byte(TYPE_DICT, p);\r | |
384 | /* This one is NULL object terminated! */\r | |
385 | pos = 0;\r | |
386 | while (PyDict_Next(v, &pos, &key, &value)) {\r | |
387 | w_object(key, p);\r | |
388 | w_object(value, p);\r | |
389 | }\r | |
390 | w_object((PyObject *)NULL, p);\r | |
391 | }\r | |
392 | else if (PyAnySet_CheckExact(v)) {\r | |
393 | PyObject *value, *it;\r | |
394 | \r | |
395 | if (PyObject_TypeCheck(v, &PySet_Type))\r | |
396 | w_byte(TYPE_SET, p);\r | |
397 | else\r | |
398 | w_byte(TYPE_FROZENSET, p);\r | |
399 | n = PyObject_Size(v);\r | |
400 | if (n == -1) {\r | |
401 | p->depth--;\r | |
402 | p->error = WFERR_UNMARSHALLABLE;\r | |
403 | return;\r | |
404 | }\r | |
405 | w_long((long)n, p);\r | |
406 | it = PyObject_GetIter(v);\r | |
407 | if (it == NULL) {\r | |
408 | p->depth--;\r | |
409 | p->error = WFERR_UNMARSHALLABLE;\r | |
410 | return;\r | |
411 | }\r | |
412 | while ((value = PyIter_Next(it)) != NULL) {\r | |
413 | w_object(value, p);\r | |
414 | Py_DECREF(value);\r | |
415 | }\r | |
416 | Py_DECREF(it);\r | |
417 | if (PyErr_Occurred()) {\r | |
418 | p->depth--;\r | |
419 | p->error = WFERR_UNMARSHALLABLE;\r | |
420 | return;\r | |
421 | }\r | |
422 | }\r | |
423 | else if (PyCode_Check(v)) {\r | |
424 | PyCodeObject *co = (PyCodeObject *)v;\r | |
425 | w_byte(TYPE_CODE, p);\r | |
426 | w_long(co->co_argcount, p);\r | |
427 | w_long(co->co_nlocals, p);\r | |
428 | w_long(co->co_stacksize, p);\r | |
429 | w_long(co->co_flags, p);\r | |
430 | w_object(co->co_code, p);\r | |
431 | w_object(co->co_consts, p);\r | |
432 | w_object(co->co_names, p);\r | |
433 | w_object(co->co_varnames, p);\r | |
434 | w_object(co->co_freevars, p);\r | |
435 | w_object(co->co_cellvars, p);\r | |
436 | w_object(co->co_filename, p);\r | |
437 | w_object(co->co_name, p);\r | |
438 | w_long(co->co_firstlineno, p);\r | |
439 | w_object(co->co_lnotab, p);\r | |
440 | }\r | |
441 | else if (PyObject_CheckReadBuffer(v)) {\r | |
442 | /* Write unknown buffer-style objects as a string */\r | |
443 | char *s;\r | |
444 | PyBufferProcs *pb = v->ob_type->tp_as_buffer;\r | |
445 | w_byte(TYPE_STRING, p);\r | |
446 | n = (*pb->bf_getreadbuffer)(v, 0, (void **)&s);\r | |
447 | if (n > INT_MAX) {\r | |
448 | p->depth--;\r | |
449 | p->error = WFERR_UNMARSHALLABLE;\r | |
450 | return;\r | |
451 | }\r | |
452 | w_long((long)n, p);\r | |
453 | w_string(s, (int)n, p);\r | |
454 | }\r | |
455 | else {\r | |
456 | w_byte(TYPE_UNKNOWN, p);\r | |
457 | p->error = WFERR_UNMARSHALLABLE;\r | |
458 | }\r | |
459 | exit:\r | |
460 | p->depth--;\r | |
461 | }\r | |
462 | \r | |
463 | /* version currently has no effect for writing longs. */\r | |
464 | void\r | |
465 | PyMarshal_WriteLongToFile(long x, FILE *fp, int version)\r | |
466 | {\r | |
467 | WFILE wf;\r | |
468 | wf.fp = fp;\r | |
469 | wf.error = WFERR_OK;\r | |
470 | wf.depth = 0;\r | |
471 | wf.strings = NULL;\r | |
472 | wf.version = version;\r | |
473 | w_long(x, &wf);\r | |
474 | }\r | |
475 | \r | |
476 | void\r | |
477 | PyMarshal_WriteObjectToFile(PyObject *x, FILE *fp, int version)\r | |
478 | {\r | |
479 | WFILE wf;\r | |
480 | wf.fp = fp;\r | |
481 | wf.error = WFERR_OK;\r | |
482 | wf.depth = 0;\r | |
483 | wf.strings = (version > 0) ? PyDict_New() : NULL;\r | |
484 | wf.version = version;\r | |
485 | w_object(x, &wf);\r | |
486 | Py_XDECREF(wf.strings);\r | |
487 | }\r | |
488 | \r | |
489 | typedef WFILE RFILE; /* Same struct with different invariants */\r | |
490 | \r | |
491 | #define rs_byte(p) (((p)->ptr < (p)->end) ? (unsigned char)*(p)->ptr++ : EOF)\r | |
492 | \r | |
493 | #define r_byte(p) ((p)->fp ? getc((p)->fp) : rs_byte(p))\r | |
494 | \r | |
495 | static int\r | |
496 | r_string(char *s, int n, RFILE *p)\r | |
497 | {\r | |
498 | if (p->fp != NULL)\r | |
499 | /* The result fits into int because it must be <=n. */\r | |
500 | return (int)fread(s, 1, n, p->fp);\r | |
501 | if (p->end - p->ptr < n)\r | |
502 | n = (int)(p->end - p->ptr);\r | |
503 | memcpy(s, p->ptr, n);\r | |
504 | p->ptr += n;\r | |
505 | return n;\r | |
506 | }\r | |
507 | \r | |
508 | static int\r | |
509 | r_short(RFILE *p)\r | |
510 | {\r | |
511 | register short x;\r | |
512 | x = r_byte(p);\r | |
513 | x |= r_byte(p) << 8;\r | |
514 | /* Sign-extension, in case short greater than 16 bits */\r | |
515 | x |= -(x & 0x8000);\r | |
516 | return x;\r | |
517 | }\r | |
518 | \r | |
519 | static long\r | |
520 | r_long(RFILE *p)\r | |
521 | {\r | |
522 | register long x;\r | |
523 | register FILE *fp = p->fp;\r | |
524 | if (fp) {\r | |
525 | x = getc(fp);\r | |
526 | x |= (long)getc(fp) << 8;\r | |
527 | x |= (long)getc(fp) << 16;\r | |
528 | x |= (long)getc(fp) << 24;\r | |
529 | }\r | |
530 | else {\r | |
531 | x = rs_byte(p);\r | |
532 | x |= (long)rs_byte(p) << 8;\r | |
533 | x |= (long)rs_byte(p) << 16;\r | |
534 | x |= (long)rs_byte(p) << 24;\r | |
535 | }\r | |
536 | #if SIZEOF_LONG > 4\r | |
537 | /* Sign extension for 64-bit machines */\r | |
538 | x |= -(x & 0x80000000L);\r | |
539 | #endif\r | |
540 | return x;\r | |
541 | }\r | |
542 | \r | |
543 | /* r_long64 deals with the TYPE_INT64 code. On a machine with\r | |
544 | sizeof(long) > 4, it returns a Python int object, else a Python long\r | |
545 | object. Note that w_long64 writes out TYPE_INT if 32 bits is enough,\r | |
546 | so there's no inefficiency here in returning a PyLong on 32-bit boxes\r | |
547 | for everything written via TYPE_INT64 (i.e., if an int is written via\r | |
548 | TYPE_INT64, it *needs* more than 32 bits).\r | |
549 | */\r | |
550 | static PyObject *\r | |
551 | r_long64(RFILE *p)\r | |
552 | {\r | |
553 | long lo4 = r_long(p);\r | |
554 | long hi4 = r_long(p);\r | |
555 | #if SIZEOF_LONG > 4\r | |
556 | long x = (hi4 << 32) | (lo4 & 0xFFFFFFFFL);\r | |
557 | return PyInt_FromLong(x);\r | |
558 | #else\r | |
559 | unsigned char buf[8];\r | |
560 | int one = 1;\r | |
561 | int is_little_endian = (int)*(char*)&one;\r | |
562 | if (is_little_endian) {\r | |
563 | memcpy(buf, &lo4, 4);\r | |
564 | memcpy(buf+4, &hi4, 4);\r | |
565 | }\r | |
566 | else {\r | |
567 | memcpy(buf, &hi4, 4);\r | |
568 | memcpy(buf+4, &lo4, 4);\r | |
569 | }\r | |
570 | return _PyLong_FromByteArray(buf, 8, is_little_endian, 1);\r | |
571 | #endif\r | |
572 | }\r | |
573 | \r | |
574 | static PyObject *\r | |
575 | r_PyLong(RFILE *p)\r | |
576 | {\r | |
577 | PyLongObject *ob;\r | |
578 | int size, i, j, md, shorts_in_top_digit;\r | |
579 | long n;\r | |
580 | digit d;\r | |
581 | \r | |
582 | n = r_long(p);\r | |
583 | if (n == 0)\r | |
584 | return (PyObject *)_PyLong_New(0);\r | |
585 | if (n < -INT_MAX || n > INT_MAX) {\r | |
586 | PyErr_SetString(PyExc_ValueError,\r | |
587 | "bad marshal data (long size out of range)");\r | |
588 | return NULL;\r | |
589 | }\r | |
590 | \r | |
591 | size = 1 + (ABS(n) - 1) / PyLong_MARSHAL_RATIO;\r | |
592 | shorts_in_top_digit = 1 + (ABS(n) - 1) % PyLong_MARSHAL_RATIO;\r | |
593 | ob = _PyLong_New(size);\r | |
594 | if (ob == NULL)\r | |
595 | return NULL;\r | |
596 | Py_SIZE(ob) = n > 0 ? size : -size;\r | |
597 | \r | |
598 | for (i = 0; i < size-1; i++) {\r | |
599 | d = 0;\r | |
600 | for (j=0; j < PyLong_MARSHAL_RATIO; j++) {\r | |
601 | md = r_short(p);\r | |
602 | if (md < 0 || md > PyLong_MARSHAL_BASE)\r | |
603 | goto bad_digit;\r | |
604 | d += (digit)md << j*PyLong_MARSHAL_SHIFT;\r | |
605 | }\r | |
606 | ob->ob_digit[i] = d;\r | |
607 | }\r | |
608 | d = 0;\r | |
609 | for (j=0; j < shorts_in_top_digit; j++) {\r | |
610 | md = r_short(p);\r | |
611 | if (md < 0 || md > PyLong_MARSHAL_BASE)\r | |
612 | goto bad_digit;\r | |
613 | /* topmost marshal digit should be nonzero */\r | |
614 | if (md == 0 && j == shorts_in_top_digit - 1) {\r | |
615 | Py_DECREF(ob);\r | |
616 | PyErr_SetString(PyExc_ValueError,\r | |
617 | "bad marshal data (unnormalized long data)");\r | |
618 | return NULL;\r | |
619 | }\r | |
620 | d += (digit)md << j*PyLong_MARSHAL_SHIFT;\r | |
621 | }\r | |
622 | /* top digit should be nonzero, else the resulting PyLong won't be\r | |
623 | normalized */\r | |
624 | ob->ob_digit[size-1] = d;\r | |
625 | return (PyObject *)ob;\r | |
626 | bad_digit:\r | |
627 | Py_DECREF(ob);\r | |
628 | PyErr_SetString(PyExc_ValueError,\r | |
629 | "bad marshal data (digit out of range in long)");\r | |
630 | return NULL;\r | |
631 | }\r | |
632 | \r | |
633 | \r | |
634 | static PyObject *\r | |
635 | r_object(RFILE *p)\r | |
636 | {\r | |
637 | /* NULL is a valid return value, it does not necessarily means that\r | |
638 | an exception is set. */\r | |
639 | PyObject *v, *v2;\r | |
640 | long i, n;\r | |
641 | int type = r_byte(p);\r | |
642 | PyObject *retval;\r | |
643 | \r | |
644 | p->depth++;\r | |
645 | \r | |
646 | if (p->depth > MAX_MARSHAL_STACK_DEPTH) {\r | |
647 | p->depth--;\r | |
648 | PyErr_SetString(PyExc_ValueError, "recursion limit exceeded");\r | |
649 | return NULL;\r | |
650 | }\r | |
651 | \r | |
652 | switch (type) {\r | |
653 | \r | |
654 | case EOF:\r | |
655 | PyErr_SetString(PyExc_EOFError,\r | |
656 | "EOF read where object expected");\r | |
657 | retval = NULL;\r | |
658 | break;\r | |
659 | \r | |
660 | case TYPE_NULL:\r | |
661 | retval = NULL;\r | |
662 | break;\r | |
663 | \r | |
664 | case TYPE_NONE:\r | |
665 | Py_INCREF(Py_None);\r | |
666 | retval = Py_None;\r | |
667 | break;\r | |
668 | \r | |
669 | case TYPE_STOPITER:\r | |
670 | Py_INCREF(PyExc_StopIteration);\r | |
671 | retval = PyExc_StopIteration;\r | |
672 | break;\r | |
673 | \r | |
674 | case TYPE_ELLIPSIS:\r | |
675 | Py_INCREF(Py_Ellipsis);\r | |
676 | retval = Py_Ellipsis;\r | |
677 | break;\r | |
678 | \r | |
679 | case TYPE_FALSE:\r | |
680 | Py_INCREF(Py_False);\r | |
681 | retval = Py_False;\r | |
682 | break;\r | |
683 | \r | |
684 | case TYPE_TRUE:\r | |
685 | Py_INCREF(Py_True);\r | |
686 | retval = Py_True;\r | |
687 | break;\r | |
688 | \r | |
689 | case TYPE_INT:\r | |
690 | retval = PyInt_FromLong(r_long(p));\r | |
691 | break;\r | |
692 | \r | |
693 | case TYPE_INT64:\r | |
694 | retval = r_long64(p);\r | |
695 | break;\r | |
696 | \r | |
697 | case TYPE_LONG:\r | |
698 | retval = r_PyLong(p);\r | |
699 | break;\r | |
700 | \r | |
701 | case TYPE_FLOAT:\r | |
702 | {\r | |
703 | char buf[256];\r | |
704 | double dx;\r | |
705 | n = r_byte(p);\r | |
706 | if (n == EOF || r_string(buf, (int)n, p) != n) {\r | |
707 | PyErr_SetString(PyExc_EOFError,\r | |
708 | "EOF read where object expected");\r | |
709 | retval = NULL;\r | |
710 | break;\r | |
711 | }\r | |
712 | buf[n] = '\0';\r | |
713 | dx = PyOS_string_to_double(buf, NULL, NULL);\r | |
714 | if (dx == -1.0 && PyErr_Occurred()) {\r | |
715 | retval = NULL;\r | |
716 | break;\r | |
717 | }\r | |
718 | retval = PyFloat_FromDouble(dx);\r | |
719 | break;\r | |
720 | }\r | |
721 | \r | |
722 | case TYPE_BINARY_FLOAT:\r | |
723 | {\r | |
724 | unsigned char buf[8];\r | |
725 | double x;\r | |
726 | if (r_string((char*)buf, 8, p) != 8) {\r | |
727 | PyErr_SetString(PyExc_EOFError,\r | |
728 | "EOF read where object expected");\r | |
729 | retval = NULL;\r | |
730 | break;\r | |
731 | }\r | |
732 | x = _PyFloat_Unpack8(buf, 1);\r | |
733 | if (x == -1.0 && PyErr_Occurred()) {\r | |
734 | retval = NULL;\r | |
735 | break;\r | |
736 | }\r | |
737 | retval = PyFloat_FromDouble(x);\r | |
738 | break;\r | |
739 | }\r | |
740 | \r | |
741 | #ifndef WITHOUT_COMPLEX\r | |
742 | case TYPE_COMPLEX:\r | |
743 | {\r | |
744 | char buf[256];\r | |
745 | Py_complex c;\r | |
746 | n = r_byte(p);\r | |
747 | if (n == EOF || r_string(buf, (int)n, p) != n) {\r | |
748 | PyErr_SetString(PyExc_EOFError,\r | |
749 | "EOF read where object expected");\r | |
750 | retval = NULL;\r | |
751 | break;\r | |
752 | }\r | |
753 | buf[n] = '\0';\r | |
754 | c.real = PyOS_string_to_double(buf, NULL, NULL);\r | |
755 | if (c.real == -1.0 && PyErr_Occurred()) {\r | |
756 | retval = NULL;\r | |
757 | break;\r | |
758 | }\r | |
759 | n = r_byte(p);\r | |
760 | if (n == EOF || r_string(buf, (int)n, p) != n) {\r | |
761 | PyErr_SetString(PyExc_EOFError,\r | |
762 | "EOF read where object expected");\r | |
763 | retval = NULL;\r | |
764 | break;\r | |
765 | }\r | |
766 | buf[n] = '\0';\r | |
767 | c.imag = PyOS_string_to_double(buf, NULL, NULL);\r | |
768 | if (c.imag == -1.0 && PyErr_Occurred()) {\r | |
769 | retval = NULL;\r | |
770 | break;\r | |
771 | }\r | |
772 | retval = PyComplex_FromCComplex(c);\r | |
773 | break;\r | |
774 | }\r | |
775 | \r | |
776 | case TYPE_BINARY_COMPLEX:\r | |
777 | {\r | |
778 | unsigned char buf[8];\r | |
779 | Py_complex c;\r | |
780 | if (r_string((char*)buf, 8, p) != 8) {\r | |
781 | PyErr_SetString(PyExc_EOFError,\r | |
782 | "EOF read where object expected");\r | |
783 | retval = NULL;\r | |
784 | break;\r | |
785 | }\r | |
786 | c.real = _PyFloat_Unpack8(buf, 1);\r | |
787 | if (c.real == -1.0 && PyErr_Occurred()) {\r | |
788 | retval = NULL;\r | |
789 | break;\r | |
790 | }\r | |
791 | if (r_string((char*)buf, 8, p) != 8) {\r | |
792 | PyErr_SetString(PyExc_EOFError,\r | |
793 | "EOF read where object expected");\r | |
794 | retval = NULL;\r | |
795 | break;\r | |
796 | }\r | |
797 | c.imag = _PyFloat_Unpack8(buf, 1);\r | |
798 | if (c.imag == -1.0 && PyErr_Occurred()) {\r | |
799 | retval = NULL;\r | |
800 | break;\r | |
801 | }\r | |
802 | retval = PyComplex_FromCComplex(c);\r | |
803 | break;\r | |
804 | }\r | |
805 | #endif\r | |
806 | \r | |
807 | case TYPE_INTERNED:\r | |
808 | case TYPE_STRING:\r | |
809 | n = r_long(p);\r | |
810 | if (n < 0 || n > INT_MAX) {\r | |
811 | PyErr_SetString(PyExc_ValueError, "bad marshal data (string size out of range)");\r | |
812 | retval = NULL;\r | |
813 | break;\r | |
814 | }\r | |
815 | v = PyString_FromStringAndSize((char *)NULL, n);\r | |
816 | if (v == NULL) {\r | |
817 | retval = NULL;\r | |
818 | break;\r | |
819 | }\r | |
820 | if (r_string(PyString_AS_STRING(v), (int)n, p) != n) {\r | |
821 | Py_DECREF(v);\r | |
822 | PyErr_SetString(PyExc_EOFError,\r | |
823 | "EOF read where object expected");\r | |
824 | retval = NULL;\r | |
825 | break;\r | |
826 | }\r | |
827 | if (type == TYPE_INTERNED) {\r | |
828 | PyString_InternInPlace(&v);\r | |
829 | if (PyList_Append(p->strings, v) < 0) {\r | |
830 | retval = NULL;\r | |
831 | break;\r | |
832 | }\r | |
833 | }\r | |
834 | retval = v;\r | |
835 | break;\r | |
836 | \r | |
837 | case TYPE_STRINGREF:\r | |
838 | n = r_long(p);\r | |
839 | if (n < 0 || n >= PyList_GET_SIZE(p->strings)) {\r | |
840 | PyErr_SetString(PyExc_ValueError, "bad marshal data (string ref out of range)");\r | |
841 | retval = NULL;\r | |
842 | break;\r | |
843 | }\r | |
844 | v = PyList_GET_ITEM(p->strings, n);\r | |
845 | Py_INCREF(v);\r | |
846 | retval = v;\r | |
847 | break;\r | |
848 | \r | |
849 | #ifdef Py_USING_UNICODE\r | |
850 | case TYPE_UNICODE:\r | |
851 | {\r | |
852 | char *buffer;\r | |
853 | \r | |
854 | n = r_long(p);\r | |
855 | if (n < 0 || n > INT_MAX) {\r | |
856 | PyErr_SetString(PyExc_ValueError, "bad marshal data (unicode size out of range)");\r | |
857 | retval = NULL;\r | |
858 | break;\r | |
859 | }\r | |
860 | buffer = PyMem_NEW(char, n);\r | |
861 | if (buffer == NULL) {\r | |
862 | retval = PyErr_NoMemory();\r | |
863 | break;\r | |
864 | }\r | |
865 | if (r_string(buffer, (int)n, p) != n) {\r | |
866 | PyMem_DEL(buffer);\r | |
867 | PyErr_SetString(PyExc_EOFError,\r | |
868 | "EOF read where object expected");\r | |
869 | retval = NULL;\r | |
870 | break;\r | |
871 | }\r | |
872 | v = PyUnicode_DecodeUTF8(buffer, n, NULL);\r | |
873 | PyMem_DEL(buffer);\r | |
874 | retval = v;\r | |
875 | break;\r | |
876 | }\r | |
877 | #endif\r | |
878 | \r | |
879 | case TYPE_TUPLE:\r | |
880 | n = r_long(p);\r | |
881 | if (n < 0 || n > INT_MAX) {\r | |
882 | PyErr_SetString(PyExc_ValueError, "bad marshal data (tuple size out of range)");\r | |
883 | retval = NULL;\r | |
884 | break;\r | |
885 | }\r | |
886 | v = PyTuple_New((int)n);\r | |
887 | if (v == NULL) {\r | |
888 | retval = NULL;\r | |
889 | break;\r | |
890 | }\r | |
891 | for (i = 0; i < n; i++) {\r | |
892 | v2 = r_object(p);\r | |
893 | if ( v2 == NULL ) {\r | |
894 | if (!PyErr_Occurred())\r | |
895 | PyErr_SetString(PyExc_TypeError,\r | |
896 | "NULL object in marshal data for tuple");\r | |
897 | Py_DECREF(v);\r | |
898 | v = NULL;\r | |
899 | break;\r | |
900 | }\r | |
901 | PyTuple_SET_ITEM(v, (int)i, v2);\r | |
902 | }\r | |
903 | retval = v;\r | |
904 | break;\r | |
905 | \r | |
906 | case TYPE_LIST:\r | |
907 | n = r_long(p);\r | |
908 | if (n < 0 || n > INT_MAX) {\r | |
909 | PyErr_SetString(PyExc_ValueError, "bad marshal data (list size out of range)");\r | |
910 | retval = NULL;\r | |
911 | break;\r | |
912 | }\r | |
913 | v = PyList_New((int)n);\r | |
914 | if (v == NULL) {\r | |
915 | retval = NULL;\r | |
916 | break;\r | |
917 | }\r | |
918 | for (i = 0; i < n; i++) {\r | |
919 | v2 = r_object(p);\r | |
920 | if ( v2 == NULL ) {\r | |
921 | if (!PyErr_Occurred())\r | |
922 | PyErr_SetString(PyExc_TypeError,\r | |
923 | "NULL object in marshal data for list");\r | |
924 | Py_DECREF(v);\r | |
925 | v = NULL;\r | |
926 | break;\r | |
927 | }\r | |
928 | PyList_SET_ITEM(v, (int)i, v2);\r | |
929 | }\r | |
930 | retval = v;\r | |
931 | break;\r | |
932 | \r | |
933 | case TYPE_DICT:\r | |
934 | v = PyDict_New();\r | |
935 | if (v == NULL) {\r | |
936 | retval = NULL;\r | |
937 | break;\r | |
938 | }\r | |
939 | for (;;) {\r | |
940 | PyObject *key, *val;\r | |
941 | key = r_object(p);\r | |
942 | if (key == NULL)\r | |
943 | break;\r | |
944 | val = r_object(p);\r | |
945 | if (val != NULL)\r | |
946 | PyDict_SetItem(v, key, val);\r | |
947 | Py_DECREF(key);\r | |
948 | Py_XDECREF(val);\r | |
949 | }\r | |
950 | if (PyErr_Occurred()) {\r | |
951 | Py_DECREF(v);\r | |
952 | v = NULL;\r | |
953 | }\r | |
954 | retval = v;\r | |
955 | break;\r | |
956 | \r | |
957 | case TYPE_SET:\r | |
958 | case TYPE_FROZENSET:\r | |
959 | n = r_long(p);\r | |
960 | if (n < 0 || n > INT_MAX) {\r | |
961 | PyErr_SetString(PyExc_ValueError, "bad marshal data (set size out of range)");\r | |
962 | retval = NULL;\r | |
963 | break;\r | |
964 | }\r | |
965 | v = (type == TYPE_SET) ? PySet_New(NULL) : PyFrozenSet_New(NULL);\r | |
966 | if (v == NULL) {\r | |
967 | retval = NULL;\r | |
968 | break;\r | |
969 | }\r | |
970 | for (i = 0; i < n; i++) {\r | |
971 | v2 = r_object(p);\r | |
972 | if ( v2 == NULL ) {\r | |
973 | if (!PyErr_Occurred())\r | |
974 | PyErr_SetString(PyExc_TypeError,\r | |
975 | "NULL object in marshal data for set");\r | |
976 | Py_DECREF(v);\r | |
977 | v = NULL;\r | |
978 | break;\r | |
979 | }\r | |
980 | if (PySet_Add(v, v2) == -1) {\r | |
981 | Py_DECREF(v);\r | |
982 | Py_DECREF(v2);\r | |
983 | v = NULL;\r | |
984 | break;\r | |
985 | }\r | |
986 | Py_DECREF(v2);\r | |
987 | }\r | |
988 | retval = v;\r | |
989 | break;\r | |
990 | \r | |
991 | case TYPE_CODE:\r | |
992 | if (PyEval_GetRestricted()) {\r | |
993 | PyErr_SetString(PyExc_RuntimeError,\r | |
994 | "cannot unmarshal code objects in "\r | |
995 | "restricted execution mode");\r | |
996 | retval = NULL;\r | |
997 | break;\r | |
998 | }\r | |
999 | else {\r | |
1000 | int argcount;\r | |
1001 | int nlocals;\r | |
1002 | int stacksize;\r | |
1003 | int flags;\r | |
1004 | PyObject *code = NULL;\r | |
1005 | PyObject *consts = NULL;\r | |
1006 | PyObject *names = NULL;\r | |
1007 | PyObject *varnames = NULL;\r | |
1008 | PyObject *freevars = NULL;\r | |
1009 | PyObject *cellvars = NULL;\r | |
1010 | PyObject *filename = NULL;\r | |
1011 | PyObject *name = NULL;\r | |
1012 | int firstlineno;\r | |
1013 | PyObject *lnotab = NULL;\r | |
1014 | \r | |
1015 | v = NULL;\r | |
1016 | \r | |
1017 | /* XXX ignore long->int overflows for now */\r | |
1018 | argcount = (int)r_long(p);\r | |
1019 | nlocals = (int)r_long(p);\r | |
1020 | stacksize = (int)r_long(p);\r | |
1021 | flags = (int)r_long(p);\r | |
1022 | code = r_object(p);\r | |
1023 | if (code == NULL)\r | |
1024 | goto code_error;\r | |
1025 | consts = r_object(p);\r | |
1026 | if (consts == NULL)\r | |
1027 | goto code_error;\r | |
1028 | names = r_object(p);\r | |
1029 | if (names == NULL)\r | |
1030 | goto code_error;\r | |
1031 | varnames = r_object(p);\r | |
1032 | if (varnames == NULL)\r | |
1033 | goto code_error;\r | |
1034 | freevars = r_object(p);\r | |
1035 | if (freevars == NULL)\r | |
1036 | goto code_error;\r | |
1037 | cellvars = r_object(p);\r | |
1038 | if (cellvars == NULL)\r | |
1039 | goto code_error;\r | |
1040 | filename = r_object(p);\r | |
1041 | if (filename == NULL)\r | |
1042 | goto code_error;\r | |
1043 | name = r_object(p);\r | |
1044 | if (name == NULL)\r | |
1045 | goto code_error;\r | |
1046 | firstlineno = (int)r_long(p);\r | |
1047 | lnotab = r_object(p);\r | |
1048 | if (lnotab == NULL)\r | |
1049 | goto code_error;\r | |
1050 | \r | |
1051 | v = (PyObject *) PyCode_New(\r | |
1052 | argcount, nlocals, stacksize, flags,\r | |
1053 | code, consts, names, varnames,\r | |
1054 | freevars, cellvars, filename, name,\r | |
1055 | firstlineno, lnotab);\r | |
1056 | \r | |
1057 | code_error:\r | |
1058 | Py_XDECREF(code);\r | |
1059 | Py_XDECREF(consts);\r | |
1060 | Py_XDECREF(names);\r | |
1061 | Py_XDECREF(varnames);\r | |
1062 | Py_XDECREF(freevars);\r | |
1063 | Py_XDECREF(cellvars);\r | |
1064 | Py_XDECREF(filename);\r | |
1065 | Py_XDECREF(name);\r | |
1066 | Py_XDECREF(lnotab);\r | |
1067 | \r | |
1068 | }\r | |
1069 | retval = v;\r | |
1070 | break;\r | |
1071 | \r | |
1072 | default:\r | |
1073 | /* Bogus data got written, which isn't ideal.\r | |
1074 | This will let you keep working and recover. */\r | |
1075 | PyErr_SetString(PyExc_ValueError, "bad marshal data (unknown type code)");\r | |
1076 | retval = NULL;\r | |
1077 | break;\r | |
1078 | \r | |
1079 | }\r | |
1080 | p->depth--;\r | |
1081 | return retval;\r | |
1082 | }\r | |
1083 | \r | |
1084 | static PyObject *\r | |
1085 | read_object(RFILE *p)\r | |
1086 | {\r | |
1087 | PyObject *v;\r | |
1088 | if (PyErr_Occurred()) {\r | |
1089 | fprintf(stderr, "XXX readobject called with exception set\n");\r | |
1090 | return NULL;\r | |
1091 | }\r | |
1092 | v = r_object(p);\r | |
1093 | if (v == NULL && !PyErr_Occurred())\r | |
1094 | PyErr_SetString(PyExc_TypeError, "NULL object in marshal data for object");\r | |
1095 | return v;\r | |
1096 | }\r | |
1097 | \r | |
1098 | int\r | |
1099 | PyMarshal_ReadShortFromFile(FILE *fp)\r | |
1100 | {\r | |
1101 | RFILE rf;\r | |
1102 | assert(fp);\r | |
1103 | rf.fp = fp;\r | |
1104 | rf.strings = NULL;\r | |
1105 | rf.end = rf.ptr = NULL;\r | |
1106 | return r_short(&rf);\r | |
1107 | }\r | |
1108 | \r | |
1109 | long\r | |
1110 | PyMarshal_ReadLongFromFile(FILE *fp)\r | |
1111 | {\r | |
1112 | RFILE rf;\r | |
1113 | rf.fp = fp;\r | |
1114 | rf.strings = NULL;\r | |
1115 | rf.ptr = rf.end = NULL;\r | |
1116 | return r_long(&rf);\r | |
1117 | }\r | |
1118 | \r | |
1119 | #ifdef HAVE_FSTAT\r | |
1120 | /* Return size of file in bytes; < 0 if unknown. */\r | |
1121 | static off_t\r | |
1122 | getfilesize(FILE *fp)\r | |
1123 | {\r | |
1124 | struct stat st;\r | |
1125 | if (fstat(fileno(fp), &st) != 0)\r | |
1126 | return -1;\r | |
1127 | else\r | |
1128 | return st.st_size;\r | |
1129 | }\r | |
1130 | #endif\r | |
1131 | \r | |
1132 | /* If we can get the size of the file up-front, and it's reasonably small,\r | |
1133 | * read it in one gulp and delegate to ...FromString() instead. Much quicker\r | |
1134 | * than reading a byte at a time from file; speeds .pyc imports.\r | |
1135 | * CAUTION: since this may read the entire remainder of the file, don't\r | |
1136 | * call it unless you know you're done with the file.\r | |
1137 | */\r | |
1138 | PyObject *\r | |
1139 | PyMarshal_ReadLastObjectFromFile(FILE *fp)\r | |
1140 | {\r | |
1141 | /* REASONABLE_FILE_LIMIT is by defn something big enough for Tkinter.pyc. */\r | |
1142 | #define REASONABLE_FILE_LIMIT (1L << 18)\r | |
1143 | #ifdef HAVE_FSTAT\r | |
1144 | off_t filesize;\r | |
1145 | filesize = getfilesize(fp);\r | |
1146 | if (filesize > 0 && filesize <= REASONABLE_FILE_LIMIT) {\r | |
1147 | char* pBuf = (char *)PyMem_MALLOC(filesize);\r | |
1148 | if (pBuf != NULL) {\r | |
1149 | PyObject* v;\r | |
1150 | size_t n;\r | |
1151 | /* filesize must fit into an int, because it\r | |
1152 | is smaller than REASONABLE_FILE_LIMIT */\r | |
1153 | n = fread(pBuf, 1, (int)filesize, fp);\r | |
1154 | v = PyMarshal_ReadObjectFromString(pBuf, n);\r | |
1155 | PyMem_FREE(pBuf);\r | |
1156 | return v;\r | |
1157 | }\r | |
1158 | \r | |
1159 | }\r | |
1160 | #endif\r | |
1161 | /* We don't have fstat, or we do but the file is larger than\r | |
1162 | * REASONABLE_FILE_LIMIT or malloc failed -- read a byte at a time.\r | |
1163 | */\r | |
1164 | return PyMarshal_ReadObjectFromFile(fp);\r | |
1165 | \r | |
1166 | #undef REASONABLE_FILE_LIMIT\r | |
1167 | }\r | |
1168 | \r | |
1169 | PyObject *\r | |
1170 | PyMarshal_ReadObjectFromFile(FILE *fp)\r | |
1171 | {\r | |
1172 | RFILE rf;\r | |
1173 | PyObject *result;\r | |
1174 | rf.fp = fp;\r | |
1175 | rf.strings = PyList_New(0);\r | |
1176 | rf.depth = 0;\r | |
1177 | rf.ptr = rf.end = NULL;\r | |
1178 | result = r_object(&rf);\r | |
1179 | Py_DECREF(rf.strings);\r | |
1180 | return result;\r | |
1181 | }\r | |
1182 | \r | |
1183 | PyObject *\r | |
1184 | PyMarshal_ReadObjectFromString(char *str, Py_ssize_t len)\r | |
1185 | {\r | |
1186 | RFILE rf;\r | |
1187 | PyObject *result;\r | |
1188 | rf.fp = NULL;\r | |
1189 | rf.ptr = str;\r | |
1190 | rf.end = str + len;\r | |
1191 | rf.strings = PyList_New(0);\r | |
1192 | rf.depth = 0;\r | |
1193 | result = r_object(&rf);\r | |
1194 | Py_DECREF(rf.strings);\r | |
1195 | return result;\r | |
1196 | }\r | |
1197 | \r | |
1198 | static void\r | |
1199 | set_error(int error)\r | |
1200 | {\r | |
1201 | switch (error) {\r | |
1202 | case WFERR_NOMEMORY:\r | |
1203 | PyErr_NoMemory();\r | |
1204 | break;\r | |
1205 | case WFERR_UNMARSHALLABLE:\r | |
1206 | PyErr_SetString(PyExc_ValueError, "unmarshallable object");\r | |
1207 | break;\r | |
1208 | case WFERR_NESTEDTOODEEP:\r | |
1209 | default:\r | |
1210 | PyErr_SetString(PyExc_ValueError,\r | |
1211 | "object too deeply nested to marshal");\r | |
1212 | break;\r | |
1213 | }\r | |
1214 | }\r | |
1215 | \r | |
1216 | PyObject *\r | |
1217 | PyMarshal_WriteObjectToString(PyObject *x, int version)\r | |
1218 | {\r | |
1219 | WFILE wf;\r | |
1220 | wf.fp = NULL;\r | |
1221 | wf.str = PyString_FromStringAndSize((char *)NULL, 50);\r | |
1222 | if (wf.str == NULL)\r | |
1223 | return NULL;\r | |
1224 | wf.ptr = PyString_AS_STRING((PyStringObject *)wf.str);\r | |
1225 | wf.end = wf.ptr + PyString_Size(wf.str);\r | |
1226 | wf.error = WFERR_OK;\r | |
1227 | wf.depth = 0;\r | |
1228 | wf.version = version;\r | |
1229 | wf.strings = (version > 0) ? PyDict_New() : NULL;\r | |
1230 | w_object(x, &wf);\r | |
1231 | Py_XDECREF(wf.strings);\r | |
1232 | if (wf.str != NULL) {\r | |
1233 | char *base = PyString_AS_STRING((PyStringObject *)wf.str);\r | |
1234 | if (wf.ptr - base > PY_SSIZE_T_MAX) {\r | |
1235 | Py_DECREF(wf.str);\r | |
1236 | PyErr_SetString(PyExc_OverflowError,\r | |
1237 | "too much marshall data for a string");\r | |
1238 | return NULL;\r | |
1239 | }\r | |
1240 | if (_PyString_Resize(&wf.str, (Py_ssize_t)(wf.ptr - base)))\r | |
1241 | return NULL;\r | |
1242 | }\r | |
1243 | if (wf.error != WFERR_OK) {\r | |
1244 | Py_XDECREF(wf.str);\r | |
1245 | set_error(wf.error);\r | |
1246 | return NULL;\r | |
1247 | }\r | |
1248 | return wf.str;\r | |
1249 | }\r | |
1250 | \r | |
1251 | /* And an interface for Python programs... */\r | |
1252 | \r | |
1253 | static PyObject *\r | |
1254 | marshal_dump(PyObject *self, PyObject *args)\r | |
1255 | {\r | |
1256 | WFILE wf;\r | |
1257 | PyObject *x;\r | |
1258 | PyObject *f;\r | |
1259 | int version = Py_MARSHAL_VERSION;\r | |
1260 | if (!PyArg_ParseTuple(args, "OO|i:dump", &x, &f, &version))\r | |
1261 | return NULL;\r | |
1262 | if (!PyFile_Check(f)) {\r | |
1263 | PyErr_SetString(PyExc_TypeError,\r | |
1264 | "marshal.dump() 2nd arg must be file");\r | |
1265 | return NULL;\r | |
1266 | }\r | |
1267 | wf.fp = PyFile_AsFile(f);\r | |
1268 | wf.str = NULL;\r | |
1269 | wf.ptr = wf.end = NULL;\r | |
1270 | wf.error = WFERR_OK;\r | |
1271 | wf.depth = 0;\r | |
1272 | wf.strings = (version > 0) ? PyDict_New() : 0;\r | |
1273 | wf.version = version;\r | |
1274 | w_object(x, &wf);\r | |
1275 | Py_XDECREF(wf.strings);\r | |
1276 | if (wf.error != WFERR_OK) {\r | |
1277 | set_error(wf.error);\r | |
1278 | return NULL;\r | |
1279 | }\r | |
1280 | Py_INCREF(Py_None);\r | |
1281 | return Py_None;\r | |
1282 | }\r | |
1283 | \r | |
1284 | PyDoc_STRVAR(dump_doc,\r | |
1285 | "dump(value, file[, version])\n\\r | |
1286 | \n\\r | |
1287 | Write the value on the open file. The value must be a supported type.\n\\r | |
1288 | The file must be an open file object such as sys.stdout or returned by\n\\r | |
1289 | open() or os.popen(). It must be opened in binary mode ('wb' or 'w+b').\n\\r | |
1290 | \n\\r | |
1291 | If the value has (or contains an object that has) an unsupported type, a\n\\r | |
1ea946d0 | 1292 | ValueError exception is raised - but garbage data will also be written\n\\r |
6c0ebd5f | 1293 | to the file. The object will not be properly read back by load()\n\\r |
1294 | \n\\r | |
1295 | New in version 2.4: The version argument indicates the data format that\n\\r | |
1296 | dump should use.");\r | |
1297 | \r | |
1298 | static PyObject *\r | |
1299 | marshal_load(PyObject *self, PyObject *f)\r | |
1300 | {\r | |
1301 | RFILE rf;\r | |
1302 | PyObject *result;\r | |
1303 | if (!PyFile_Check(f)) {\r | |
1304 | PyErr_SetString(PyExc_TypeError,\r | |
1305 | "marshal.load() arg must be file");\r | |
1306 | return NULL;\r | |
1307 | }\r | |
1308 | rf.fp = PyFile_AsFile(f);\r | |
1309 | rf.strings = PyList_New(0);\r | |
1310 | rf.depth = 0;\r | |
1311 | result = read_object(&rf);\r | |
1312 | Py_DECREF(rf.strings);\r | |
1313 | return result;\r | |
1314 | }\r | |
1315 | \r | |
1316 | PyDoc_STRVAR(load_doc,\r | |
1317 | "load(file)\n\\r | |
1318 | \n\\r | |
1319 | Read one value from the open file and return it. If no valid value is\n\\r | |
1ea946d0 | 1320 | read (e.g. because the data has a different Python version's\n\\r |
6c0ebd5f | 1321 | incompatible marshal format), raise EOFError, ValueError or TypeError.\n\\r |
1322 | The file must be an open file object opened in binary mode ('rb' or\n\\r | |
1323 | 'r+b').\n\\r | |
1324 | \n\\r | |
1325 | Note: If an object containing an unsupported type was marshalled with\n\\r | |
1326 | dump(), load() will substitute None for the unmarshallable type.");\r | |
1327 | \r | |
1328 | \r | |
1329 | static PyObject *\r | |
1330 | marshal_dumps(PyObject *self, PyObject *args)\r | |
1331 | {\r | |
1332 | PyObject *x;\r | |
1333 | int version = Py_MARSHAL_VERSION;\r | |
1334 | if (!PyArg_ParseTuple(args, "O|i:dumps", &x, &version))\r | |
1335 | return NULL;\r | |
1336 | return PyMarshal_WriteObjectToString(x, version);\r | |
1337 | }\r | |
1338 | \r | |
1339 | PyDoc_STRVAR(dumps_doc,\r | |
1340 | "dumps(value[, version])\n\\r | |
1341 | \n\\r | |
1342 | Return the string that would be written to a file by dump(value, file).\n\\r | |
1343 | The value must be a supported type. Raise a ValueError exception if\n\\r | |
1344 | value has (or contains an object that has) an unsupported type.\n\\r | |
1345 | \n\\r | |
1346 | New in version 2.4: The version argument indicates the data format that\n\\r | |
1347 | dumps should use.");\r | |
1348 | \r | |
1349 | \r | |
1350 | static PyObject *\r | |
1351 | marshal_loads(PyObject *self, PyObject *args)\r | |
1352 | {\r | |
1353 | RFILE rf;\r | |
1354 | char *s;\r | |
1355 | Py_ssize_t n;\r | |
1356 | PyObject* result;\r | |
1357 | if (!PyArg_ParseTuple(args, "s#:loads", &s, &n))\r | |
1358 | return NULL;\r | |
1359 | rf.fp = NULL;\r | |
1360 | rf.ptr = s;\r | |
1361 | rf.end = s + n;\r | |
1362 | rf.strings = PyList_New(0);\r | |
1363 | rf.depth = 0;\r | |
1364 | result = read_object(&rf);\r | |
1365 | Py_DECREF(rf.strings);\r | |
1366 | return result;\r | |
1367 | }\r | |
1368 | \r | |
1369 | PyDoc_STRVAR(loads_doc,\r | |
1370 | "loads(string)\n\\r | |
1371 | \n\\r | |
1372 | Convert the string to a value. If no valid value is found, raise\n\\r | |
1373 | EOFError, ValueError or TypeError. Extra characters in the string are\n\\r | |
1374 | ignored.");\r | |
1375 | \r | |
1376 | static PyMethodDef marshal_methods[] = {\r | |
1377 | {"dump", marshal_dump, METH_VARARGS, dump_doc},\r | |
1378 | {"load", marshal_load, METH_O, load_doc},\r | |
1379 | {"dumps", marshal_dumps, METH_VARARGS, dumps_doc},\r | |
1380 | {"loads", marshal_loads, METH_VARARGS, loads_doc},\r | |
1381 | {NULL, NULL} /* sentinel */\r | |
1382 | };\r | |
1383 | \r | |
1384 | PyDoc_STRVAR(marshal_doc,\r | |
1385 | "This module contains functions that can read and write Python values in\n\\r | |
1386 | a binary format. The format is specific to Python, but independent of\n\\r | |
1387 | machine architecture issues.\n\\r | |
1388 | \n\\r | |
1389 | Not all Python object types are supported; in general, only objects\n\\r | |
1390 | whose value is independent from a particular invocation of Python can be\n\\r | |
1391 | written and read by this module. The following types are supported:\n\\r | |
1392 | None, integers, long integers, floating point numbers, strings, Unicode\n\\r | |
1393 | objects, tuples, lists, sets, dictionaries, and code objects, where it\n\\r | |
1394 | should be understood that tuples, lists and dictionaries are only\n\\r | |
1395 | supported as long as the values contained therein are themselves\n\\r | |
1396 | supported; and recursive lists and dictionaries should not be written\n\\r | |
1397 | (they will cause infinite loops).\n\\r | |
1398 | \n\\r | |
1399 | Variables:\n\\r | |
1400 | \n\\r | |
1401 | version -- indicates the format that the module uses. Version 0 is the\n\\r | |
1402 | historical format, version 1 (added in Python 2.4) shares interned\n\\r | |
1403 | strings and version 2 (added in Python 2.5) uses a binary format for\n\\r | |
1404 | floating point numbers. (New in version 2.4)\n\\r | |
1405 | \n\\r | |
1406 | Functions:\n\\r | |
1407 | \n\\r | |
1408 | dump() -- write value to a file\n\\r | |
1409 | load() -- read value from a file\n\\r | |
1410 | dumps() -- write value to a string\n\\r | |
1411 | loads() -- read value from a string");\r | |
1412 | \r | |
1413 | \r | |
1414 | PyMODINIT_FUNC\r | |
1415 | PyMarshal_Init(void)\r | |
1416 | {\r | |
1417 | PyObject *mod = Py_InitModule3("marshal", marshal_methods,\r | |
1418 | marshal_doc);\r | |
1419 | if (mod == NULL)\r | |
1420 | return;\r | |
1421 | PyModule_AddIntConstant(mod, "version", Py_MARSHAL_VERSION);\r | |
1422 | }\r |