|
1 #include "Python.h" |
|
2 #include "cStringIO.h" |
|
3 #include "structmember.h" |
|
4 |
|
5 PyDoc_STRVAR(cPickle_module_documentation, |
|
6 "C implementation and optimization of the Python pickle module."); |
|
7 |
|
8 #ifndef Py_eval_input |
|
9 #include <graminit.h> |
|
10 #define Py_eval_input eval_input |
|
11 #endif /* Py_eval_input */ |
|
12 |
|
13 #define DEL_LIST_SLICE(list, from, to) (PyList_SetSlice(list, from, to, NULL)) |
|
14 |
|
15 #define WRITE_BUF_SIZE 256 |
|
16 |
|
17 /* Bump this when new opcodes are added to the pickle protocol. */ |
|
18 #define HIGHEST_PROTOCOL 2 |
|
19 |
|
20 /* |
|
21 * Pickle opcodes. These must be kept in synch with pickle.py. Extensive |
|
22 * docs are in pickletools.py. |
|
23 */ |
|
24 #define MARK '(' |
|
25 #define STOP '.' |
|
26 #define POP '0' |
|
27 #define POP_MARK '1' |
|
28 #define DUP '2' |
|
29 #define FLOAT 'F' |
|
30 #define BINFLOAT 'G' |
|
31 #define INT 'I' |
|
32 #define BININT 'J' |
|
33 #define BININT1 'K' |
|
34 #define LONG 'L' |
|
35 #define BININT2 'M' |
|
36 #define NONE 'N' |
|
37 #define PERSID 'P' |
|
38 #define BINPERSID 'Q' |
|
39 #define REDUCE 'R' |
|
40 #define STRING 'S' |
|
41 #define BINSTRING 'T' |
|
42 #define SHORT_BINSTRING 'U' |
|
43 #define UNICODE 'V' |
|
44 #define BINUNICODE 'X' |
|
45 #define APPEND 'a' |
|
46 #define BUILD 'b' |
|
47 #define GLOBAL 'c' |
|
48 #define DICT 'd' |
|
49 #define EMPTY_DICT '}' |
|
50 #define APPENDS 'e' |
|
51 #define GET 'g' |
|
52 #define BINGET 'h' |
|
53 #define INST 'i' |
|
54 #define LONG_BINGET 'j' |
|
55 #define LIST 'l' |
|
56 #define EMPTY_LIST ']' |
|
57 #define OBJ 'o' |
|
58 #define PUT 'p' |
|
59 #define BINPUT 'q' |
|
60 #define LONG_BINPUT 'r' |
|
61 #define SETITEM 's' |
|
62 #define TUPLE 't' |
|
63 #define EMPTY_TUPLE ')' |
|
64 #define SETITEMS 'u' |
|
65 |
|
66 /* Protocol 2. */ |
|
67 #define PROTO '\x80' /* identify pickle protocol */ |
|
68 #define NEWOBJ '\x81' /* build object by applying cls.__new__ to argtuple */ |
|
69 #define EXT1 '\x82' /* push object from extension registry; 1-byte index */ |
|
70 #define EXT2 '\x83' /* ditto, but 2-byte index */ |
|
71 #define EXT4 '\x84' /* ditto, but 4-byte index */ |
|
72 #define TUPLE1 '\x85' /* build 1-tuple from stack top */ |
|
73 #define TUPLE2 '\x86' /* build 2-tuple from two topmost stack items */ |
|
74 #define TUPLE3 '\x87' /* build 3-tuple from three topmost stack items */ |
|
75 #define NEWTRUE '\x88' /* push True */ |
|
76 #define NEWFALSE '\x89' /* push False */ |
|
77 #define LONG1 '\x8a' /* push long from < 256 bytes */ |
|
78 #define LONG4 '\x8b' /* push really big long */ |
|
79 |
|
80 /* There aren't opcodes -- they're ways to pickle bools before protocol 2, |
|
81 * so that unpicklers written before bools were introduced unpickle them |
|
82 * as ints, but unpicklers after can recognize that bools were intended. |
|
83 * Note that protocol 2 added direct ways to pickle bools. |
|
84 */ |
|
85 #undef TRUE |
|
86 #define TRUE "I01\n" |
|
87 #undef FALSE |
|
88 #define FALSE "I00\n" |
|
89 |
|
90 /* Keep in synch with pickle.Pickler._BATCHSIZE. This is how many elements |
|
91 * batch_list/dict() pumps out before doing APPENDS/SETITEMS. Nothing will |
|
92 * break if this gets out of synch with pickle.py, but it's unclear that |
|
93 * would help anything either. |
|
94 */ |
|
95 #define BATCHSIZE 1000 |
|
96 |
|
97 static char MARKv = MARK; |
|
98 |
|
99 static PyObject *PickleError; |
|
100 static PyObject *PicklingError; |
|
101 static PyObject *UnpickleableError; |
|
102 static PyObject *UnpicklingError; |
|
103 static PyObject *BadPickleGet; |
|
104 |
|
105 /* As the name says, an empty tuple. */ |
|
106 static PyObject *empty_tuple; |
|
107 |
|
108 /* copy_reg.dispatch_table, {type_object: pickling_function} */ |
|
109 static PyObject *dispatch_table; |
|
110 |
|
111 /* For EXT[124] opcodes. */ |
|
112 /* copy_reg._extension_registry, {(module_name, function_name): code} */ |
|
113 static PyObject *extension_registry; |
|
114 /* copy_reg._inverted_registry, {code: (module_name, function_name)} */ |
|
115 static PyObject *inverted_registry; |
|
116 /* copy_reg._extension_cache, {code: object} */ |
|
117 static PyObject *extension_cache; |
|
118 |
|
119 /* For looking up name pairs in copy_reg._extension_registry. */ |
|
120 static PyObject *two_tuple; |
|
121 |
|
122 static PyObject *__class___str, *__getinitargs___str, *__dict___str, |
|
123 *__getstate___str, *__setstate___str, *__name___str, *__reduce___str, |
|
124 *__reduce_ex___str, |
|
125 *write_str, *append_str, |
|
126 *read_str, *readline_str, *__main___str, |
|
127 *copyreg_str, *dispatch_table_str; |
|
128 |
|
129 /************************************************************************* |
|
130 Internal Data type for pickle data. */ |
|
131 |
|
132 typedef struct { |
|
133 PyObject_HEAD |
|
134 int length; /* number of initial slots in data currently used */ |
|
135 int size; /* number of slots in data allocated */ |
|
136 PyObject **data; |
|
137 } Pdata; |
|
138 |
|
139 static void |
|
140 Pdata_dealloc(Pdata *self) |
|
141 { |
|
142 int i; |
|
143 PyObject **p; |
|
144 |
|
145 for (i = self->length, p = self->data; --i >= 0; p++) { |
|
146 Py_DECREF(*p); |
|
147 } |
|
148 if (self->data) |
|
149 free(self->data); |
|
150 PyObject_Del(self); |
|
151 } |
|
152 |
|
153 static PyTypeObject PdataType = { |
|
154 PyVarObject_HEAD_INIT(NULL, 0) "cPickle.Pdata", sizeof(Pdata), 0, |
|
155 (destructor)Pdata_dealloc, |
|
156 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0L,0L,0L,0L, "" |
|
157 }; |
|
158 |
|
159 #define Pdata_Check(O) (Py_TYPE(O) == &PdataType) |
|
160 |
|
161 static PyObject * |
|
162 Pdata_New(void) |
|
163 { |
|
164 Pdata *self; |
|
165 |
|
166 if (!(self = PyObject_New(Pdata, &PdataType))) |
|
167 return NULL; |
|
168 self->size = 8; |
|
169 self->length = 0; |
|
170 self->data = malloc(self->size * sizeof(PyObject*)); |
|
171 if (self->data) |
|
172 return (PyObject*)self; |
|
173 Py_DECREF(self); |
|
174 return PyErr_NoMemory(); |
|
175 } |
|
176 |
|
177 static int |
|
178 stackUnderflow(void) |
|
179 { |
|
180 PyErr_SetString(UnpicklingError, "unpickling stack underflow"); |
|
181 return -1; |
|
182 } |
|
183 |
|
184 /* Retain only the initial clearto items. If clearto >= the current |
|
185 * number of items, this is a (non-erroneous) NOP. |
|
186 */ |
|
187 static int |
|
188 Pdata_clear(Pdata *self, int clearto) |
|
189 { |
|
190 int i; |
|
191 PyObject **p; |
|
192 |
|
193 if (clearto < 0) return stackUnderflow(); |
|
194 if (clearto >= self->length) return 0; |
|
195 |
|
196 for (i = self->length, p = self->data + clearto; |
|
197 --i >= clearto; |
|
198 p++) { |
|
199 Py_CLEAR(*p); |
|
200 } |
|
201 self->length = clearto; |
|
202 |
|
203 return 0; |
|
204 } |
|
205 |
|
206 static int |
|
207 Pdata_grow(Pdata *self) |
|
208 { |
|
209 int bigger; |
|
210 size_t nbytes; |
|
211 PyObject **tmp; |
|
212 |
|
213 bigger = self->size << 1; |
|
214 if (bigger <= 0) /* was 0, or new value overflows */ |
|
215 goto nomemory; |
|
216 if ((int)(size_t)bigger != bigger) |
|
217 goto nomemory; |
|
218 nbytes = (size_t)bigger * sizeof(PyObject *); |
|
219 if (nbytes / sizeof(PyObject *) != (size_t)bigger) |
|
220 goto nomemory; |
|
221 tmp = realloc(self->data, nbytes); |
|
222 if (tmp == NULL) |
|
223 goto nomemory; |
|
224 self->data = tmp; |
|
225 self->size = bigger; |
|
226 return 0; |
|
227 |
|
228 nomemory: |
|
229 PyErr_NoMemory(); |
|
230 return -1; |
|
231 } |
|
232 |
|
233 /* D is a Pdata*. Pop the topmost element and store it into V, which |
|
234 * must be an lvalue holding PyObject*. On stack underflow, UnpicklingError |
|
235 * is raised and V is set to NULL. D and V may be evaluated several times. |
|
236 */ |
|
237 #define PDATA_POP(D, V) { \ |
|
238 if ((D)->length) \ |
|
239 (V) = (D)->data[--((D)->length)]; \ |
|
240 else { \ |
|
241 PyErr_SetString(UnpicklingError, "bad pickle data"); \ |
|
242 (V) = NULL; \ |
|
243 } \ |
|
244 } |
|
245 |
|
246 /* PDATA_PUSH and PDATA_APPEND both push rvalue PyObject* O on to Pdata* |
|
247 * D. If the Pdata stack can't be grown to hold the new value, both |
|
248 * raise MemoryError and execute "return ER". The difference is in ownership |
|
249 * of O after: _PUSH transfers ownership of O from the caller to the stack |
|
250 * (no incref of O is done, and in case of error O is decrefed), while |
|
251 * _APPEND pushes a new reference. |
|
252 */ |
|
253 |
|
254 /* Push O on stack D, giving ownership of O to the stack. */ |
|
255 #define PDATA_PUSH(D, O, ER) { \ |
|
256 if (((Pdata*)(D))->length == ((Pdata*)(D))->size && \ |
|
257 Pdata_grow((Pdata*)(D)) < 0) { \ |
|
258 Py_DECREF(O); \ |
|
259 return ER; \ |
|
260 } \ |
|
261 ((Pdata*)(D))->data[((Pdata*)(D))->length++] = (O); \ |
|
262 } |
|
263 |
|
264 /* Push O on stack D, pushing a new reference. */ |
|
265 #define PDATA_APPEND(D, O, ER) { \ |
|
266 if (((Pdata*)(D))->length == ((Pdata*)(D))->size && \ |
|
267 Pdata_grow((Pdata*)(D)) < 0) \ |
|
268 return ER; \ |
|
269 Py_INCREF(O); \ |
|
270 ((Pdata*)(D))->data[((Pdata*)(D))->length++] = (O); \ |
|
271 } |
|
272 |
|
273 |
|
274 static PyObject * |
|
275 Pdata_popTuple(Pdata *self, int start) |
|
276 { |
|
277 PyObject *r; |
|
278 int i, j, l; |
|
279 |
|
280 l = self->length-start; |
|
281 r = PyTuple_New(l); |
|
282 if (r == NULL) |
|
283 return NULL; |
|
284 for (i = start, j = 0 ; j < l; i++, j++) |
|
285 PyTuple_SET_ITEM(r, j, self->data[i]); |
|
286 |
|
287 self->length = start; |
|
288 return r; |
|
289 } |
|
290 |
|
291 static PyObject * |
|
292 Pdata_popList(Pdata *self, int start) |
|
293 { |
|
294 PyObject *r; |
|
295 int i, j, l; |
|
296 |
|
297 l=self->length-start; |
|
298 if (!( r=PyList_New(l))) return NULL; |
|
299 for (i=start, j=0 ; j < l; i++, j++) |
|
300 PyList_SET_ITEM(r, j, self->data[i]); |
|
301 |
|
302 self->length=start; |
|
303 return r; |
|
304 } |
|
305 |
|
306 /*************************************************************************/ |
|
307 |
|
308 #define ARG_TUP(self, o) { \ |
|
309 if (self->arg || (self->arg=PyTuple_New(1))) { \ |
|
310 Py_XDECREF(PyTuple_GET_ITEM(self->arg,0)); \ |
|
311 PyTuple_SET_ITEM(self->arg,0,o); \ |
|
312 } \ |
|
313 else { \ |
|
314 Py_DECREF(o); \ |
|
315 } \ |
|
316 } |
|
317 |
|
318 #define FREE_ARG_TUP(self) { \ |
|
319 if (Py_REFCNT(self->arg) > 1) { \ |
|
320 Py_DECREF(self->arg); \ |
|
321 self->arg=NULL; \ |
|
322 } \ |
|
323 } |
|
324 |
|
325 typedef struct Picklerobject { |
|
326 PyObject_HEAD |
|
327 FILE *fp; |
|
328 PyObject *write; |
|
329 PyObject *file; |
|
330 PyObject *memo; |
|
331 PyObject *arg; |
|
332 PyObject *pers_func; |
|
333 PyObject *inst_pers_func; |
|
334 |
|
335 /* pickle protocol number, >= 0 */ |
|
336 int proto; |
|
337 |
|
338 /* bool, true if proto > 0 */ |
|
339 int bin; |
|
340 |
|
341 int fast; /* Fast mode doesn't save in memo, don't use if circ ref */ |
|
342 int (*write_func)(struct Picklerobject *, const char *, Py_ssize_t); |
|
343 char *write_buf; |
|
344 int buf_size; |
|
345 PyObject *dispatch_table; |
|
346 int fast_container; /* count nested container dumps */ |
|
347 PyObject *fast_memo; |
|
348 } Picklerobject; |
|
349 |
|
350 #ifndef PY_CPICKLE_FAST_LIMIT |
|
351 #define PY_CPICKLE_FAST_LIMIT 50 |
|
352 #endif |
|
353 |
|
354 static PyTypeObject Picklertype; |
|
355 |
|
356 typedef struct Unpicklerobject { |
|
357 PyObject_HEAD |
|
358 FILE *fp; |
|
359 PyObject *file; |
|
360 PyObject *readline; |
|
361 PyObject *read; |
|
362 PyObject *memo; |
|
363 PyObject *arg; |
|
364 Pdata *stack; |
|
365 PyObject *mark; |
|
366 PyObject *pers_func; |
|
367 PyObject *last_string; |
|
368 int *marks; |
|
369 int num_marks; |
|
370 int marks_size; |
|
371 Py_ssize_t (*read_func)(struct Unpicklerobject *, char **, Py_ssize_t); |
|
372 Py_ssize_t (*readline_func)(struct Unpicklerobject *, char **); |
|
373 int buf_size; |
|
374 char *buf; |
|
375 PyObject *find_class; |
|
376 } Unpicklerobject; |
|
377 |
|
378 static PyTypeObject Unpicklertype; |
|
379 |
|
380 /* Forward decls that need the above structs */ |
|
381 static int save(Picklerobject *, PyObject *, int); |
|
382 static int put2(Picklerobject *, PyObject *); |
|
383 |
|
384 static |
|
385 PyObject * |
|
386 cPickle_ErrFormat(PyObject *ErrType, char *stringformat, char *format, ...) |
|
387 { |
|
388 va_list va; |
|
389 PyObject *args=0, *retval=0; |
|
390 va_start(va, format); |
|
391 |
|
392 if (format) args = Py_VaBuildValue(format, va); |
|
393 va_end(va); |
|
394 if (format && ! args) return NULL; |
|
395 if (stringformat && !(retval=PyString_FromString(stringformat))) |
|
396 return NULL; |
|
397 |
|
398 if (retval) { |
|
399 if (args) { |
|
400 PyObject *v; |
|
401 v=PyString_Format(retval, args); |
|
402 Py_DECREF(retval); |
|
403 Py_DECREF(args); |
|
404 if (! v) return NULL; |
|
405 retval=v; |
|
406 } |
|
407 } |
|
408 else |
|
409 if (args) retval=args; |
|
410 else { |
|
411 PyErr_SetObject(ErrType,Py_None); |
|
412 return NULL; |
|
413 } |
|
414 PyErr_SetObject(ErrType,retval); |
|
415 Py_DECREF(retval); |
|
416 return NULL; |
|
417 } |
|
418 |
|
419 static int |
|
420 write_file(Picklerobject *self, const char *s, Py_ssize_t n) |
|
421 { |
|
422 size_t nbyteswritten; |
|
423 |
|
424 if (s == NULL) { |
|
425 return 0; |
|
426 } |
|
427 |
|
428 if (n > INT_MAX) { |
|
429 /* String too large */ |
|
430 return -1; |
|
431 } |
|
432 |
|
433 PyFile_IncUseCount((PyFileObject *)self->file); |
|
434 Py_BEGIN_ALLOW_THREADS |
|
435 nbyteswritten = fwrite(s, sizeof(char), n, self->fp); |
|
436 Py_END_ALLOW_THREADS |
|
437 PyFile_DecUseCount((PyFileObject *)self->file); |
|
438 if (nbyteswritten != (size_t)n) { |
|
439 PyErr_SetFromErrno(PyExc_IOError); |
|
440 return -1; |
|
441 } |
|
442 |
|
443 return (int)n; |
|
444 } |
|
445 |
|
446 static int |
|
447 write_cStringIO(Picklerobject *self, const char *s, Py_ssize_t n) |
|
448 { |
|
449 if (s == NULL) { |
|
450 return 0; |
|
451 } |
|
452 |
|
453 if (PycStringIO->cwrite((PyObject *)self->file, s, n) != n) { |
|
454 return -1; |
|
455 } |
|
456 |
|
457 return (int)n; |
|
458 } |
|
459 |
|
460 static int |
|
461 write_none(Picklerobject *self, const char *s, Py_ssize_t n) |
|
462 { |
|
463 if (s == NULL) return 0; |
|
464 if (n > INT_MAX) return -1; |
|
465 return (int)n; |
|
466 } |
|
467 |
|
468 static int |
|
469 write_other(Picklerobject *self, const char *s, Py_ssize_t _n) |
|
470 { |
|
471 PyObject *py_str = 0, *junk = 0; |
|
472 int n; |
|
473 |
|
474 if (_n > INT_MAX) |
|
475 return -1; |
|
476 n = (int)_n; |
|
477 if (s == NULL) { |
|
478 if (!( self->buf_size )) return 0; |
|
479 py_str = PyString_FromStringAndSize(self->write_buf, |
|
480 self->buf_size); |
|
481 if (!py_str) |
|
482 return -1; |
|
483 } |
|
484 else { |
|
485 if (self->buf_size && (n + self->buf_size) > WRITE_BUF_SIZE) { |
|
486 if (write_other(self, NULL, 0) < 0) |
|
487 return -1; |
|
488 } |
|
489 |
|
490 if (n > WRITE_BUF_SIZE) { |
|
491 if (!( py_str = |
|
492 PyString_FromStringAndSize(s, n))) |
|
493 return -1; |
|
494 } |
|
495 else { |
|
496 memcpy(self->write_buf + self->buf_size, s, n); |
|
497 self->buf_size += n; |
|
498 return n; |
|
499 } |
|
500 } |
|
501 |
|
502 if (self->write) { |
|
503 /* object with write method */ |
|
504 ARG_TUP(self, py_str); |
|
505 if (self->arg) { |
|
506 junk = PyObject_Call(self->write, self->arg, NULL); |
|
507 FREE_ARG_TUP(self); |
|
508 } |
|
509 if (junk) Py_DECREF(junk); |
|
510 else return -1; |
|
511 } |
|
512 else |
|
513 PDATA_PUSH(self->file, py_str, -1); |
|
514 |
|
515 self->buf_size = 0; |
|
516 return n; |
|
517 } |
|
518 |
|
519 |
|
520 static Py_ssize_t |
|
521 read_file(Unpicklerobject *self, char **s, Py_ssize_t n) |
|
522 { |
|
523 size_t nbytesread; |
|
524 |
|
525 if (self->buf_size == 0) { |
|
526 int size; |
|
527 |
|
528 size = ((n < 32) ? 32 : n); |
|
529 if (!( self->buf = (char *)malloc(size))) { |
|
530 PyErr_NoMemory(); |
|
531 return -1; |
|
532 } |
|
533 |
|
534 self->buf_size = size; |
|
535 } |
|
536 else if (n > self->buf_size) { |
|
537 char *newbuf = (char *)realloc(self->buf, n); |
|
538 if (!newbuf) { |
|
539 PyErr_NoMemory(); |
|
540 return -1; |
|
541 } |
|
542 self->buf = newbuf; |
|
543 self->buf_size = n; |
|
544 } |
|
545 |
|
546 PyFile_IncUseCount((PyFileObject *)self->file); |
|
547 Py_BEGIN_ALLOW_THREADS |
|
548 nbytesread = fread(self->buf, sizeof(char), n, self->fp); |
|
549 Py_END_ALLOW_THREADS |
|
550 PyFile_DecUseCount((PyFileObject *)self->file); |
|
551 if (nbytesread != (size_t)n) { |
|
552 if (feof(self->fp)) { |
|
553 PyErr_SetNone(PyExc_EOFError); |
|
554 return -1; |
|
555 } |
|
556 |
|
557 PyErr_SetFromErrno(PyExc_IOError); |
|
558 return -1; |
|
559 } |
|
560 |
|
561 *s = self->buf; |
|
562 |
|
563 return n; |
|
564 } |
|
565 |
|
566 |
|
567 static Py_ssize_t |
|
568 readline_file(Unpicklerobject *self, char **s) |
|
569 { |
|
570 int i; |
|
571 |
|
572 if (self->buf_size == 0) { |
|
573 if (!( self->buf = (char *)malloc(40))) { |
|
574 PyErr_NoMemory(); |
|
575 return -1; |
|
576 } |
|
577 self->buf_size = 40; |
|
578 } |
|
579 |
|
580 i = 0; |
|
581 while (1) { |
|
582 int bigger; |
|
583 char *newbuf; |
|
584 for (; i < (self->buf_size - 1); i++) { |
|
585 if (feof(self->fp) || |
|
586 (self->buf[i] = getc(self->fp)) == '\n') { |
|
587 self->buf[i + 1] = '\0'; |
|
588 *s = self->buf; |
|
589 return i + 1; |
|
590 } |
|
591 } |
|
592 bigger = self->buf_size << 1; |
|
593 if (bigger <= 0) { /* overflow */ |
|
594 PyErr_NoMemory(); |
|
595 return -1; |
|
596 } |
|
597 newbuf = (char *)realloc(self->buf, bigger); |
|
598 if (!newbuf) { |
|
599 PyErr_NoMemory(); |
|
600 return -1; |
|
601 } |
|
602 self->buf = newbuf; |
|
603 self->buf_size = bigger; |
|
604 } |
|
605 } |
|
606 |
|
607 |
|
608 static Py_ssize_t |
|
609 read_cStringIO(Unpicklerobject *self, char **s, Py_ssize_t n) |
|
610 { |
|
611 char *ptr; |
|
612 |
|
613 if (PycStringIO->cread((PyObject *)self->file, &ptr, n) != n) { |
|
614 PyErr_SetNone(PyExc_EOFError); |
|
615 return -1; |
|
616 } |
|
617 |
|
618 *s = ptr; |
|
619 |
|
620 return n; |
|
621 } |
|
622 |
|
623 |
|
624 static Py_ssize_t |
|
625 readline_cStringIO(Unpicklerobject *self, char **s) |
|
626 { |
|
627 Py_ssize_t n; |
|
628 char *ptr; |
|
629 |
|
630 if ((n = PycStringIO->creadline((PyObject *)self->file, &ptr)) < 0) { |
|
631 return -1; |
|
632 } |
|
633 |
|
634 *s = ptr; |
|
635 |
|
636 return n; |
|
637 } |
|
638 |
|
639 |
|
640 static Py_ssize_t |
|
641 read_other(Unpicklerobject *self, char **s, Py_ssize_t n) |
|
642 { |
|
643 PyObject *bytes, *str=0; |
|
644 |
|
645 if (!( bytes = PyInt_FromSsize_t(n))) return -1; |
|
646 |
|
647 ARG_TUP(self, bytes); |
|
648 if (self->arg) { |
|
649 str = PyObject_Call(self->read, self->arg, NULL); |
|
650 FREE_ARG_TUP(self); |
|
651 } |
|
652 if (! str) return -1; |
|
653 |
|
654 Py_XDECREF(self->last_string); |
|
655 self->last_string = str; |
|
656 |
|
657 if (! (*s = PyString_AsString(str))) return -1; |
|
658 return n; |
|
659 } |
|
660 |
|
661 |
|
662 static Py_ssize_t |
|
663 readline_other(Unpicklerobject *self, char **s) |
|
664 { |
|
665 PyObject *str; |
|
666 Py_ssize_t str_size; |
|
667 |
|
668 if (!( str = PyObject_CallObject(self->readline, empty_tuple))) { |
|
669 return -1; |
|
670 } |
|
671 |
|
672 if ((str_size = PyString_Size(str)) < 0) |
|
673 return -1; |
|
674 |
|
675 Py_XDECREF(self->last_string); |
|
676 self->last_string = str; |
|
677 |
|
678 if (! (*s = PyString_AsString(str))) |
|
679 return -1; |
|
680 |
|
681 return str_size; |
|
682 } |
|
683 |
|
684 /* Copy the first n bytes from s into newly malloc'ed memory, plus a |
|
685 * trailing 0 byte. Return a pointer to that, or NULL if out of memory. |
|
686 * The caller is responsible for free()'ing the return value. |
|
687 */ |
|
688 static char * |
|
689 pystrndup(const char *s, int n) |
|
690 { |
|
691 char *r = (char *)malloc(n+1); |
|
692 if (r == NULL) |
|
693 return (char*)PyErr_NoMemory(); |
|
694 memcpy(r, s, n); |
|
695 r[n] = 0; |
|
696 return r; |
|
697 } |
|
698 |
|
699 |
|
700 static int |
|
701 get(Picklerobject *self, PyObject *id) |
|
702 { |
|
703 PyObject *value, *mv; |
|
704 long c_value; |
|
705 char s[30]; |
|
706 size_t len; |
|
707 |
|
708 if (!( mv = PyDict_GetItem(self->memo, id))) { |
|
709 PyErr_SetObject(PyExc_KeyError, id); |
|
710 return -1; |
|
711 } |
|
712 |
|
713 if (!( value = PyTuple_GetItem(mv, 0))) |
|
714 return -1; |
|
715 |
|
716 if (!( PyInt_Check(value))) { |
|
717 PyErr_SetString(PicklingError, "no int where int expected in memo"); |
|
718 return -1; |
|
719 } |
|
720 c_value = PyInt_AS_LONG((PyIntObject*)value); |
|
721 |
|
722 if (!self->bin) { |
|
723 s[0] = GET; |
|
724 PyOS_snprintf(s + 1, sizeof(s) - 1, "%ld\n", c_value); |
|
725 len = strlen(s); |
|
726 } |
|
727 else if (Pdata_Check(self->file)) { |
|
728 if (write_other(self, NULL, 0) < 0) return -1; |
|
729 PDATA_APPEND(self->file, mv, -1); |
|
730 return 0; |
|
731 } |
|
732 else { |
|
733 if (c_value < 256) { |
|
734 s[0] = BINGET; |
|
735 s[1] = (int)(c_value & 0xff); |
|
736 len = 2; |
|
737 } |
|
738 else { |
|
739 s[0] = LONG_BINGET; |
|
740 s[1] = (int)(c_value & 0xff); |
|
741 s[2] = (int)((c_value >> 8) & 0xff); |
|
742 s[3] = (int)((c_value >> 16) & 0xff); |
|
743 s[4] = (int)((c_value >> 24) & 0xff); |
|
744 len = 5; |
|
745 } |
|
746 } |
|
747 |
|
748 if (self->write_func(self, s, len) < 0) |
|
749 return -1; |
|
750 |
|
751 return 0; |
|
752 } |
|
753 |
|
754 |
|
755 static int |
|
756 put(Picklerobject *self, PyObject *ob) |
|
757 { |
|
758 if (Py_REFCNT(ob) < 2 || self->fast) |
|
759 return 0; |
|
760 |
|
761 return put2(self, ob); |
|
762 } |
|
763 |
|
764 |
|
765 static int |
|
766 put2(Picklerobject *self, PyObject *ob) |
|
767 { |
|
768 char c_str[30]; |
|
769 int p; |
|
770 size_t len; |
|
771 int res = -1; |
|
772 PyObject *py_ob_id = 0, *memo_len = 0, *t = 0; |
|
773 |
|
774 if (self->fast) |
|
775 return 0; |
|
776 |
|
777 if ((p = PyDict_Size(self->memo)) < 0) |
|
778 goto finally; |
|
779 |
|
780 /* Make sure memo keys are positive! */ |
|
781 /* XXX Why? |
|
782 * XXX And does "positive" really mean non-negative? |
|
783 * XXX pickle.py starts with PUT index 0, not 1. This makes for |
|
784 * XXX gratuitous differences between the pickling modules. |
|
785 */ |
|
786 p++; |
|
787 |
|
788 if (!( py_ob_id = PyLong_FromVoidPtr(ob))) |
|
789 goto finally; |
|
790 |
|
791 if (!( memo_len = PyInt_FromLong(p))) |
|
792 goto finally; |
|
793 |
|
794 if (!( t = PyTuple_New(2))) |
|
795 goto finally; |
|
796 |
|
797 PyTuple_SET_ITEM(t, 0, memo_len); |
|
798 Py_INCREF(memo_len); |
|
799 PyTuple_SET_ITEM(t, 1, ob); |
|
800 Py_INCREF(ob); |
|
801 |
|
802 if (PyDict_SetItem(self->memo, py_ob_id, t) < 0) |
|
803 goto finally; |
|
804 |
|
805 if (!self->bin) { |
|
806 c_str[0] = PUT; |
|
807 PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%d\n", p); |
|
808 len = strlen(c_str); |
|
809 } |
|
810 else if (Pdata_Check(self->file)) { |
|
811 if (write_other(self, NULL, 0) < 0) return -1; |
|
812 PDATA_APPEND(self->file, memo_len, -1); |
|
813 res=0; /* Job well done ;) */ |
|
814 goto finally; |
|
815 } |
|
816 else { |
|
817 if (p >= 256) { |
|
818 c_str[0] = LONG_BINPUT; |
|
819 c_str[1] = (int)(p & 0xff); |
|
820 c_str[2] = (int)((p >> 8) & 0xff); |
|
821 c_str[3] = (int)((p >> 16) & 0xff); |
|
822 c_str[4] = (int)((p >> 24) & 0xff); |
|
823 len = 5; |
|
824 } |
|
825 else { |
|
826 c_str[0] = BINPUT; |
|
827 c_str[1] = p; |
|
828 len = 2; |
|
829 } |
|
830 } |
|
831 |
|
832 if (self->write_func(self, c_str, len) < 0) |
|
833 goto finally; |
|
834 |
|
835 res = 0; |
|
836 |
|
837 finally: |
|
838 Py_XDECREF(py_ob_id); |
|
839 Py_XDECREF(memo_len); |
|
840 Py_XDECREF(t); |
|
841 |
|
842 return res; |
|
843 } |
|
844 |
|
845 static PyObject * |
|
846 whichmodule(PyObject *global, PyObject *global_name) |
|
847 { |
|
848 Py_ssize_t i, j; |
|
849 PyObject *module = 0, *modules_dict = 0, |
|
850 *global_name_attr = 0, *name = 0; |
|
851 |
|
852 module = PyObject_GetAttrString(global, "__module__"); |
|
853 if (module) |
|
854 return module; |
|
855 if (PyErr_ExceptionMatches(PyExc_AttributeError)) |
|
856 PyErr_Clear(); |
|
857 else |
|
858 return NULL; |
|
859 |
|
860 if (!( modules_dict = PySys_GetObject("modules"))) |
|
861 return NULL; |
|
862 |
|
863 i = 0; |
|
864 while ((j = PyDict_Next(modules_dict, &i, &name, &module))) { |
|
865 |
|
866 if (PyObject_Compare(name, __main___str)==0) continue; |
|
867 |
|
868 global_name_attr = PyObject_GetAttr(module, global_name); |
|
869 if (!global_name_attr) { |
|
870 if (PyErr_ExceptionMatches(PyExc_AttributeError)) |
|
871 PyErr_Clear(); |
|
872 else |
|
873 return NULL; |
|
874 continue; |
|
875 } |
|
876 |
|
877 if (global_name_attr != global) { |
|
878 Py_DECREF(global_name_attr); |
|
879 continue; |
|
880 } |
|
881 |
|
882 Py_DECREF(global_name_attr); |
|
883 |
|
884 break; |
|
885 } |
|
886 |
|
887 /* The following implements the rule in pickle.py added in 1.5 |
|
888 that used __main__ if no module is found. I don't actually |
|
889 like this rule. jlf |
|
890 */ |
|
891 if (!j) { |
|
892 j=1; |
|
893 name=__main___str; |
|
894 } |
|
895 |
|
896 Py_INCREF(name); |
|
897 return name; |
|
898 } |
|
899 |
|
900 |
|
901 static int |
|
902 fast_save_enter(Picklerobject *self, PyObject *obj) |
|
903 { |
|
904 /* if fast_container < 0, we're doing an error exit. */ |
|
905 if (++self->fast_container >= PY_CPICKLE_FAST_LIMIT) { |
|
906 PyObject *key = NULL; |
|
907 if (self->fast_memo == NULL) { |
|
908 self->fast_memo = PyDict_New(); |
|
909 if (self->fast_memo == NULL) { |
|
910 self->fast_container = -1; |
|
911 return 0; |
|
912 } |
|
913 } |
|
914 key = PyLong_FromVoidPtr(obj); |
|
915 if (key == NULL) |
|
916 return 0; |
|
917 if (PyDict_GetItem(self->fast_memo, key)) { |
|
918 Py_DECREF(key); |
|
919 PyErr_Format(PyExc_ValueError, |
|
920 "fast mode: can't pickle cyclic objects " |
|
921 "including object type %s at %p", |
|
922 Py_TYPE(obj)->tp_name, obj); |
|
923 self->fast_container = -1; |
|
924 return 0; |
|
925 } |
|
926 if (PyDict_SetItem(self->fast_memo, key, Py_None) < 0) { |
|
927 Py_DECREF(key); |
|
928 self->fast_container = -1; |
|
929 return 0; |
|
930 } |
|
931 Py_DECREF(key); |
|
932 } |
|
933 return 1; |
|
934 } |
|
935 |
|
936 int |
|
937 fast_save_leave(Picklerobject *self, PyObject *obj) |
|
938 { |
|
939 if (self->fast_container-- >= PY_CPICKLE_FAST_LIMIT) { |
|
940 PyObject *key = PyLong_FromVoidPtr(obj); |
|
941 if (key == NULL) |
|
942 return 0; |
|
943 if (PyDict_DelItem(self->fast_memo, key) < 0) { |
|
944 Py_DECREF(key); |
|
945 return 0; |
|
946 } |
|
947 Py_DECREF(key); |
|
948 } |
|
949 return 1; |
|
950 } |
|
951 |
|
952 static int |
|
953 save_none(Picklerobject *self, PyObject *args) |
|
954 { |
|
955 static char none = NONE; |
|
956 if (self->write_func(self, &none, 1) < 0) |
|
957 return -1; |
|
958 |
|
959 return 0; |
|
960 } |
|
961 |
|
962 static int |
|
963 save_bool(Picklerobject *self, PyObject *args) |
|
964 { |
|
965 static const char *buf[2] = {FALSE, TRUE}; |
|
966 static char len[2] = {sizeof(FALSE)-1, sizeof(TRUE)-1}; |
|
967 long l = PyInt_AS_LONG((PyIntObject *)args); |
|
968 |
|
969 if (self->proto >= 2) { |
|
970 char opcode = l ? NEWTRUE : NEWFALSE; |
|
971 if (self->write_func(self, &opcode, 1) < 0) |
|
972 return -1; |
|
973 } |
|
974 else if (self->write_func(self, buf[l], len[l]) < 0) |
|
975 return -1; |
|
976 return 0; |
|
977 } |
|
978 |
|
979 static int |
|
980 save_int(Picklerobject *self, PyObject *args) |
|
981 { |
|
982 char c_str[32]; |
|
983 long l = PyInt_AS_LONG((PyIntObject *)args); |
|
984 int len = 0; |
|
985 |
|
986 if (!self->bin |
|
987 #if SIZEOF_LONG > 4 |
|
988 || l > 0x7fffffffL |
|
989 || l < -0x80000000L |
|
990 #endif |
|
991 ) { |
|
992 /* Text-mode pickle, or long too big to fit in the 4-byte |
|
993 * signed BININT format: store as a string. |
|
994 */ |
|
995 c_str[0] = INT; |
|
996 PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%ld\n", l); |
|
997 if (self->write_func(self, c_str, strlen(c_str)) < 0) |
|
998 return -1; |
|
999 } |
|
1000 else { |
|
1001 /* Binary pickle and l fits in a signed 4-byte int. */ |
|
1002 c_str[1] = (int)( l & 0xff); |
|
1003 c_str[2] = (int)((l >> 8) & 0xff); |
|
1004 c_str[3] = (int)((l >> 16) & 0xff); |
|
1005 c_str[4] = (int)((l >> 24) & 0xff); |
|
1006 |
|
1007 if ((c_str[4] == 0) && (c_str[3] == 0)) { |
|
1008 if (c_str[2] == 0) { |
|
1009 c_str[0] = BININT1; |
|
1010 len = 2; |
|
1011 } |
|
1012 else { |
|
1013 c_str[0] = BININT2; |
|
1014 len = 3; |
|
1015 } |
|
1016 } |
|
1017 else { |
|
1018 c_str[0] = BININT; |
|
1019 len = 5; |
|
1020 } |
|
1021 |
|
1022 if (self->write_func(self, c_str, len) < 0) |
|
1023 return -1; |
|
1024 } |
|
1025 |
|
1026 return 0; |
|
1027 } |
|
1028 |
|
1029 |
|
1030 static int |
|
1031 save_long(Picklerobject *self, PyObject *args) |
|
1032 { |
|
1033 Py_ssize_t size; |
|
1034 int res = -1; |
|
1035 PyObject *repr = NULL; |
|
1036 |
|
1037 static char l = LONG; |
|
1038 |
|
1039 if (self->proto >= 2) { |
|
1040 /* Linear-time pickling. */ |
|
1041 size_t nbits; |
|
1042 size_t nbytes; |
|
1043 unsigned char *pdata; |
|
1044 char c_str[5]; |
|
1045 int i; |
|
1046 int sign = _PyLong_Sign(args); |
|
1047 |
|
1048 if (sign == 0) { |
|
1049 /* It's 0 -- an empty bytestring. */ |
|
1050 c_str[0] = LONG1; |
|
1051 c_str[1] = 0; |
|
1052 i = self->write_func(self, c_str, 2); |
|
1053 if (i < 0) goto finally; |
|
1054 res = 0; |
|
1055 goto finally; |
|
1056 } |
|
1057 nbits = _PyLong_NumBits(args); |
|
1058 if (nbits == (size_t)-1 && PyErr_Occurred()) |
|
1059 goto finally; |
|
1060 /* How many bytes do we need? There are nbits >> 3 full |
|
1061 * bytes of data, and nbits & 7 leftover bits. If there |
|
1062 * are any leftover bits, then we clearly need another |
|
1063 * byte. Wnat's not so obvious is that we *probably* |
|
1064 * need another byte even if there aren't any leftovers: |
|
1065 * the most-significant bit of the most-significant byte |
|
1066 * acts like a sign bit, and it's usually got a sense |
|
1067 * opposite of the one we need. The exception is longs |
|
1068 * of the form -(2**(8*j-1)) for j > 0. Such a long is |
|
1069 * its own 256's-complement, so has the right sign bit |
|
1070 * even without the extra byte. That's a pain to check |
|
1071 * for in advance, though, so we always grab an extra |
|
1072 * byte at the start, and cut it back later if possible. |
|
1073 */ |
|
1074 nbytes = (nbits >> 3) + 1; |
|
1075 if (nbytes > INT_MAX) { |
|
1076 PyErr_SetString(PyExc_OverflowError, "long too large " |
|
1077 "to pickle"); |
|
1078 goto finally; |
|
1079 } |
|
1080 repr = PyString_FromStringAndSize(NULL, (int)nbytes); |
|
1081 if (repr == NULL) goto finally; |
|
1082 pdata = (unsigned char *)PyString_AS_STRING(repr); |
|
1083 i = _PyLong_AsByteArray((PyLongObject *)args, |
|
1084 pdata, nbytes, |
|
1085 1 /* little endian */, 1 /* signed */); |
|
1086 if (i < 0) goto finally; |
|
1087 /* If the long is negative, this may be a byte more than |
|
1088 * needed. This is so iff the MSB is all redundant sign |
|
1089 * bits. |
|
1090 */ |
|
1091 if (sign < 0 && nbytes > 1 && pdata[nbytes - 1] == 0xff && |
|
1092 (pdata[nbytes - 2] & 0x80) != 0) |
|
1093 --nbytes; |
|
1094 |
|
1095 if (nbytes < 256) { |
|
1096 c_str[0] = LONG1; |
|
1097 c_str[1] = (char)nbytes; |
|
1098 size = 2; |
|
1099 } |
|
1100 else { |
|
1101 c_str[0] = LONG4; |
|
1102 size = (int)nbytes; |
|
1103 for (i = 1; i < 5; i++) { |
|
1104 c_str[i] = (char)(size & 0xff); |
|
1105 size >>= 8; |
|
1106 } |
|
1107 size = 5; |
|
1108 } |
|
1109 i = self->write_func(self, c_str, size); |
|
1110 if (i < 0) goto finally; |
|
1111 i = self->write_func(self, (char *)pdata, (int)nbytes); |
|
1112 if (i < 0) goto finally; |
|
1113 res = 0; |
|
1114 goto finally; |
|
1115 } |
|
1116 |
|
1117 /* proto < 2: write the repr and newline. This is quadratic-time |
|
1118 * (in the number of digits), in both directions. |
|
1119 */ |
|
1120 if (!( repr = PyObject_Repr(args))) |
|
1121 goto finally; |
|
1122 |
|
1123 if ((size = PyString_Size(repr)) < 0) |
|
1124 goto finally; |
|
1125 |
|
1126 if (self->write_func(self, &l, 1) < 0) |
|
1127 goto finally; |
|
1128 |
|
1129 if (self->write_func(self, |
|
1130 PyString_AS_STRING((PyStringObject *)repr), |
|
1131 size) < 0) |
|
1132 goto finally; |
|
1133 |
|
1134 if (self->write_func(self, "\n", 1) < 0) |
|
1135 goto finally; |
|
1136 |
|
1137 res = 0; |
|
1138 |
|
1139 finally: |
|
1140 Py_XDECREF(repr); |
|
1141 return res; |
|
1142 } |
|
1143 |
|
1144 |
|
1145 static int |
|
1146 save_float(Picklerobject *self, PyObject *args) |
|
1147 { |
|
1148 double x = PyFloat_AS_DOUBLE((PyFloatObject *)args); |
|
1149 |
|
1150 if (self->bin) { |
|
1151 char str[9]; |
|
1152 str[0] = BINFLOAT; |
|
1153 if (_PyFloat_Pack8(x, (unsigned char *)&str[1], 0) < 0) |
|
1154 return -1; |
|
1155 if (self->write_func(self, str, 9) < 0) |
|
1156 return -1; |
|
1157 } |
|
1158 else { |
|
1159 char c_str[250]; |
|
1160 c_str[0] = FLOAT; |
|
1161 PyOS_ascii_formatd(c_str + 1, sizeof(c_str) - 2, "%.17g", x); |
|
1162 /* Extend the formatted string with a newline character */ |
|
1163 strcat(c_str, "\n"); |
|
1164 |
|
1165 if (self->write_func(self, c_str, strlen(c_str)) < 0) |
|
1166 return -1; |
|
1167 } |
|
1168 |
|
1169 return 0; |
|
1170 } |
|
1171 |
|
1172 |
|
1173 static int |
|
1174 save_string(Picklerobject *self, PyObject *args, int doput) |
|
1175 { |
|
1176 int size, len; |
|
1177 PyObject *repr=0; |
|
1178 |
|
1179 if ((size = PyString_Size(args)) < 0) |
|
1180 return -1; |
|
1181 |
|
1182 if (!self->bin) { |
|
1183 char *repr_str; |
|
1184 |
|
1185 static char string = STRING; |
|
1186 |
|
1187 if (!( repr = PyObject_Repr(args))) |
|
1188 return -1; |
|
1189 |
|
1190 if ((len = PyString_Size(repr)) < 0) |
|
1191 goto err; |
|
1192 repr_str = PyString_AS_STRING((PyStringObject *)repr); |
|
1193 |
|
1194 if (self->write_func(self, &string, 1) < 0) |
|
1195 goto err; |
|
1196 |
|
1197 if (self->write_func(self, repr_str, len) < 0) |
|
1198 goto err; |
|
1199 |
|
1200 if (self->write_func(self, "\n", 1) < 0) |
|
1201 goto err; |
|
1202 |
|
1203 Py_XDECREF(repr); |
|
1204 } |
|
1205 else { |
|
1206 int i; |
|
1207 char c_str[5]; |
|
1208 |
|
1209 if ((size = PyString_Size(args)) < 0) |
|
1210 return -1; |
|
1211 |
|
1212 if (size < 256) { |
|
1213 c_str[0] = SHORT_BINSTRING; |
|
1214 c_str[1] = size; |
|
1215 len = 2; |
|
1216 } |
|
1217 else if (size <= INT_MAX) { |
|
1218 c_str[0] = BINSTRING; |
|
1219 for (i = 1; i < 5; i++) |
|
1220 c_str[i] = (int)(size >> ((i - 1) * 8)); |
|
1221 len = 5; |
|
1222 } |
|
1223 else |
|
1224 return -1; /* string too large */ |
|
1225 |
|
1226 if (self->write_func(self, c_str, len) < 0) |
|
1227 return -1; |
|
1228 |
|
1229 if (size > 128 && Pdata_Check(self->file)) { |
|
1230 if (write_other(self, NULL, 0) < 0) return -1; |
|
1231 PDATA_APPEND(self->file, args, -1); |
|
1232 } |
|
1233 else { |
|
1234 if (self->write_func(self, |
|
1235 PyString_AS_STRING( |
|
1236 (PyStringObject *)args), |
|
1237 size) < 0) |
|
1238 return -1; |
|
1239 } |
|
1240 } |
|
1241 |
|
1242 if (doput) |
|
1243 if (put(self, args) < 0) |
|
1244 return -1; |
|
1245 |
|
1246 return 0; |
|
1247 |
|
1248 err: |
|
1249 Py_XDECREF(repr); |
|
1250 return -1; |
|
1251 } |
|
1252 |
|
1253 |
|
1254 #ifdef Py_USING_UNICODE |
|
1255 /* A copy of PyUnicode_EncodeRawUnicodeEscape() that also translates |
|
1256 backslash and newline characters to \uXXXX escapes. */ |
|
1257 static PyObject * |
|
1258 modified_EncodeRawUnicodeEscape(const Py_UNICODE *s, int size) |
|
1259 { |
|
1260 PyObject *repr; |
|
1261 char *p; |
|
1262 char *q; |
|
1263 |
|
1264 static const char *hexdigit = "0123456789ABCDEF"; |
|
1265 |
|
1266 repr = PyString_FromStringAndSize(NULL, 6 * size); |
|
1267 if (repr == NULL) |
|
1268 return NULL; |
|
1269 if (size == 0) |
|
1270 return repr; |
|
1271 |
|
1272 p = q = PyString_AS_STRING(repr); |
|
1273 while (size-- > 0) { |
|
1274 Py_UNICODE ch = *s++; |
|
1275 /* Map 16-bit characters to '\uxxxx' */ |
|
1276 if (ch >= 256 || ch == '\\' || ch == '\n') { |
|
1277 *p++ = '\\'; |
|
1278 *p++ = 'u'; |
|
1279 *p++ = hexdigit[(ch >> 12) & 0xf]; |
|
1280 *p++ = hexdigit[(ch >> 8) & 0xf]; |
|
1281 *p++ = hexdigit[(ch >> 4) & 0xf]; |
|
1282 *p++ = hexdigit[ch & 15]; |
|
1283 } |
|
1284 /* Copy everything else as-is */ |
|
1285 else |
|
1286 *p++ = (char) ch; |
|
1287 } |
|
1288 *p = '\0'; |
|
1289 _PyString_Resize(&repr, p - q); |
|
1290 return repr; |
|
1291 } |
|
1292 |
|
1293 |
|
1294 static int |
|
1295 save_unicode(Picklerobject *self, PyObject *args, int doput) |
|
1296 { |
|
1297 Py_ssize_t size, len; |
|
1298 PyObject *repr=0; |
|
1299 |
|
1300 if (!PyUnicode_Check(args)) |
|
1301 return -1; |
|
1302 |
|
1303 if (!self->bin) { |
|
1304 char *repr_str; |
|
1305 static char string = UNICODE; |
|
1306 |
|
1307 repr = modified_EncodeRawUnicodeEscape( |
|
1308 PyUnicode_AS_UNICODE(args), PyUnicode_GET_SIZE(args)); |
|
1309 if (!repr) |
|
1310 return -1; |
|
1311 |
|
1312 if ((len = PyString_Size(repr)) < 0) |
|
1313 goto err; |
|
1314 repr_str = PyString_AS_STRING((PyStringObject *)repr); |
|
1315 |
|
1316 if (self->write_func(self, &string, 1) < 0) |
|
1317 goto err; |
|
1318 |
|
1319 if (self->write_func(self, repr_str, len) < 0) |
|
1320 goto err; |
|
1321 |
|
1322 if (self->write_func(self, "\n", 1) < 0) |
|
1323 goto err; |
|
1324 |
|
1325 Py_XDECREF(repr); |
|
1326 } |
|
1327 else { |
|
1328 int i; |
|
1329 char c_str[5]; |
|
1330 |
|
1331 if (!( repr = PyUnicode_AsUTF8String(args))) |
|
1332 return -1; |
|
1333 |
|
1334 if ((size = PyString_Size(repr)) < 0) |
|
1335 goto err; |
|
1336 if (size > INT_MAX) |
|
1337 return -1; /* string too large */ |
|
1338 |
|
1339 c_str[0] = BINUNICODE; |
|
1340 for (i = 1; i < 5; i++) |
|
1341 c_str[i] = (int)(size >> ((i - 1) * 8)); |
|
1342 len = 5; |
|
1343 |
|
1344 if (self->write_func(self, c_str, len) < 0) |
|
1345 goto err; |
|
1346 |
|
1347 if (size > 128 && Pdata_Check(self->file)) { |
|
1348 if (write_other(self, NULL, 0) < 0) |
|
1349 goto err; |
|
1350 PDATA_APPEND(self->file, repr, -1); |
|
1351 } |
|
1352 else { |
|
1353 if (self->write_func(self, PyString_AS_STRING(repr), |
|
1354 size) < 0) |
|
1355 goto err; |
|
1356 } |
|
1357 |
|
1358 Py_DECREF(repr); |
|
1359 } |
|
1360 |
|
1361 if (doput) |
|
1362 if (put(self, args) < 0) |
|
1363 return -1; |
|
1364 |
|
1365 return 0; |
|
1366 |
|
1367 err: |
|
1368 Py_XDECREF(repr); |
|
1369 return -1; |
|
1370 } |
|
1371 #endif |
|
1372 |
|
1373 /* A helper for save_tuple. Push the len elements in tuple t on the stack. */ |
|
1374 static int |
|
1375 store_tuple_elements(Picklerobject *self, PyObject *t, int len) |
|
1376 { |
|
1377 int i; |
|
1378 int res = -1; /* guilty until proved innocent */ |
|
1379 |
|
1380 assert(PyTuple_Size(t) == len); |
|
1381 |
|
1382 for (i = 0; i < len; i++) { |
|
1383 PyObject *element = PyTuple_GET_ITEM(t, i); |
|
1384 |
|
1385 if (element == NULL) |
|
1386 goto finally; |
|
1387 if (save(self, element, 0) < 0) |
|
1388 goto finally; |
|
1389 } |
|
1390 res = 0; |
|
1391 |
|
1392 finally: |
|
1393 return res; |
|
1394 } |
|
1395 |
|
1396 /* Tuples are ubiquitous in the pickle protocols, so many techniques are |
|
1397 * used across protocols to minimize the space needed to pickle them. |
|
1398 * Tuples are also the only builtin immutable type that can be recursive |
|
1399 * (a tuple can be reached from itself), and that requires some subtle |
|
1400 * magic so that it works in all cases. IOW, this is a long routine. |
|
1401 */ |
|
1402 static int |
|
1403 save_tuple(Picklerobject *self, PyObject *args) |
|
1404 { |
|
1405 PyObject *py_tuple_id = NULL; |
|
1406 int len, i; |
|
1407 int res = -1; |
|
1408 |
|
1409 static char tuple = TUPLE; |
|
1410 static char pop = POP; |
|
1411 static char pop_mark = POP_MARK; |
|
1412 static char len2opcode[] = {EMPTY_TUPLE, TUPLE1, TUPLE2, TUPLE3}; |
|
1413 |
|
1414 if ((len = PyTuple_Size(args)) < 0) |
|
1415 goto finally; |
|
1416 |
|
1417 if (len == 0) { |
|
1418 char c_str[2]; |
|
1419 |
|
1420 if (self->proto) { |
|
1421 c_str[0] = EMPTY_TUPLE; |
|
1422 len = 1; |
|
1423 } |
|
1424 else { |
|
1425 c_str[0] = MARK; |
|
1426 c_str[1] = TUPLE; |
|
1427 len = 2; |
|
1428 } |
|
1429 if (self->write_func(self, c_str, len) >= 0) |
|
1430 res = 0; |
|
1431 /* Don't memoize an empty tuple. */ |
|
1432 goto finally; |
|
1433 } |
|
1434 |
|
1435 /* A non-empty tuple. */ |
|
1436 |
|
1437 /* id(tuple) isn't in the memo now. If it shows up there after |
|
1438 * saving the tuple elements, the tuple must be recursive, in |
|
1439 * which case we'll pop everything we put on the stack, and fetch |
|
1440 * its value from the memo. |
|
1441 */ |
|
1442 py_tuple_id = PyLong_FromVoidPtr(args); |
|
1443 if (py_tuple_id == NULL) |
|
1444 goto finally; |
|
1445 |
|
1446 if (len <= 3 && self->proto >= 2) { |
|
1447 /* Use TUPLE{1,2,3} opcodes. */ |
|
1448 if (store_tuple_elements(self, args, len) < 0) |
|
1449 goto finally; |
|
1450 if (PyDict_GetItem(self->memo, py_tuple_id)) { |
|
1451 /* pop the len elements */ |
|
1452 for (i = 0; i < len; ++i) |
|
1453 if (self->write_func(self, &pop, 1) < 0) |
|
1454 goto finally; |
|
1455 /* fetch from memo */ |
|
1456 if (get(self, py_tuple_id) < 0) |
|
1457 goto finally; |
|
1458 res = 0; |
|
1459 goto finally; |
|
1460 } |
|
1461 /* Not recursive. */ |
|
1462 if (self->write_func(self, len2opcode + len, 1) < 0) |
|
1463 goto finally; |
|
1464 goto memoize; |
|
1465 } |
|
1466 |
|
1467 /* proto < 2 and len > 0, or proto >= 2 and len > 3. |
|
1468 * Generate MARK elt1 elt2 ... TUPLE |
|
1469 */ |
|
1470 if (self->write_func(self, &MARKv, 1) < 0) |
|
1471 goto finally; |
|
1472 |
|
1473 if (store_tuple_elements(self, args, len) < 0) |
|
1474 goto finally; |
|
1475 |
|
1476 if (PyDict_GetItem(self->memo, py_tuple_id)) { |
|
1477 /* pop the stack stuff we pushed */ |
|
1478 if (self->bin) { |
|
1479 if (self->write_func(self, &pop_mark, 1) < 0) |
|
1480 goto finally; |
|
1481 } |
|
1482 else { |
|
1483 /* Note that we pop one more than len, to remove |
|
1484 * the MARK too. |
|
1485 */ |
|
1486 for (i = 0; i <= len; i++) |
|
1487 if (self->write_func(self, &pop, 1) < 0) |
|
1488 goto finally; |
|
1489 } |
|
1490 /* fetch from memo */ |
|
1491 if (get(self, py_tuple_id) >= 0) |
|
1492 res = 0; |
|
1493 goto finally; |
|
1494 } |
|
1495 |
|
1496 /* Not recursive. */ |
|
1497 if (self->write_func(self, &tuple, 1) < 0) |
|
1498 goto finally; |
|
1499 |
|
1500 memoize: |
|
1501 if (put(self, args) >= 0) |
|
1502 res = 0; |
|
1503 |
|
1504 finally: |
|
1505 Py_XDECREF(py_tuple_id); |
|
1506 return res; |
|
1507 } |
|
1508 |
|
1509 /* iter is an iterator giving items, and we batch up chunks of |
|
1510 * MARK item item ... item APPENDS |
|
1511 * opcode sequences. Calling code should have arranged to first create an |
|
1512 * empty list, or list-like object, for the APPENDS to operate on. |
|
1513 * Returns 0 on success, <0 on error. |
|
1514 */ |
|
1515 static int |
|
1516 batch_list(Picklerobject *self, PyObject *iter) |
|
1517 { |
|
1518 PyObject *obj = NULL; |
|
1519 PyObject *firstitem = NULL; |
|
1520 int i, n; |
|
1521 |
|
1522 static char append = APPEND; |
|
1523 static char appends = APPENDS; |
|
1524 |
|
1525 assert(iter != NULL); |
|
1526 |
|
1527 if (self->proto == 0) { |
|
1528 /* APPENDS isn't available; do one at a time. */ |
|
1529 for (;;) { |
|
1530 obj = PyIter_Next(iter); |
|
1531 if (obj == NULL) { |
|
1532 if (PyErr_Occurred()) |
|
1533 return -1; |
|
1534 break; |
|
1535 } |
|
1536 i = save(self, obj, 0); |
|
1537 Py_DECREF(obj); |
|
1538 if (i < 0) |
|
1539 return -1; |
|
1540 if (self->write_func(self, &append, 1) < 0) |
|
1541 return -1; |
|
1542 } |
|
1543 return 0; |
|
1544 } |
|
1545 |
|
1546 /* proto > 0: write in batches of BATCHSIZE. */ |
|
1547 do { |
|
1548 /* Get first item */ |
|
1549 firstitem = PyIter_Next(iter); |
|
1550 if (firstitem == NULL) { |
|
1551 if (PyErr_Occurred()) |
|
1552 goto BatchFailed; |
|
1553 |
|
1554 /* nothing more to add */ |
|
1555 break; |
|
1556 } |
|
1557 |
|
1558 /* Try to get a second item */ |
|
1559 obj = PyIter_Next(iter); |
|
1560 if (obj == NULL) { |
|
1561 if (PyErr_Occurred()) |
|
1562 goto BatchFailed; |
|
1563 |
|
1564 /* Only one item to write */ |
|
1565 if (save(self, firstitem, 0) < 0) |
|
1566 goto BatchFailed; |
|
1567 if (self->write_func(self, &append, 1) < 0) |
|
1568 goto BatchFailed; |
|
1569 Py_CLEAR(firstitem); |
|
1570 break; |
|
1571 } |
|
1572 |
|
1573 /* More than one item to write */ |
|
1574 |
|
1575 /* Pump out MARK, items, APPENDS. */ |
|
1576 if (self->write_func(self, &MARKv, 1) < 0) |
|
1577 goto BatchFailed; |
|
1578 |
|
1579 if (save(self, firstitem, 0) < 0) |
|
1580 goto BatchFailed; |
|
1581 Py_CLEAR(firstitem); |
|
1582 n = 1; |
|
1583 |
|
1584 /* Fetch and save up to BATCHSIZE items */ |
|
1585 while (obj) { |
|
1586 if (save(self, obj, 0) < 0) |
|
1587 goto BatchFailed; |
|
1588 Py_CLEAR(obj); |
|
1589 n += 1; |
|
1590 |
|
1591 if (n == BATCHSIZE) |
|
1592 break; |
|
1593 |
|
1594 obj = PyIter_Next(iter); |
|
1595 if (obj == NULL) { |
|
1596 if (PyErr_Occurred()) |
|
1597 goto BatchFailed; |
|
1598 break; |
|
1599 } |
|
1600 } |
|
1601 |
|
1602 if (self->write_func(self, &appends, 1) < 0) |
|
1603 goto BatchFailed; |
|
1604 |
|
1605 } while (n == BATCHSIZE); |
|
1606 return 0; |
|
1607 |
|
1608 BatchFailed: |
|
1609 Py_XDECREF(firstitem); |
|
1610 Py_XDECREF(obj); |
|
1611 return -1; |
|
1612 } |
|
1613 |
|
1614 static int |
|
1615 save_list(Picklerobject *self, PyObject *args) |
|
1616 { |
|
1617 int res = -1; |
|
1618 char s[3]; |
|
1619 int len; |
|
1620 PyObject *iter; |
|
1621 |
|
1622 if (self->fast && !fast_save_enter(self, args)) |
|
1623 goto finally; |
|
1624 |
|
1625 /* Create an empty list. */ |
|
1626 if (self->bin) { |
|
1627 s[0] = EMPTY_LIST; |
|
1628 len = 1; |
|
1629 } |
|
1630 else { |
|
1631 s[0] = MARK; |
|
1632 s[1] = LIST; |
|
1633 len = 2; |
|
1634 } |
|
1635 |
|
1636 if (self->write_func(self, s, len) < 0) |
|
1637 goto finally; |
|
1638 |
|
1639 /* Get list length, and bow out early if empty. */ |
|
1640 if ((len = PyList_Size(args)) < 0) |
|
1641 goto finally; |
|
1642 |
|
1643 /* Memoize. */ |
|
1644 if (len == 0) { |
|
1645 if (put(self, args) >= 0) |
|
1646 res = 0; |
|
1647 goto finally; |
|
1648 } |
|
1649 if (put2(self, args) < 0) |
|
1650 goto finally; |
|
1651 |
|
1652 /* Materialize the list elements. */ |
|
1653 iter = PyObject_GetIter(args); |
|
1654 if (iter == NULL) |
|
1655 goto finally; |
|
1656 |
|
1657 if (Py_EnterRecursiveCall(" while pickling an object") == 0) |
|
1658 { |
|
1659 res = batch_list(self, iter); |
|
1660 Py_LeaveRecursiveCall(); |
|
1661 } |
|
1662 Py_DECREF(iter); |
|
1663 |
|
1664 finally: |
|
1665 if (self->fast && !fast_save_leave(self, args)) |
|
1666 res = -1; |
|
1667 |
|
1668 return res; |
|
1669 } |
|
1670 |
|
1671 |
|
1672 /* iter is an iterator giving (key, value) pairs, and we batch up chunks of |
|
1673 * MARK key value ... key value SETITEMS |
|
1674 * opcode sequences. Calling code should have arranged to first create an |
|
1675 * empty dict, or dict-like object, for the SETITEMS to operate on. |
|
1676 * Returns 0 on success, <0 on error. |
|
1677 * |
|
1678 * This is very much like batch_list(). The difference between saving |
|
1679 * elements directly, and picking apart two-tuples, is so long-winded at |
|
1680 * the C level, though, that attempts to combine these routines were too |
|
1681 * ugly to bear. |
|
1682 */ |
|
1683 static int |
|
1684 batch_dict(Picklerobject *self, PyObject *iter) |
|
1685 { |
|
1686 PyObject *p = NULL; |
|
1687 PyObject *firstitem = NULL; |
|
1688 int i, n; |
|
1689 |
|
1690 static char setitem = SETITEM; |
|
1691 static char setitems = SETITEMS; |
|
1692 |
|
1693 assert(iter != NULL); |
|
1694 |
|
1695 if (self->proto == 0) { |
|
1696 /* SETITEMS isn't available; do one at a time. */ |
|
1697 for (;;) { |
|
1698 p = PyIter_Next(iter); |
|
1699 if (p == NULL) { |
|
1700 if (PyErr_Occurred()) |
|
1701 return -1; |
|
1702 break; |
|
1703 } |
|
1704 if (!PyTuple_Check(p) || PyTuple_Size(p) != 2) { |
|
1705 PyErr_SetString(PyExc_TypeError, "dict items " |
|
1706 "iterator must return 2-tuples"); |
|
1707 return -1; |
|
1708 } |
|
1709 i = save(self, PyTuple_GET_ITEM(p, 0), 0); |
|
1710 if (i >= 0) |
|
1711 i = save(self, PyTuple_GET_ITEM(p, 1), 0); |
|
1712 Py_DECREF(p); |
|
1713 if (i < 0) |
|
1714 return -1; |
|
1715 if (self->write_func(self, &setitem, 1) < 0) |
|
1716 return -1; |
|
1717 } |
|
1718 return 0; |
|
1719 } |
|
1720 |
|
1721 /* proto > 0: write in batches of BATCHSIZE. */ |
|
1722 do { |
|
1723 /* Get first item */ |
|
1724 firstitem = PyIter_Next(iter); |
|
1725 if (firstitem == NULL) { |
|
1726 if (PyErr_Occurred()) |
|
1727 goto BatchFailed; |
|
1728 |
|
1729 /* nothing more to add */ |
|
1730 break; |
|
1731 } |
|
1732 if (!PyTuple_Check(firstitem) || PyTuple_Size(firstitem) != 2) { |
|
1733 PyErr_SetString(PyExc_TypeError, "dict items " |
|
1734 "iterator must return 2-tuples"); |
|
1735 goto BatchFailed; |
|
1736 } |
|
1737 |
|
1738 /* Try to get a second item */ |
|
1739 p = PyIter_Next(iter); |
|
1740 if (p == NULL) { |
|
1741 if (PyErr_Occurred()) |
|
1742 goto BatchFailed; |
|
1743 |
|
1744 /* Only one item to write */ |
|
1745 if (save(self, PyTuple_GET_ITEM(firstitem, 0), 0) < 0) |
|
1746 goto BatchFailed; |
|
1747 if (save(self, PyTuple_GET_ITEM(firstitem, 1), 0) < 0) |
|
1748 goto BatchFailed; |
|
1749 if (self->write_func(self, &setitem, 1) < 0) |
|
1750 goto BatchFailed; |
|
1751 Py_CLEAR(firstitem); |
|
1752 break; |
|
1753 } |
|
1754 |
|
1755 /* More than one item to write */ |
|
1756 |
|
1757 /* Pump out MARK, items, SETITEMS. */ |
|
1758 if (self->write_func(self, &MARKv, 1) < 0) |
|
1759 goto BatchFailed; |
|
1760 |
|
1761 if (save(self, PyTuple_GET_ITEM(firstitem, 0), 0) < 0) |
|
1762 goto BatchFailed; |
|
1763 if (save(self, PyTuple_GET_ITEM(firstitem, 1), 0) < 0) |
|
1764 goto BatchFailed; |
|
1765 Py_CLEAR(firstitem); |
|
1766 n = 1; |
|
1767 |
|
1768 /* Fetch and save up to BATCHSIZE items */ |
|
1769 while (p) { |
|
1770 if (!PyTuple_Check(p) || PyTuple_Size(p) != 2) { |
|
1771 PyErr_SetString(PyExc_TypeError, "dict items " |
|
1772 "iterator must return 2-tuples"); |
|
1773 goto BatchFailed; |
|
1774 } |
|
1775 if (save(self, PyTuple_GET_ITEM(p, 0), 0) < 0) |
|
1776 goto BatchFailed; |
|
1777 if (save(self, PyTuple_GET_ITEM(p, 1), 0) < 0) |
|
1778 goto BatchFailed; |
|
1779 Py_CLEAR(p); |
|
1780 n += 1; |
|
1781 |
|
1782 if (n == BATCHSIZE) |
|
1783 break; |
|
1784 |
|
1785 p = PyIter_Next(iter); |
|
1786 if (p == NULL) { |
|
1787 if (PyErr_Occurred()) |
|
1788 goto BatchFailed; |
|
1789 break; |
|
1790 } |
|
1791 } |
|
1792 |
|
1793 if (self->write_func(self, &setitems, 1) < 0) |
|
1794 goto BatchFailed; |
|
1795 |
|
1796 } while (n == BATCHSIZE); |
|
1797 return 0; |
|
1798 |
|
1799 BatchFailed: |
|
1800 Py_XDECREF(firstitem); |
|
1801 Py_XDECREF(p); |
|
1802 return -1; |
|
1803 } |
|
1804 |
|
1805 static int |
|
1806 save_dict(Picklerobject *self, PyObject *args) |
|
1807 { |
|
1808 int res = -1; |
|
1809 char s[3]; |
|
1810 int len; |
|
1811 PyObject *iter; |
|
1812 |
|
1813 if (self->fast && !fast_save_enter(self, args)) |
|
1814 goto finally; |
|
1815 |
|
1816 /* Create an empty dict. */ |
|
1817 if (self->bin) { |
|
1818 s[0] = EMPTY_DICT; |
|
1819 len = 1; |
|
1820 } |
|
1821 else { |
|
1822 s[0] = MARK; |
|
1823 s[1] = DICT; |
|
1824 len = 2; |
|
1825 } |
|
1826 |
|
1827 if (self->write_func(self, s, len) < 0) |
|
1828 goto finally; |
|
1829 |
|
1830 /* Get dict size, and bow out early if empty. */ |
|
1831 if ((len = PyDict_Size(args)) < 0) |
|
1832 goto finally; |
|
1833 |
|
1834 if (len == 0) { |
|
1835 if (put(self, args) >= 0) |
|
1836 res = 0; |
|
1837 goto finally; |
|
1838 } |
|
1839 if (put2(self, args) < 0) |
|
1840 goto finally; |
|
1841 |
|
1842 /* Materialize the dict items. */ |
|
1843 iter = PyObject_CallMethod(args, "iteritems", "()"); |
|
1844 if (iter == NULL) |
|
1845 goto finally; |
|
1846 if (Py_EnterRecursiveCall(" while pickling an object") == 0) |
|
1847 { |
|
1848 res = batch_dict(self, iter); |
|
1849 Py_LeaveRecursiveCall(); |
|
1850 } |
|
1851 Py_DECREF(iter); |
|
1852 |
|
1853 finally: |
|
1854 if (self->fast && !fast_save_leave(self, args)) |
|
1855 res = -1; |
|
1856 |
|
1857 return res; |
|
1858 } |
|
1859 |
|
1860 |
|
1861 static int |
|
1862 save_inst(Picklerobject *self, PyObject *args) |
|
1863 { |
|
1864 PyObject *class = 0, *module = 0, *name = 0, *state = 0, |
|
1865 *getinitargs_func = 0, *getstate_func = 0, *class_args = 0; |
|
1866 char *module_str, *name_str; |
|
1867 int module_size, name_size, res = -1; |
|
1868 |
|
1869 static char inst = INST, obj = OBJ, build = BUILD; |
|
1870 |
|
1871 if (self->fast && !fast_save_enter(self, args)) |
|
1872 goto finally; |
|
1873 |
|
1874 if (self->write_func(self, &MARKv, 1) < 0) |
|
1875 goto finally; |
|
1876 |
|
1877 if (!( class = PyObject_GetAttr(args, __class___str))) |
|
1878 goto finally; |
|
1879 |
|
1880 if (self->bin) { |
|
1881 if (save(self, class, 0) < 0) |
|
1882 goto finally; |
|
1883 } |
|
1884 |
|
1885 if ((getinitargs_func = PyObject_GetAttr(args, __getinitargs___str))) { |
|
1886 PyObject *element = 0; |
|
1887 int i, len; |
|
1888 |
|
1889 if (!( class_args = |
|
1890 PyObject_Call(getinitargs_func, empty_tuple, NULL))) |
|
1891 goto finally; |
|
1892 |
|
1893 if ((len = PyObject_Size(class_args)) < 0) |
|
1894 goto finally; |
|
1895 |
|
1896 for (i = 0; i < len; i++) { |
|
1897 if (!( element = PySequence_GetItem(class_args, i))) |
|
1898 goto finally; |
|
1899 |
|
1900 if (save(self, element, 0) < 0) { |
|
1901 Py_DECREF(element); |
|
1902 goto finally; |
|
1903 } |
|
1904 |
|
1905 Py_DECREF(element); |
|
1906 } |
|
1907 } |
|
1908 else { |
|
1909 if (PyErr_ExceptionMatches(PyExc_AttributeError)) |
|
1910 PyErr_Clear(); |
|
1911 else |
|
1912 goto finally; |
|
1913 } |
|
1914 |
|
1915 if (!self->bin) { |
|
1916 if (!( name = ((PyClassObject *)class)->cl_name )) { |
|
1917 PyErr_SetString(PicklingError, "class has no name"); |
|
1918 goto finally; |
|
1919 } |
|
1920 |
|
1921 if (!( module = whichmodule(class, name))) |
|
1922 goto finally; |
|
1923 |
|
1924 |
|
1925 if ((module_size = PyString_Size(module)) < 0 || |
|
1926 (name_size = PyString_Size(name)) < 0) |
|
1927 goto finally; |
|
1928 |
|
1929 module_str = PyString_AS_STRING((PyStringObject *)module); |
|
1930 name_str = PyString_AS_STRING((PyStringObject *)name); |
|
1931 |
|
1932 if (self->write_func(self, &inst, 1) < 0) |
|
1933 goto finally; |
|
1934 |
|
1935 if (self->write_func(self, module_str, module_size) < 0) |
|
1936 goto finally; |
|
1937 |
|
1938 if (self->write_func(self, "\n", 1) < 0) |
|
1939 goto finally; |
|
1940 |
|
1941 if (self->write_func(self, name_str, name_size) < 0) |
|
1942 goto finally; |
|
1943 |
|
1944 if (self->write_func(self, "\n", 1) < 0) |
|
1945 goto finally; |
|
1946 } |
|
1947 else if (self->write_func(self, &obj, 1) < 0) { |
|
1948 goto finally; |
|
1949 } |
|
1950 |
|
1951 if ((getstate_func = PyObject_GetAttr(args, __getstate___str))) { |
|
1952 state = PyObject_Call(getstate_func, empty_tuple, NULL); |
|
1953 if (!state) |
|
1954 goto finally; |
|
1955 } |
|
1956 else { |
|
1957 if (PyErr_ExceptionMatches(PyExc_AttributeError)) |
|
1958 PyErr_Clear(); |
|
1959 else |
|
1960 goto finally; |
|
1961 |
|
1962 if (!( state = PyObject_GetAttr(args, __dict___str))) { |
|
1963 if (PyErr_ExceptionMatches(PyExc_AttributeError)) |
|
1964 PyErr_Clear(); |
|
1965 else |
|
1966 goto finally; |
|
1967 res = 0; |
|
1968 goto finally; |
|
1969 } |
|
1970 } |
|
1971 |
|
1972 if (!PyDict_Check(state)) { |
|
1973 if (put2(self, args) < 0) |
|
1974 goto finally; |
|
1975 } |
|
1976 else { |
|
1977 if (put(self, args) < 0) |
|
1978 goto finally; |
|
1979 } |
|
1980 |
|
1981 if (save(self, state, 0) < 0) |
|
1982 goto finally; |
|
1983 |
|
1984 if (self->write_func(self, &build, 1) < 0) |
|
1985 goto finally; |
|
1986 |
|
1987 res = 0; |
|
1988 |
|
1989 finally: |
|
1990 if (self->fast && !fast_save_leave(self, args)) |
|
1991 res = -1; |
|
1992 |
|
1993 Py_XDECREF(module); |
|
1994 Py_XDECREF(class); |
|
1995 Py_XDECREF(state); |
|
1996 Py_XDECREF(getinitargs_func); |
|
1997 Py_XDECREF(getstate_func); |
|
1998 Py_XDECREF(class_args); |
|
1999 |
|
2000 return res; |
|
2001 } |
|
2002 |
|
2003 |
|
2004 static int |
|
2005 save_global(Picklerobject *self, PyObject *args, PyObject *name) |
|
2006 { |
|
2007 PyObject *global_name = 0, *module = 0, *mod = 0, *klass = 0; |
|
2008 char *name_str, *module_str; |
|
2009 int module_size, name_size, res = -1; |
|
2010 |
|
2011 static char global = GLOBAL; |
|
2012 |
|
2013 if (name) { |
|
2014 global_name = name; |
|
2015 Py_INCREF(global_name); |
|
2016 } |
|
2017 else { |
|
2018 if (!( global_name = PyObject_GetAttr(args, __name___str))) |
|
2019 goto finally; |
|
2020 } |
|
2021 |
|
2022 if (!( module = whichmodule(args, global_name))) |
|
2023 goto finally; |
|
2024 |
|
2025 if ((module_size = PyString_Size(module)) < 0 || |
|
2026 (name_size = PyString_Size(global_name)) < 0) |
|
2027 goto finally; |
|
2028 |
|
2029 module_str = PyString_AS_STRING((PyStringObject *)module); |
|
2030 name_str = PyString_AS_STRING((PyStringObject *)global_name); |
|
2031 |
|
2032 /* XXX This can be doing a relative import. Clearly it shouldn't, |
|
2033 but I don't know how to stop it. :-( */ |
|
2034 mod = PyImport_ImportModule(module_str); |
|
2035 if (mod == NULL) { |
|
2036 cPickle_ErrFormat(PicklingError, |
|
2037 "Can't pickle %s: import of module %s " |
|
2038 "failed", |
|
2039 "OS", args, module); |
|
2040 goto finally; |
|
2041 } |
|
2042 klass = PyObject_GetAttrString(mod, name_str); |
|
2043 if (klass == NULL) { |
|
2044 cPickle_ErrFormat(PicklingError, |
|
2045 "Can't pickle %s: attribute lookup %s.%s " |
|
2046 "failed", |
|
2047 "OSS", args, module, global_name); |
|
2048 goto finally; |
|
2049 } |
|
2050 if (klass != args) { |
|
2051 Py_DECREF(klass); |
|
2052 cPickle_ErrFormat(PicklingError, |
|
2053 "Can't pickle %s: it's not the same object " |
|
2054 "as %s.%s", |
|
2055 "OSS", args, module, global_name); |
|
2056 goto finally; |
|
2057 } |
|
2058 Py_DECREF(klass); |
|
2059 |
|
2060 if (self->proto >= 2) { |
|
2061 /* See whether this is in the extension registry, and if |
|
2062 * so generate an EXT opcode. |
|
2063 */ |
|
2064 PyObject *py_code; /* extension code as Python object */ |
|
2065 long code; /* extension code as C value */ |
|
2066 char c_str[5]; |
|
2067 int n; |
|
2068 |
|
2069 PyTuple_SET_ITEM(two_tuple, 0, module); |
|
2070 PyTuple_SET_ITEM(two_tuple, 1, global_name); |
|
2071 py_code = PyDict_GetItem(extension_registry, two_tuple); |
|
2072 if (py_code == NULL) |
|
2073 goto gen_global; /* not registered */ |
|
2074 |
|
2075 /* Verify py_code has the right type and value. */ |
|
2076 if (!PyInt_Check(py_code)) { |
|
2077 cPickle_ErrFormat(PicklingError, "Can't pickle %s: " |
|
2078 "extension code %s isn't an integer", |
|
2079 "OO", args, py_code); |
|
2080 goto finally; |
|
2081 } |
|
2082 code = PyInt_AS_LONG(py_code); |
|
2083 if (code <= 0 || code > 0x7fffffffL) { |
|
2084 cPickle_ErrFormat(PicklingError, "Can't pickle %s: " |
|
2085 "extension code %ld is out of range", |
|
2086 "Ol", args, code); |
|
2087 goto finally; |
|
2088 } |
|
2089 |
|
2090 /* Generate an EXT opcode. */ |
|
2091 if (code <= 0xff) { |
|
2092 c_str[0] = EXT1; |
|
2093 c_str[1] = (char)code; |
|
2094 n = 2; |
|
2095 } |
|
2096 else if (code <= 0xffff) { |
|
2097 c_str[0] = EXT2; |
|
2098 c_str[1] = (char)(code & 0xff); |
|
2099 c_str[2] = (char)((code >> 8) & 0xff); |
|
2100 n = 3; |
|
2101 } |
|
2102 else { |
|
2103 c_str[0] = EXT4; |
|
2104 c_str[1] = (char)(code & 0xff); |
|
2105 c_str[2] = (char)((code >> 8) & 0xff); |
|
2106 c_str[3] = (char)((code >> 16) & 0xff); |
|
2107 c_str[4] = (char)((code >> 24) & 0xff); |
|
2108 n = 5; |
|
2109 } |
|
2110 |
|
2111 if (self->write_func(self, c_str, n) >= 0) |
|
2112 res = 0; |
|
2113 goto finally; /* and don't memoize */ |
|
2114 } |
|
2115 |
|
2116 gen_global: |
|
2117 if (self->write_func(self, &global, 1) < 0) |
|
2118 goto finally; |
|
2119 |
|
2120 if (self->write_func(self, module_str, module_size) < 0) |
|
2121 goto finally; |
|
2122 |
|
2123 if (self->write_func(self, "\n", 1) < 0) |
|
2124 goto finally; |
|
2125 |
|
2126 if (self->write_func(self, name_str, name_size) < 0) |
|
2127 goto finally; |
|
2128 |
|
2129 if (self->write_func(self, "\n", 1) < 0) |
|
2130 goto finally; |
|
2131 |
|
2132 if (put(self, args) < 0) |
|
2133 goto finally; |
|
2134 |
|
2135 res = 0; |
|
2136 |
|
2137 finally: |
|
2138 Py_XDECREF(module); |
|
2139 Py_XDECREF(global_name); |
|
2140 Py_XDECREF(mod); |
|
2141 |
|
2142 return res; |
|
2143 } |
|
2144 |
|
2145 static int |
|
2146 save_pers(Picklerobject *self, PyObject *args, PyObject *f) |
|
2147 { |
|
2148 PyObject *pid = 0; |
|
2149 int size, res = -1; |
|
2150 |
|
2151 static char persid = PERSID, binpersid = BINPERSID; |
|
2152 |
|
2153 Py_INCREF(args); |
|
2154 ARG_TUP(self, args); |
|
2155 if (self->arg) { |
|
2156 pid = PyObject_Call(f, self->arg, NULL); |
|
2157 FREE_ARG_TUP(self); |
|
2158 } |
|
2159 if (! pid) return -1; |
|
2160 |
|
2161 if (pid != Py_None) { |
|
2162 if (!self->bin) { |
|
2163 if (!PyString_Check(pid)) { |
|
2164 PyErr_SetString(PicklingError, |
|
2165 "persistent id must be string"); |
|
2166 goto finally; |
|
2167 } |
|
2168 |
|
2169 if (self->write_func(self, &persid, 1) < 0) |
|
2170 goto finally; |
|
2171 |
|
2172 if ((size = PyString_Size(pid)) < 0) |
|
2173 goto finally; |
|
2174 |
|
2175 if (self->write_func(self, |
|
2176 PyString_AS_STRING( |
|
2177 (PyStringObject *)pid), |
|
2178 size) < 0) |
|
2179 goto finally; |
|
2180 |
|
2181 if (self->write_func(self, "\n", 1) < 0) |
|
2182 goto finally; |
|
2183 |
|
2184 res = 1; |
|
2185 goto finally; |
|
2186 } |
|
2187 else if (save(self, pid, 1) >= 0) { |
|
2188 if (self->write_func(self, &binpersid, 1) < 0) |
|
2189 res = -1; |
|
2190 else |
|
2191 res = 1; |
|
2192 } |
|
2193 |
|
2194 goto finally; |
|
2195 } |
|
2196 |
|
2197 res = 0; |
|
2198 |
|
2199 finally: |
|
2200 Py_XDECREF(pid); |
|
2201 |
|
2202 return res; |
|
2203 } |
|
2204 |
|
2205 /* We're saving ob, and args is the 2-thru-5 tuple returned by the |
|
2206 * appropriate __reduce__ method for ob. |
|
2207 */ |
|
2208 static int |
|
2209 save_reduce(Picklerobject *self, PyObject *args, PyObject *fn, PyObject *ob) |
|
2210 { |
|
2211 PyObject *callable; |
|
2212 PyObject *argtup; |
|
2213 PyObject *state = NULL; |
|
2214 PyObject *listitems = Py_None; |
|
2215 PyObject *dictitems = Py_None; |
|
2216 Py_ssize_t size; |
|
2217 |
|
2218 int use_newobj = self->proto >= 2; |
|
2219 |
|
2220 static char reduce = REDUCE; |
|
2221 static char build = BUILD; |
|
2222 static char newobj = NEWOBJ; |
|
2223 |
|
2224 size = PyTuple_Size(args); |
|
2225 if (size < 2 || size > 5) { |
|
2226 cPickle_ErrFormat(PicklingError, "tuple returned by " |
|
2227 "%s must contain 2 through 5 elements", |
|
2228 "O", fn); |
|
2229 return -1; |
|
2230 } |
|
2231 |
|
2232 if (! PyArg_UnpackTuple(args, "save_reduce", 2, 5, |
|
2233 &callable, |
|
2234 &argtup, |
|
2235 &state, |
|
2236 &listitems, |
|
2237 &dictitems)) |
|
2238 return -1; |
|
2239 |
|
2240 if (!PyTuple_Check(argtup)) { |
|
2241 cPickle_ErrFormat(PicklingError, "Second element of " |
|
2242 "tuple returned by %s must be a tuple", |
|
2243 "O", fn); |
|
2244 return -1; |
|
2245 } |
|
2246 |
|
2247 if (state == Py_None) |
|
2248 state = NULL; |
|
2249 |
|
2250 if (listitems == Py_None) |
|
2251 listitems = NULL; |
|
2252 else if (!PyIter_Check(listitems)) { |
|
2253 cPickle_ErrFormat(PicklingError, "Fourth element of " |
|
2254 "tuple returned by %s must be an iterator, not %s", |
|
2255 "Os", fn, Py_TYPE(listitems)->tp_name); |
|
2256 return -1; |
|
2257 } |
|
2258 |
|
2259 if (dictitems == Py_None) |
|
2260 dictitems = NULL; |
|
2261 else if (!PyIter_Check(dictitems)) { |
|
2262 cPickle_ErrFormat(PicklingError, "Fifth element of " |
|
2263 "tuple returned by %s must be an iterator, not %s", |
|
2264 "Os", fn, Py_TYPE(dictitems)->tp_name); |
|
2265 return -1; |
|
2266 } |
|
2267 |
|
2268 /* Protocol 2 special case: if callable's name is __newobj__, use |
|
2269 * NEWOBJ. This consumes a lot of code. |
|
2270 */ |
|
2271 if (use_newobj) { |
|
2272 PyObject *temp = PyObject_GetAttr(callable, __name___str); |
|
2273 |
|
2274 if (temp == NULL) { |
|
2275 if (PyErr_ExceptionMatches(PyExc_AttributeError)) |
|
2276 PyErr_Clear(); |
|
2277 else |
|
2278 return -1; |
|
2279 use_newobj = 0; |
|
2280 } |
|
2281 else { |
|
2282 use_newobj = PyString_Check(temp) && |
|
2283 strcmp(PyString_AS_STRING(temp), |
|
2284 "__newobj__") == 0; |
|
2285 Py_DECREF(temp); |
|
2286 } |
|
2287 } |
|
2288 if (use_newobj) { |
|
2289 PyObject *cls; |
|
2290 PyObject *newargtup; |
|
2291 int n, i; |
|
2292 |
|
2293 /* Sanity checks. */ |
|
2294 n = PyTuple_Size(argtup); |
|
2295 if (n < 1) { |
|
2296 PyErr_SetString(PicklingError, "__newobj__ arglist " |
|
2297 "is empty"); |
|
2298 return -1; |
|
2299 } |
|
2300 |
|
2301 cls = PyTuple_GET_ITEM(argtup, 0); |
|
2302 if (! PyObject_HasAttrString(cls, "__new__")) { |
|
2303 PyErr_SetString(PicklingError, "args[0] from " |
|
2304 "__newobj__ args has no __new__"); |
|
2305 return -1; |
|
2306 } |
|
2307 |
|
2308 /* XXX How could ob be NULL? */ |
|
2309 if (ob != NULL) { |
|
2310 PyObject *ob_dot_class; |
|
2311 |
|
2312 ob_dot_class = PyObject_GetAttr(ob, __class___str); |
|
2313 if (ob_dot_class == NULL) { |
|
2314 if (PyErr_ExceptionMatches( |
|
2315 PyExc_AttributeError)) |
|
2316 PyErr_Clear(); |
|
2317 else |
|
2318 return -1; |
|
2319 } |
|
2320 i = ob_dot_class != cls; /* true iff a problem */ |
|
2321 Py_XDECREF(ob_dot_class); |
|
2322 if (i) { |
|
2323 PyErr_SetString(PicklingError, "args[0] from " |
|
2324 "__newobj__ args has the wrong class"); |
|
2325 return -1; |
|
2326 } |
|
2327 } |
|
2328 |
|
2329 /* Save the class and its __new__ arguments. */ |
|
2330 if (save(self, cls, 0) < 0) |
|
2331 return -1; |
|
2332 |
|
2333 newargtup = PyTuple_New(n-1); /* argtup[1:] */ |
|
2334 if (newargtup == NULL) |
|
2335 return -1; |
|
2336 for (i = 1; i < n; ++i) { |
|
2337 PyObject *temp = PyTuple_GET_ITEM(argtup, i); |
|
2338 Py_INCREF(temp); |
|
2339 PyTuple_SET_ITEM(newargtup, i-1, temp); |
|
2340 } |
|
2341 i = save(self, newargtup, 0); |
|
2342 Py_DECREF(newargtup); |
|
2343 if (i < 0) |
|
2344 return -1; |
|
2345 |
|
2346 /* Add NEWOBJ opcode. */ |
|
2347 if (self->write_func(self, &newobj, 1) < 0) |
|
2348 return -1; |
|
2349 } |
|
2350 else { |
|
2351 /* Not using NEWOBJ. */ |
|
2352 if (save(self, callable, 0) < 0 || |
|
2353 save(self, argtup, 0) < 0 || |
|
2354 self->write_func(self, &reduce, 1) < 0) |
|
2355 return -1; |
|
2356 } |
|
2357 |
|
2358 /* Memoize. */ |
|
2359 /* XXX How can ob be NULL? */ |
|
2360 if (ob != NULL) { |
|
2361 if (state && !PyDict_Check(state)) { |
|
2362 if (put2(self, ob) < 0) |
|
2363 return -1; |
|
2364 } |
|
2365 else if (put(self, ob) < 0) |
|
2366 return -1; |
|
2367 } |
|
2368 |
|
2369 |
|
2370 if (listitems && batch_list(self, listitems) < 0) |
|
2371 return -1; |
|
2372 |
|
2373 if (dictitems && batch_dict(self, dictitems) < 0) |
|
2374 return -1; |
|
2375 |
|
2376 if (state) { |
|
2377 if (save(self, state, 0) < 0 || |
|
2378 self->write_func(self, &build, 1) < 0) |
|
2379 return -1; |
|
2380 } |
|
2381 |
|
2382 return 0; |
|
2383 } |
|
2384 |
|
2385 static int |
|
2386 save(Picklerobject *self, PyObject *args, int pers_save) |
|
2387 { |
|
2388 PyTypeObject *type; |
|
2389 PyObject *py_ob_id = 0, *__reduce__ = 0, *t = 0; |
|
2390 int res = -1; |
|
2391 int tmp; |
|
2392 |
|
2393 if (Py_EnterRecursiveCall(" while pickling an object")) |
|
2394 return -1; |
|
2395 |
|
2396 if (!pers_save && self->pers_func) { |
|
2397 if ((tmp = save_pers(self, args, self->pers_func)) != 0) { |
|
2398 res = tmp; |
|
2399 goto finally; |
|
2400 } |
|
2401 } |
|
2402 |
|
2403 if (args == Py_None) { |
|
2404 res = save_none(self, args); |
|
2405 goto finally; |
|
2406 } |
|
2407 |
|
2408 type = Py_TYPE(args); |
|
2409 |
|
2410 switch (type->tp_name[0]) { |
|
2411 case 'b': |
|
2412 if (args == Py_False || args == Py_True) { |
|
2413 res = save_bool(self, args); |
|
2414 goto finally; |
|
2415 } |
|
2416 break; |
|
2417 case 'i': |
|
2418 if (type == &PyInt_Type) { |
|
2419 res = save_int(self, args); |
|
2420 goto finally; |
|
2421 } |
|
2422 break; |
|
2423 |
|
2424 case 'l': |
|
2425 if (type == &PyLong_Type) { |
|
2426 res = save_long(self, args); |
|
2427 goto finally; |
|
2428 } |
|
2429 break; |
|
2430 |
|
2431 case 'f': |
|
2432 if (type == &PyFloat_Type) { |
|
2433 res = save_float(self, args); |
|
2434 goto finally; |
|
2435 } |
|
2436 break; |
|
2437 |
|
2438 case 't': |
|
2439 if (type == &PyTuple_Type && PyTuple_Size(args) == 0) { |
|
2440 res = save_tuple(self, args); |
|
2441 goto finally; |
|
2442 } |
|
2443 break; |
|
2444 |
|
2445 case 's': |
|
2446 if ((type == &PyString_Type) && (PyString_GET_SIZE(args) < 2)) { |
|
2447 res = save_string(self, args, 0); |
|
2448 goto finally; |
|
2449 } |
|
2450 break; |
|
2451 |
|
2452 #ifdef Py_USING_UNICODE |
|
2453 case 'u': |
|
2454 if ((type == &PyUnicode_Type) && (PyString_GET_SIZE(args) < 2)) { |
|
2455 res = save_unicode(self, args, 0); |
|
2456 goto finally; |
|
2457 } |
|
2458 break; |
|
2459 #endif |
|
2460 } |
|
2461 |
|
2462 if (Py_REFCNT(args) > 1) { |
|
2463 if (!( py_ob_id = PyLong_FromVoidPtr(args))) |
|
2464 goto finally; |
|
2465 |
|
2466 if (PyDict_GetItem(self->memo, py_ob_id)) { |
|
2467 if (get(self, py_ob_id) < 0) |
|
2468 goto finally; |
|
2469 |
|
2470 res = 0; |
|
2471 goto finally; |
|
2472 } |
|
2473 } |
|
2474 |
|
2475 switch (type->tp_name[0]) { |
|
2476 case 's': |
|
2477 if (type == &PyString_Type) { |
|
2478 res = save_string(self, args, 1); |
|
2479 goto finally; |
|
2480 } |
|
2481 break; |
|
2482 |
|
2483 #ifdef Py_USING_UNICODE |
|
2484 case 'u': |
|
2485 if (type == &PyUnicode_Type) { |
|
2486 res = save_unicode(self, args, 1); |
|
2487 goto finally; |
|
2488 } |
|
2489 break; |
|
2490 #endif |
|
2491 |
|
2492 case 't': |
|
2493 if (type == &PyTuple_Type) { |
|
2494 res = save_tuple(self, args); |
|
2495 goto finally; |
|
2496 } |
|
2497 if (type == &PyType_Type) { |
|
2498 res = save_global(self, args, NULL); |
|
2499 goto finally; |
|
2500 } |
|
2501 break; |
|
2502 |
|
2503 case 'l': |
|
2504 if (type == &PyList_Type) { |
|
2505 res = save_list(self, args); |
|
2506 goto finally; |
|
2507 } |
|
2508 break; |
|
2509 |
|
2510 case 'd': |
|
2511 if (type == &PyDict_Type) { |
|
2512 res = save_dict(self, args); |
|
2513 goto finally; |
|
2514 } |
|
2515 break; |
|
2516 |
|
2517 case 'i': |
|
2518 if (type == &PyInstance_Type) { |
|
2519 res = save_inst(self, args); |
|
2520 goto finally; |
|
2521 } |
|
2522 break; |
|
2523 |
|
2524 case 'c': |
|
2525 if (type == &PyClass_Type) { |
|
2526 res = save_global(self, args, NULL); |
|
2527 goto finally; |
|
2528 } |
|
2529 break; |
|
2530 |
|
2531 case 'f': |
|
2532 if (type == &PyFunction_Type) { |
|
2533 res = save_global(self, args, NULL); |
|
2534 if (res && PyErr_ExceptionMatches(PickleError)) { |
|
2535 /* fall back to reduce */ |
|
2536 PyErr_Clear(); |
|
2537 break; |
|
2538 } |
|
2539 goto finally; |
|
2540 } |
|
2541 break; |
|
2542 |
|
2543 case 'b': |
|
2544 if (type == &PyCFunction_Type) { |
|
2545 res = save_global(self, args, NULL); |
|
2546 goto finally; |
|
2547 } |
|
2548 } |
|
2549 |
|
2550 if (!pers_save && self->inst_pers_func) { |
|
2551 if ((tmp = save_pers(self, args, self->inst_pers_func)) != 0) { |
|
2552 res = tmp; |
|
2553 goto finally; |
|
2554 } |
|
2555 } |
|
2556 |
|
2557 if (PyType_IsSubtype(type, &PyType_Type)) { |
|
2558 res = save_global(self, args, NULL); |
|
2559 goto finally; |
|
2560 } |
|
2561 |
|
2562 /* Get a reduction callable, and call it. This may come from |
|
2563 * copy_reg.dispatch_table, the object's __reduce_ex__ method, |
|
2564 * or the object's __reduce__ method. |
|
2565 */ |
|
2566 __reduce__ = PyDict_GetItem(dispatch_table, (PyObject *)type); |
|
2567 if (__reduce__ != NULL) { |
|
2568 Py_INCREF(__reduce__); |
|
2569 Py_INCREF(args); |
|
2570 ARG_TUP(self, args); |
|
2571 if (self->arg) { |
|
2572 t = PyObject_Call(__reduce__, self->arg, NULL); |
|
2573 FREE_ARG_TUP(self); |
|
2574 } |
|
2575 } |
|
2576 else { |
|
2577 /* Check for a __reduce_ex__ method. */ |
|
2578 __reduce__ = PyObject_GetAttr(args, __reduce_ex___str); |
|
2579 if (__reduce__ != NULL) { |
|
2580 t = PyInt_FromLong(self->proto); |
|
2581 if (t != NULL) { |
|
2582 ARG_TUP(self, t); |
|
2583 t = NULL; |
|
2584 if (self->arg) { |
|
2585 t = PyObject_Call(__reduce__, |
|
2586 self->arg, NULL); |
|
2587 FREE_ARG_TUP(self); |
|
2588 } |
|
2589 } |
|
2590 } |
|
2591 else { |
|
2592 if (PyErr_ExceptionMatches(PyExc_AttributeError)) |
|
2593 PyErr_Clear(); |
|
2594 else |
|
2595 goto finally; |
|
2596 /* Check for a __reduce__ method. */ |
|
2597 __reduce__ = PyObject_GetAttr(args, __reduce___str); |
|
2598 if (__reduce__ != NULL) { |
|
2599 t = PyObject_Call(__reduce__, |
|
2600 empty_tuple, NULL); |
|
2601 } |
|
2602 else { |
|
2603 PyErr_SetObject(UnpickleableError, args); |
|
2604 goto finally; |
|
2605 } |
|
2606 } |
|
2607 } |
|
2608 |
|
2609 if (t == NULL) |
|
2610 goto finally; |
|
2611 |
|
2612 if (PyString_Check(t)) { |
|
2613 res = save_global(self, args, t); |
|
2614 goto finally; |
|
2615 } |
|
2616 |
|
2617 if (!PyTuple_Check(t)) { |
|
2618 cPickle_ErrFormat(PicklingError, "Value returned by " |
|
2619 "%s must be string or tuple", |
|
2620 "O", __reduce__); |
|
2621 goto finally; |
|
2622 } |
|
2623 |
|
2624 res = save_reduce(self, t, __reduce__, args); |
|
2625 |
|
2626 finally: |
|
2627 Py_LeaveRecursiveCall(); |
|
2628 Py_XDECREF(py_ob_id); |
|
2629 Py_XDECREF(__reduce__); |
|
2630 Py_XDECREF(t); |
|
2631 |
|
2632 return res; |
|
2633 } |
|
2634 |
|
2635 |
|
2636 static int |
|
2637 dump(Picklerobject *self, PyObject *args) |
|
2638 { |
|
2639 static char stop = STOP; |
|
2640 |
|
2641 if (self->proto >= 2) { |
|
2642 char bytes[2]; |
|
2643 |
|
2644 bytes[0] = PROTO; |
|
2645 assert(self->proto >= 0 && self->proto < 256); |
|
2646 bytes[1] = (char)self->proto; |
|
2647 if (self->write_func(self, bytes, 2) < 0) |
|
2648 return -1; |
|
2649 } |
|
2650 |
|
2651 if (save(self, args, 0) < 0) |
|
2652 return -1; |
|
2653 |
|
2654 if (self->write_func(self, &stop, 1) < 0) |
|
2655 return -1; |
|
2656 |
|
2657 if (self->write_func(self, NULL, 0) < 0) |
|
2658 return -1; |
|
2659 |
|
2660 return 0; |
|
2661 } |
|
2662 |
|
2663 static PyObject * |
|
2664 Pickle_clear_memo(Picklerobject *self, PyObject *args) |
|
2665 { |
|
2666 if (self->memo) |
|
2667 PyDict_Clear(self->memo); |
|
2668 Py_INCREF(Py_None); |
|
2669 return Py_None; |
|
2670 } |
|
2671 |
|
2672 static PyObject * |
|
2673 Pickle_getvalue(Picklerobject *self, PyObject *args) |
|
2674 { |
|
2675 int l, i, rsize, ssize, clear=1, lm; |
|
2676 long ik; |
|
2677 PyObject *k, *r; |
|
2678 char *s, *p, *have_get; |
|
2679 Pdata *data; |
|
2680 |
|
2681 /* Can be called by Python code or C code */ |
|
2682 if (args && !PyArg_ParseTuple(args, "|i:getvalue", &clear)) |
|
2683 return NULL; |
|
2684 |
|
2685 /* Check to make sure we are based on a list */ |
|
2686 if (! Pdata_Check(self->file)) { |
|
2687 PyErr_SetString(PicklingError, |
|
2688 "Attempt to getvalue() a non-list-based pickler"); |
|
2689 return NULL; |
|
2690 } |
|
2691 |
|
2692 /* flush write buffer */ |
|
2693 if (write_other(self, NULL, 0) < 0) return NULL; |
|
2694 |
|
2695 data=(Pdata*)self->file; |
|
2696 l=data->length; |
|
2697 |
|
2698 /* set up an array to hold get/put status */ |
|
2699 lm = PyDict_Size(self->memo); |
|
2700 if (lm < 0) return NULL; |
|
2701 lm++; |
|
2702 have_get = malloc(lm); |
|
2703 if (have_get == NULL) return PyErr_NoMemory(); |
|
2704 memset(have_get, 0, lm); |
|
2705 |
|
2706 /* Scan for gets. */ |
|
2707 for (rsize = 0, i = l; --i >= 0; ) { |
|
2708 k = data->data[i]; |
|
2709 |
|
2710 if (PyString_Check(k)) |
|
2711 rsize += PyString_GET_SIZE(k); |
|
2712 |
|
2713 else if (PyInt_Check(k)) { /* put */ |
|
2714 ik = PyInt_AS_LONG((PyIntObject*)k); |
|
2715 if (ik >= lm || ik == 0) { |
|
2716 PyErr_SetString(PicklingError, |
|
2717 "Invalid get data"); |
|
2718 goto err; |
|
2719 } |
|
2720 if (have_get[ik]) /* with matching get */ |
|
2721 rsize += ik < 256 ? 2 : 5; |
|
2722 } |
|
2723 |
|
2724 else if (! (PyTuple_Check(k) && |
|
2725 PyTuple_GET_SIZE(k) == 2 && |
|
2726 PyInt_Check((k = PyTuple_GET_ITEM(k, 0)))) |
|
2727 ) { |
|
2728 PyErr_SetString(PicklingError, |
|
2729 "Unexpected data in internal list"); |
|
2730 goto err; |
|
2731 } |
|
2732 |
|
2733 else { /* put */ |
|
2734 ik = PyInt_AS_LONG((PyIntObject *)k); |
|
2735 if (ik >= lm || ik == 0) { |
|
2736 PyErr_SetString(PicklingError, |
|
2737 "Invalid get data"); |
|
2738 return NULL; |
|
2739 } |
|
2740 have_get[ik] = 1; |
|
2741 rsize += ik < 256 ? 2 : 5; |
|
2742 } |
|
2743 } |
|
2744 |
|
2745 /* Now generate the result */ |
|
2746 r = PyString_FromStringAndSize(NULL, rsize); |
|
2747 if (r == NULL) goto err; |
|
2748 s = PyString_AS_STRING((PyStringObject *)r); |
|
2749 |
|
2750 for (i = 0; i < l; i++) { |
|
2751 k = data->data[i]; |
|
2752 |
|
2753 if (PyString_Check(k)) { |
|
2754 ssize = PyString_GET_SIZE(k); |
|
2755 if (ssize) { |
|
2756 p=PyString_AS_STRING((PyStringObject *)k); |
|
2757 while (--ssize >= 0) |
|
2758 *s++ = *p++; |
|
2759 } |
|
2760 } |
|
2761 |
|
2762 else if (PyTuple_Check(k)) { /* get */ |
|
2763 ik = PyInt_AS_LONG((PyIntObject *) |
|
2764 PyTuple_GET_ITEM(k, 0)); |
|
2765 if (ik < 256) { |
|
2766 *s++ = BINGET; |
|
2767 *s++ = (int)(ik & 0xff); |
|
2768 } |
|
2769 else { |
|
2770 *s++ = LONG_BINGET; |
|
2771 *s++ = (int)(ik & 0xff); |
|
2772 *s++ = (int)((ik >> 8) & 0xff); |
|
2773 *s++ = (int)((ik >> 16) & 0xff); |
|
2774 *s++ = (int)((ik >> 24) & 0xff); |
|
2775 } |
|
2776 } |
|
2777 |
|
2778 else { /* put */ |
|
2779 ik = PyInt_AS_LONG((PyIntObject*)k); |
|
2780 |
|
2781 if (have_get[ik]) { /* with matching get */ |
|
2782 if (ik < 256) { |
|
2783 *s++ = BINPUT; |
|
2784 *s++ = (int)(ik & 0xff); |
|
2785 } |
|
2786 else { |
|
2787 *s++ = LONG_BINPUT; |
|
2788 *s++ = (int)(ik & 0xff); |
|
2789 *s++ = (int)((ik >> 8) & 0xff); |
|
2790 *s++ = (int)((ik >> 16) & 0xff); |
|
2791 *s++ = (int)((ik >> 24) & 0xff); |
|
2792 } |
|
2793 } |
|
2794 } |
|
2795 } |
|
2796 |
|
2797 if (clear) { |
|
2798 PyDict_Clear(self->memo); |
|
2799 Pdata_clear(data, 0); |
|
2800 } |
|
2801 |
|
2802 free(have_get); |
|
2803 return r; |
|
2804 err: |
|
2805 free(have_get); |
|
2806 return NULL; |
|
2807 } |
|
2808 |
|
2809 static PyObject * |
|
2810 Pickler_dump(Picklerobject *self, PyObject *args) |
|
2811 { |
|
2812 PyObject *ob; |
|
2813 int get=0; |
|
2814 |
|
2815 if (!( PyArg_ParseTuple(args, "O|i:dump", &ob, &get))) |
|
2816 return NULL; |
|
2817 |
|
2818 if (dump(self, ob) < 0) |
|
2819 return NULL; |
|
2820 |
|
2821 if (get) return Pickle_getvalue(self, NULL); |
|
2822 |
|
2823 /* XXX Why does dump() return self? */ |
|
2824 Py_INCREF(self); |
|
2825 return (PyObject*)self; |
|
2826 } |
|
2827 |
|
2828 |
|
2829 static struct PyMethodDef Pickler_methods[] = |
|
2830 { |
|
2831 {"dump", (PyCFunction)Pickler_dump, METH_VARARGS, |
|
2832 PyDoc_STR("dump(object) -- " |
|
2833 "Write an object in pickle format to the object's pickle stream")}, |
|
2834 {"clear_memo", (PyCFunction)Pickle_clear_memo, METH_NOARGS, |
|
2835 PyDoc_STR("clear_memo() -- Clear the picklers memo")}, |
|
2836 {"getvalue", (PyCFunction)Pickle_getvalue, METH_VARARGS, |
|
2837 PyDoc_STR("getvalue() -- Finish picking a list-based pickle")}, |
|
2838 {NULL, NULL} /* sentinel */ |
|
2839 }; |
|
2840 |
|
2841 |
|
2842 static Picklerobject * |
|
2843 newPicklerobject(PyObject *file, int proto) |
|
2844 { |
|
2845 Picklerobject *self; |
|
2846 |
|
2847 if (proto < 0) |
|
2848 proto = HIGHEST_PROTOCOL; |
|
2849 if (proto > HIGHEST_PROTOCOL) { |
|
2850 PyErr_Format(PyExc_ValueError, "pickle protocol %d asked for; " |
|
2851 "the highest available protocol is %d", |
|
2852 proto, HIGHEST_PROTOCOL); |
|
2853 return NULL; |
|
2854 } |
|
2855 |
|
2856 self = PyObject_GC_New(Picklerobject, &Picklertype); |
|
2857 if (self == NULL) |
|
2858 return NULL; |
|
2859 self->proto = proto; |
|
2860 self->bin = proto > 0; |
|
2861 self->fp = NULL; |
|
2862 self->write = NULL; |
|
2863 self->memo = NULL; |
|
2864 self->arg = NULL; |
|
2865 self->pers_func = NULL; |
|
2866 self->inst_pers_func = NULL; |
|
2867 self->write_buf = NULL; |
|
2868 self->fast = 0; |
|
2869 self->fast_container = 0; |
|
2870 self->fast_memo = NULL; |
|
2871 self->buf_size = 0; |
|
2872 self->dispatch_table = NULL; |
|
2873 |
|
2874 self->file = NULL; |
|
2875 if (file) |
|
2876 Py_INCREF(file); |
|
2877 else { |
|
2878 file = Pdata_New(); |
|
2879 if (file == NULL) |
|
2880 goto err; |
|
2881 } |
|
2882 self->file = file; |
|
2883 |
|
2884 if (!( self->memo = PyDict_New())) |
|
2885 goto err; |
|
2886 |
|
2887 if (PyFile_Check(file)) { |
|
2888 self->fp = PyFile_AsFile(file); |
|
2889 if (self->fp == NULL) { |
|
2890 PyErr_SetString(PyExc_ValueError, |
|
2891 "I/O operation on closed file"); |
|
2892 goto err; |
|
2893 } |
|
2894 self->write_func = write_file; |
|
2895 } |
|
2896 else if (PycStringIO_OutputCheck(file)) { |
|
2897 self->write_func = write_cStringIO; |
|
2898 } |
|
2899 else if (file == Py_None) { |
|
2900 self->write_func = write_none; |
|
2901 } |
|
2902 else { |
|
2903 self->write_func = write_other; |
|
2904 |
|
2905 if (! Pdata_Check(file)) { |
|
2906 self->write = PyObject_GetAttr(file, write_str); |
|
2907 if (!self->write) { |
|
2908 PyErr_Clear(); |
|
2909 PyErr_SetString(PyExc_TypeError, |
|
2910 "argument must have 'write' " |
|
2911 "attribute"); |
|
2912 goto err; |
|
2913 } |
|
2914 } |
|
2915 |
|
2916 self->write_buf = (char *)PyMem_Malloc(WRITE_BUF_SIZE); |
|
2917 if (self->write_buf == NULL) { |
|
2918 PyErr_NoMemory(); |
|
2919 goto err; |
|
2920 } |
|
2921 } |
|
2922 |
|
2923 if (PyEval_GetRestricted()) { |
|
2924 /* Restricted execution, get private tables */ |
|
2925 PyObject *m = PyImport_Import(copyreg_str); |
|
2926 |
|
2927 if (m == NULL) |
|
2928 goto err; |
|
2929 self->dispatch_table = PyObject_GetAttr(m, dispatch_table_str); |
|
2930 Py_DECREF(m); |
|
2931 if (self->dispatch_table == NULL) |
|
2932 goto err; |
|
2933 } |
|
2934 else { |
|
2935 self->dispatch_table = dispatch_table; |
|
2936 Py_INCREF(dispatch_table); |
|
2937 } |
|
2938 PyObject_GC_Track(self); |
|
2939 |
|
2940 return self; |
|
2941 |
|
2942 err: |
|
2943 Py_DECREF(self); |
|
2944 return NULL; |
|
2945 } |
|
2946 |
|
2947 |
|
2948 static PyObject * |
|
2949 get_Pickler(PyObject *self, PyObject *args, PyObject *kwds) |
|
2950 { |
|
2951 static char *kwlist[] = {"file", "protocol", NULL}; |
|
2952 PyObject *file = NULL; |
|
2953 int proto = 0; |
|
2954 |
|
2955 /* XXX |
|
2956 * The documented signature is Pickler(file, protocol=0), but this |
|
2957 * accepts Pickler() and Pickler(integer) too. The meaning then |
|
2958 * is clear as mud, undocumented, and not supported by pickle.py. |
|
2959 * I'm told Zope uses this, but I haven't traced into this code |
|
2960 * far enough to figure out what it means. |
|
2961 */ |
|
2962 if (!PyArg_ParseTuple(args, "|i:Pickler", &proto)) { |
|
2963 PyErr_Clear(); |
|
2964 proto = 0; |
|
2965 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|i:Pickler", |
|
2966 kwlist, &file, &proto)) |
|
2967 return NULL; |
|
2968 } |
|
2969 return (PyObject *)newPicklerobject(file, proto); |
|
2970 } |
|
2971 |
|
2972 |
|
2973 static void |
|
2974 Pickler_dealloc(Picklerobject *self) |
|
2975 { |
|
2976 PyObject_GC_UnTrack(self); |
|
2977 Py_XDECREF(self->write); |
|
2978 Py_XDECREF(self->memo); |
|
2979 Py_XDECREF(self->fast_memo); |
|
2980 Py_XDECREF(self->arg); |
|
2981 Py_XDECREF(self->file); |
|
2982 Py_XDECREF(self->pers_func); |
|
2983 Py_XDECREF(self->inst_pers_func); |
|
2984 Py_XDECREF(self->dispatch_table); |
|
2985 PyMem_Free(self->write_buf); |
|
2986 Py_TYPE(self)->tp_free((PyObject *)self); |
|
2987 } |
|
2988 |
|
2989 static int |
|
2990 Pickler_traverse(Picklerobject *self, visitproc visit, void *arg) |
|
2991 { |
|
2992 Py_VISIT(self->write); |
|
2993 Py_VISIT(self->memo); |
|
2994 Py_VISIT(self->fast_memo); |
|
2995 Py_VISIT(self->arg); |
|
2996 Py_VISIT(self->file); |
|
2997 Py_VISIT(self->pers_func); |
|
2998 Py_VISIT(self->inst_pers_func); |
|
2999 Py_VISIT(self->dispatch_table); |
|
3000 return 0; |
|
3001 } |
|
3002 |
|
3003 static int |
|
3004 Pickler_clear(Picklerobject *self) |
|
3005 { |
|
3006 Py_CLEAR(self->write); |
|
3007 Py_CLEAR(self->memo); |
|
3008 Py_CLEAR(self->fast_memo); |
|
3009 Py_CLEAR(self->arg); |
|
3010 Py_CLEAR(self->file); |
|
3011 Py_CLEAR(self->pers_func); |
|
3012 Py_CLEAR(self->inst_pers_func); |
|
3013 Py_CLEAR(self->dispatch_table); |
|
3014 return 0; |
|
3015 } |
|
3016 |
|
3017 static PyObject * |
|
3018 Pickler_get_pers_func(Picklerobject *p) |
|
3019 { |
|
3020 if (p->pers_func == NULL) |
|
3021 PyErr_SetString(PyExc_AttributeError, "persistent_id"); |
|
3022 else |
|
3023 Py_INCREF(p->pers_func); |
|
3024 return p->pers_func; |
|
3025 } |
|
3026 |
|
3027 static int |
|
3028 Pickler_set_pers_func(Picklerobject *p, PyObject *v) |
|
3029 { |
|
3030 if (v == NULL) { |
|
3031 PyErr_SetString(PyExc_TypeError, |
|
3032 "attribute deletion is not supported"); |
|
3033 return -1; |
|
3034 } |
|
3035 Py_XDECREF(p->pers_func); |
|
3036 Py_INCREF(v); |
|
3037 p->pers_func = v; |
|
3038 return 0; |
|
3039 } |
|
3040 |
|
3041 static int |
|
3042 Pickler_set_inst_pers_func(Picklerobject *p, PyObject *v) |
|
3043 { |
|
3044 if (v == NULL) { |
|
3045 PyErr_SetString(PyExc_TypeError, |
|
3046 "attribute deletion is not supported"); |
|
3047 return -1; |
|
3048 } |
|
3049 Py_XDECREF(p->inst_pers_func); |
|
3050 Py_INCREF(v); |
|
3051 p->inst_pers_func = v; |
|
3052 return 0; |
|
3053 } |
|
3054 |
|
3055 static PyObject * |
|
3056 Pickler_get_memo(Picklerobject *p) |
|
3057 { |
|
3058 if (p->memo == NULL) |
|
3059 PyErr_SetString(PyExc_AttributeError, "memo"); |
|
3060 else |
|
3061 Py_INCREF(p->memo); |
|
3062 return p->memo; |
|
3063 } |
|
3064 |
|
3065 static int |
|
3066 Pickler_set_memo(Picklerobject *p, PyObject *v) |
|
3067 { |
|
3068 if (v == NULL) { |
|
3069 PyErr_SetString(PyExc_TypeError, |
|
3070 "attribute deletion is not supported"); |
|
3071 return -1; |
|
3072 } |
|
3073 if (!PyDict_Check(v)) { |
|
3074 PyErr_SetString(PyExc_TypeError, "memo must be a dictionary"); |
|
3075 return -1; |
|
3076 } |
|
3077 Py_XDECREF(p->memo); |
|
3078 Py_INCREF(v); |
|
3079 p->memo = v; |
|
3080 return 0; |
|
3081 } |
|
3082 |
|
3083 static PyObject * |
|
3084 Pickler_get_error(Picklerobject *p) |
|
3085 { |
|
3086 /* why is this an attribute on the Pickler? */ |
|
3087 Py_INCREF(PicklingError); |
|
3088 return PicklingError; |
|
3089 } |
|
3090 |
|
3091 static PyMemberDef Pickler_members[] = { |
|
3092 {"binary", T_INT, offsetof(Picklerobject, bin)}, |
|
3093 {"fast", T_INT, offsetof(Picklerobject, fast)}, |
|
3094 {NULL} |
|
3095 }; |
|
3096 |
|
3097 static PyGetSetDef Pickler_getsets[] = { |
|
3098 {"persistent_id", (getter)Pickler_get_pers_func, |
|
3099 (setter)Pickler_set_pers_func}, |
|
3100 {"inst_persistent_id", NULL, (setter)Pickler_set_inst_pers_func}, |
|
3101 {"memo", (getter)Pickler_get_memo, (setter)Pickler_set_memo}, |
|
3102 {"PicklingError", (getter)Pickler_get_error, NULL}, |
|
3103 {NULL} |
|
3104 }; |
|
3105 |
|
3106 PyDoc_STRVAR(Picklertype__doc__, |
|
3107 "Objects that know how to pickle objects\n"); |
|
3108 |
|
3109 static PyTypeObject Picklertype = { |
|
3110 PyVarObject_HEAD_INIT(NULL, 0) |
|
3111 "cPickle.Pickler", /*tp_name*/ |
|
3112 sizeof(Picklerobject), /*tp_basicsize*/ |
|
3113 0, |
|
3114 (destructor)Pickler_dealloc, /* tp_dealloc */ |
|
3115 0, /* tp_print */ |
|
3116 0, /* tp_getattr */ |
|
3117 0, /* tp_setattr */ |
|
3118 0, /* tp_compare */ |
|
3119 0, /* tp_repr */ |
|
3120 0, /* tp_as_number */ |
|
3121 0, /* tp_as_sequence */ |
|
3122 0, /* tp_as_mapping */ |
|
3123 0, /* tp_hash */ |
|
3124 0, /* tp_call */ |
|
3125 0, /* tp_str */ |
|
3126 PyObject_GenericGetAttr, /* tp_getattro */ |
|
3127 PyObject_GenericSetAttr, /* tp_setattro */ |
|
3128 0, /* tp_as_buffer */ |
|
3129 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, |
|
3130 Picklertype__doc__, /* tp_doc */ |
|
3131 (traverseproc)Pickler_traverse, /* tp_traverse */ |
|
3132 (inquiry)Pickler_clear, /* tp_clear */ |
|
3133 0, /* tp_richcompare */ |
|
3134 0, /* tp_weaklistoffset */ |
|
3135 0, /* tp_iter */ |
|
3136 0, /* tp_iternext */ |
|
3137 Pickler_methods, /* tp_methods */ |
|
3138 Pickler_members, /* tp_members */ |
|
3139 Pickler_getsets, /* tp_getset */ |
|
3140 }; |
|
3141 |
|
3142 static PyObject * |
|
3143 find_class(PyObject *py_module_name, PyObject *py_global_name, PyObject *fc) |
|
3144 { |
|
3145 PyObject *global = 0, *module; |
|
3146 |
|
3147 if (fc) { |
|
3148 if (fc==Py_None) { |
|
3149 PyErr_SetString(UnpicklingError, "Global and instance " |
|
3150 "pickles are not supported."); |
|
3151 return NULL; |
|
3152 } |
|
3153 return PyObject_CallFunctionObjArgs(fc, py_module_name, |
|
3154 py_global_name, NULL); |
|
3155 } |
|
3156 |
|
3157 module = PySys_GetObject("modules"); |
|
3158 if (module == NULL) |
|
3159 return NULL; |
|
3160 |
|
3161 module = PyDict_GetItem(module, py_module_name); |
|
3162 if (module == NULL) { |
|
3163 module = PyImport_Import(py_module_name); |
|
3164 if (!module) |
|
3165 return NULL; |
|
3166 global = PyObject_GetAttr(module, py_global_name); |
|
3167 Py_DECREF(module); |
|
3168 } |
|
3169 else |
|
3170 global = PyObject_GetAttr(module, py_global_name); |
|
3171 return global; |
|
3172 } |
|
3173 |
|
3174 static int |
|
3175 marker(Unpicklerobject *self) |
|
3176 { |
|
3177 if (self->num_marks < 1) { |
|
3178 PyErr_SetString(UnpicklingError, "could not find MARK"); |
|
3179 return -1; |
|
3180 } |
|
3181 |
|
3182 return self->marks[--self->num_marks]; |
|
3183 } |
|
3184 |
|
3185 |
|
3186 static int |
|
3187 load_none(Unpicklerobject *self) |
|
3188 { |
|
3189 PDATA_APPEND(self->stack, Py_None, -1); |
|
3190 return 0; |
|
3191 } |
|
3192 |
|
3193 static int |
|
3194 bad_readline(void) |
|
3195 { |
|
3196 PyErr_SetString(UnpicklingError, "pickle data was truncated"); |
|
3197 return -1; |
|
3198 } |
|
3199 |
|
3200 static int |
|
3201 load_int(Unpicklerobject *self) |
|
3202 { |
|
3203 PyObject *py_int = 0; |
|
3204 char *endptr, *s; |
|
3205 int len, res = -1; |
|
3206 long l; |
|
3207 |
|
3208 if ((len = self->readline_func(self, &s)) < 0) return -1; |
|
3209 if (len < 2) return bad_readline(); |
|
3210 if (!( s=pystrndup(s,len))) return -1; |
|
3211 |
|
3212 errno = 0; |
|
3213 l = strtol(s, &endptr, 0); |
|
3214 |
|
3215 if (errno || (*endptr != '\n') || (endptr[1] != '\0')) { |
|
3216 /* Hm, maybe we've got something long. Let's try reading |
|
3217 it as a Python long object. */ |
|
3218 errno = 0; |
|
3219 py_int = PyLong_FromString(s, NULL, 0); |
|
3220 if (py_int == NULL) { |
|
3221 PyErr_SetString(PyExc_ValueError, |
|
3222 "could not convert string to int"); |
|
3223 goto finally; |
|
3224 } |
|
3225 } |
|
3226 else { |
|
3227 if (len == 3 && (l == 0 || l == 1)) { |
|
3228 if (!( py_int = PyBool_FromLong(l))) goto finally; |
|
3229 } |
|
3230 else { |
|
3231 if (!( py_int = PyInt_FromLong(l))) goto finally; |
|
3232 } |
|
3233 } |
|
3234 |
|
3235 free(s); |
|
3236 PDATA_PUSH(self->stack, py_int, -1); |
|
3237 return 0; |
|
3238 |
|
3239 finally: |
|
3240 free(s); |
|
3241 |
|
3242 return res; |
|
3243 } |
|
3244 |
|
3245 static int |
|
3246 load_bool(Unpicklerobject *self, PyObject *boolean) |
|
3247 { |
|
3248 assert(boolean == Py_True || boolean == Py_False); |
|
3249 PDATA_APPEND(self->stack, boolean, -1); |
|
3250 return 0; |
|
3251 } |
|
3252 |
|
3253 /* s contains x bytes of a little-endian integer. Return its value as a |
|
3254 * C int. Obscure: when x is 1 or 2, this is an unsigned little-endian |
|
3255 * int, but when x is 4 it's a signed one. This is an historical source |
|
3256 * of x-platform bugs. |
|
3257 */ |
|
3258 static long |
|
3259 calc_binint(char *s, int x) |
|
3260 { |
|
3261 unsigned char c; |
|
3262 int i; |
|
3263 long l; |
|
3264 |
|
3265 for (i = 0, l = 0L; i < x; i++) { |
|
3266 c = (unsigned char)s[i]; |
|
3267 l |= (long)c << (i * 8); |
|
3268 } |
|
3269 #if SIZEOF_LONG > 4 |
|
3270 /* Unlike BININT1 and BININT2, BININT (more accurately BININT4) |
|
3271 * is signed, so on a box with longs bigger than 4 bytes we need |
|
3272 * to extend a BININT's sign bit to the full width. |
|
3273 */ |
|
3274 if (x == 4 && l & (1L << 31)) |
|
3275 l |= (~0L) << 32; |
|
3276 #endif |
|
3277 return l; |
|
3278 } |
|
3279 |
|
3280 |
|
3281 static int |
|
3282 load_binintx(Unpicklerobject *self, char *s, int x) |
|
3283 { |
|
3284 PyObject *py_int = 0; |
|
3285 long l; |
|
3286 |
|
3287 l = calc_binint(s, x); |
|
3288 |
|
3289 if (!( py_int = PyInt_FromLong(l))) |
|
3290 return -1; |
|
3291 |
|
3292 PDATA_PUSH(self->stack, py_int, -1); |
|
3293 return 0; |
|
3294 } |
|
3295 |
|
3296 |
|
3297 static int |
|
3298 load_binint(Unpicklerobject *self) |
|
3299 { |
|
3300 char *s; |
|
3301 |
|
3302 if (self->read_func(self, &s, 4) < 0) |
|
3303 return -1; |
|
3304 |
|
3305 return load_binintx(self, s, 4); |
|
3306 } |
|
3307 |
|
3308 |
|
3309 static int |
|
3310 load_binint1(Unpicklerobject *self) |
|
3311 { |
|
3312 char *s; |
|
3313 |
|
3314 if (self->read_func(self, &s, 1) < 0) |
|
3315 return -1; |
|
3316 |
|
3317 return load_binintx(self, s, 1); |
|
3318 } |
|
3319 |
|
3320 |
|
3321 static int |
|
3322 load_binint2(Unpicklerobject *self) |
|
3323 { |
|
3324 char *s; |
|
3325 |
|
3326 if (self->read_func(self, &s, 2) < 0) |
|
3327 return -1; |
|
3328 |
|
3329 return load_binintx(self, s, 2); |
|
3330 } |
|
3331 |
|
3332 static int |
|
3333 load_long(Unpicklerobject *self) |
|
3334 { |
|
3335 PyObject *l = 0; |
|
3336 char *end, *s; |
|
3337 int len, res = -1; |
|
3338 |
|
3339 if ((len = self->readline_func(self, &s)) < 0) return -1; |
|
3340 if (len < 2) return bad_readline(); |
|
3341 if (!( s=pystrndup(s,len))) return -1; |
|
3342 |
|
3343 if (!( l = PyLong_FromString(s, &end, 0))) |
|
3344 goto finally; |
|
3345 |
|
3346 free(s); |
|
3347 PDATA_PUSH(self->stack, l, -1); |
|
3348 return 0; |
|
3349 |
|
3350 finally: |
|
3351 free(s); |
|
3352 |
|
3353 return res; |
|
3354 } |
|
3355 |
|
3356 /* 'size' bytes contain the # of bytes of little-endian 256's-complement |
|
3357 * data following. |
|
3358 */ |
|
3359 static int |
|
3360 load_counted_long(Unpicklerobject *self, int size) |
|
3361 { |
|
3362 Py_ssize_t i; |
|
3363 char *nbytes; |
|
3364 unsigned char *pdata; |
|
3365 PyObject *along; |
|
3366 |
|
3367 assert(size == 1 || size == 4); |
|
3368 i = self->read_func(self, &nbytes, size); |
|
3369 if (i < 0) return -1; |
|
3370 |
|
3371 size = calc_binint(nbytes, size); |
|
3372 if (size < 0) { |
|
3373 /* Corrupt or hostile pickle -- we never write one like |
|
3374 * this. |
|
3375 */ |
|
3376 PyErr_SetString(UnpicklingError, "LONG pickle has negative " |
|
3377 "byte count"); |
|
3378 return -1; |
|
3379 } |
|
3380 |
|
3381 if (size == 0) |
|
3382 along = PyLong_FromLong(0L); |
|
3383 else { |
|
3384 /* Read the raw little-endian bytes & convert. */ |
|
3385 i = self->read_func(self, (char **)&pdata, size); |
|
3386 if (i < 0) return -1; |
|
3387 along = _PyLong_FromByteArray(pdata, (size_t)size, |
|
3388 1 /* little endian */, 1 /* signed */); |
|
3389 } |
|
3390 if (along == NULL) |
|
3391 return -1; |
|
3392 PDATA_PUSH(self->stack, along, -1); |
|
3393 return 0; |
|
3394 } |
|
3395 |
|
3396 static int |
|
3397 load_float(Unpicklerobject *self) |
|
3398 { |
|
3399 PyObject *py_float = 0; |
|
3400 char *endptr, *s; |
|
3401 int len, res = -1; |
|
3402 double d; |
|
3403 |
|
3404 if ((len = self->readline_func(self, &s)) < 0) return -1; |
|
3405 if (len < 2) return bad_readline(); |
|
3406 if (!( s=pystrndup(s,len))) return -1; |
|
3407 |
|
3408 errno = 0; |
|
3409 d = PyOS_ascii_strtod(s, &endptr); |
|
3410 |
|
3411 if (errno || (endptr[0] != '\n') || (endptr[1] != '\0')) { |
|
3412 PyErr_SetString(PyExc_ValueError, |
|
3413 "could not convert string to float"); |
|
3414 goto finally; |
|
3415 } |
|
3416 |
|
3417 if (!( py_float = PyFloat_FromDouble(d))) |
|
3418 goto finally; |
|
3419 |
|
3420 free(s); |
|
3421 PDATA_PUSH(self->stack, py_float, -1); |
|
3422 return 0; |
|
3423 |
|
3424 finally: |
|
3425 free(s); |
|
3426 |
|
3427 return res; |
|
3428 } |
|
3429 |
|
3430 static int |
|
3431 load_binfloat(Unpicklerobject *self) |
|
3432 { |
|
3433 PyObject *py_float; |
|
3434 double x; |
|
3435 char *p; |
|
3436 |
|
3437 if (self->read_func(self, &p, 8) < 0) |
|
3438 return -1; |
|
3439 |
|
3440 x = _PyFloat_Unpack8((unsigned char *)p, 0); |
|
3441 if (x == -1.0 && PyErr_Occurred()) |
|
3442 return -1; |
|
3443 |
|
3444 py_float = PyFloat_FromDouble(x); |
|
3445 if (py_float == NULL) |
|
3446 return -1; |
|
3447 |
|
3448 PDATA_PUSH(self->stack, py_float, -1); |
|
3449 return 0; |
|
3450 } |
|
3451 |
|
3452 static int |
|
3453 load_string(Unpicklerobject *self) |
|
3454 { |
|
3455 PyObject *str = 0; |
|
3456 int len, res = -1; |
|
3457 char *s, *p; |
|
3458 |
|
3459 if ((len = self->readline_func(self, &s)) < 0) return -1; |
|
3460 if (len < 2) return bad_readline(); |
|
3461 if (!( s=pystrndup(s,len))) return -1; |
|
3462 |
|
3463 |
|
3464 /* Strip outermost quotes */ |
|
3465 while (s[len-1] <= ' ') |
|
3466 len--; |
|
3467 if(s[0]=='"' && s[len-1]=='"'){ |
|
3468 s[len-1] = '\0'; |
|
3469 p = s + 1 ; |
|
3470 len -= 2; |
|
3471 } else if(s[0]=='\'' && s[len-1]=='\''){ |
|
3472 s[len-1] = '\0'; |
|
3473 p = s + 1 ; |
|
3474 len -= 2; |
|
3475 } else |
|
3476 goto insecure; |
|
3477 /********************************************/ |
|
3478 |
|
3479 str = PyString_DecodeEscape(p, len, NULL, 0, NULL); |
|
3480 free(s); |
|
3481 if (str) { |
|
3482 PDATA_PUSH(self->stack, str, -1); |
|
3483 res = 0; |
|
3484 } |
|
3485 return res; |
|
3486 |
|
3487 insecure: |
|
3488 free(s); |
|
3489 PyErr_SetString(PyExc_ValueError,"insecure string pickle"); |
|
3490 return -1; |
|
3491 } |
|
3492 |
|
3493 |
|
3494 static int |
|
3495 load_binstring(Unpicklerobject *self) |
|
3496 { |
|
3497 PyObject *py_string = 0; |
|
3498 long l; |
|
3499 char *s; |
|
3500 |
|
3501 if (self->read_func(self, &s, 4) < 0) return -1; |
|
3502 |
|
3503 l = calc_binint(s, 4); |
|
3504 if (l < 0) { |
|
3505 /* Corrupt or hostile pickle -- we never write one like |
|
3506 * this. |
|
3507 */ |
|
3508 PyErr_SetString(UnpicklingError, |
|
3509 "BINSTRING pickle has negative byte count"); |
|
3510 return -1; |
|
3511 } |
|
3512 |
|
3513 if (self->read_func(self, &s, l) < 0) |
|
3514 return -1; |
|
3515 |
|
3516 if (!( py_string = PyString_FromStringAndSize(s, l))) |
|
3517 return -1; |
|
3518 |
|
3519 PDATA_PUSH(self->stack, py_string, -1); |
|
3520 return 0; |
|
3521 } |
|
3522 |
|
3523 |
|
3524 static int |
|
3525 load_short_binstring(Unpicklerobject *self) |
|
3526 { |
|
3527 PyObject *py_string = 0; |
|
3528 unsigned char l; |
|
3529 char *s; |
|
3530 |
|
3531 if (self->read_func(self, &s, 1) < 0) |
|
3532 return -1; |
|
3533 |
|
3534 l = (unsigned char)s[0]; |
|
3535 |
|
3536 if (self->read_func(self, &s, l) < 0) return -1; |
|
3537 |
|
3538 if (!( py_string = PyString_FromStringAndSize(s, l))) return -1; |
|
3539 |
|
3540 PDATA_PUSH(self->stack, py_string, -1); |
|
3541 return 0; |
|
3542 } |
|
3543 |
|
3544 |
|
3545 #ifdef Py_USING_UNICODE |
|
3546 static int |
|
3547 load_unicode(Unpicklerobject *self) |
|
3548 { |
|
3549 PyObject *str = 0; |
|
3550 int len, res = -1; |
|
3551 char *s; |
|
3552 |
|
3553 if ((len = self->readline_func(self, &s)) < 0) return -1; |
|
3554 if (len < 1) return bad_readline(); |
|
3555 |
|
3556 if (!( str = PyUnicode_DecodeRawUnicodeEscape(s, len - 1, NULL))) |
|
3557 goto finally; |
|
3558 |
|
3559 PDATA_PUSH(self->stack, str, -1); |
|
3560 return 0; |
|
3561 |
|
3562 finally: |
|
3563 return res; |
|
3564 } |
|
3565 #endif |
|
3566 |
|
3567 |
|
3568 #ifdef Py_USING_UNICODE |
|
3569 static int |
|
3570 load_binunicode(Unpicklerobject *self) |
|
3571 { |
|
3572 PyObject *unicode; |
|
3573 long l; |
|
3574 char *s; |
|
3575 |
|
3576 if (self->read_func(self, &s, 4) < 0) return -1; |
|
3577 |
|
3578 l = calc_binint(s, 4); |
|
3579 if (l < 0) { |
|
3580 /* Corrupt or hostile pickle -- we never write one like |
|
3581 * this. |
|
3582 */ |
|
3583 PyErr_SetString(UnpicklingError, |
|
3584 "BINUNICODE pickle has negative byte count"); |
|
3585 return -1; |
|
3586 } |
|
3587 |
|
3588 if (self->read_func(self, &s, l) < 0) |
|
3589 return -1; |
|
3590 |
|
3591 if (!( unicode = PyUnicode_DecodeUTF8(s, l, NULL))) |
|
3592 return -1; |
|
3593 |
|
3594 PDATA_PUSH(self->stack, unicode, -1); |
|
3595 return 0; |
|
3596 } |
|
3597 #endif |
|
3598 |
|
3599 |
|
3600 static int |
|
3601 load_tuple(Unpicklerobject *self) |
|
3602 { |
|
3603 PyObject *tup; |
|
3604 int i; |
|
3605 |
|
3606 if ((i = marker(self)) < 0) return -1; |
|
3607 if (!( tup=Pdata_popTuple(self->stack, i))) return -1; |
|
3608 PDATA_PUSH(self->stack, tup, -1); |
|
3609 return 0; |
|
3610 } |
|
3611 |
|
3612 static int |
|
3613 load_counted_tuple(Unpicklerobject *self, int len) |
|
3614 { |
|
3615 PyObject *tup = PyTuple_New(len); |
|
3616 |
|
3617 if (tup == NULL) |
|
3618 return -1; |
|
3619 |
|
3620 while (--len >= 0) { |
|
3621 PyObject *element; |
|
3622 |
|
3623 PDATA_POP(self->stack, element); |
|
3624 if (element == NULL) |
|
3625 return -1; |
|
3626 PyTuple_SET_ITEM(tup, len, element); |
|
3627 } |
|
3628 PDATA_PUSH(self->stack, tup, -1); |
|
3629 return 0; |
|
3630 } |
|
3631 |
|
3632 static int |
|
3633 load_empty_list(Unpicklerobject *self) |
|
3634 { |
|
3635 PyObject *list; |
|
3636 |
|
3637 if (!( list=PyList_New(0))) return -1; |
|
3638 PDATA_PUSH(self->stack, list, -1); |
|
3639 return 0; |
|
3640 } |
|
3641 |
|
3642 static int |
|
3643 load_empty_dict(Unpicklerobject *self) |
|
3644 { |
|
3645 PyObject *dict; |
|
3646 |
|
3647 if (!( dict=PyDict_New())) return -1; |
|
3648 PDATA_PUSH(self->stack, dict, -1); |
|
3649 return 0; |
|
3650 } |
|
3651 |
|
3652 |
|
3653 static int |
|
3654 load_list(Unpicklerobject *self) |
|
3655 { |
|
3656 PyObject *list = 0; |
|
3657 int i; |
|
3658 |
|
3659 if ((i = marker(self)) < 0) return -1; |
|
3660 if (!( list=Pdata_popList(self->stack, i))) return -1; |
|
3661 PDATA_PUSH(self->stack, list, -1); |
|
3662 return 0; |
|
3663 } |
|
3664 |
|
3665 static int |
|
3666 load_dict(Unpicklerobject *self) |
|
3667 { |
|
3668 PyObject *dict, *key, *value; |
|
3669 int i, j, k; |
|
3670 |
|
3671 if ((i = marker(self)) < 0) return -1; |
|
3672 j=self->stack->length; |
|
3673 |
|
3674 if (!( dict = PyDict_New())) return -1; |
|
3675 |
|
3676 for (k = i+1; k < j; k += 2) { |
|
3677 key =self->stack->data[k-1]; |
|
3678 value=self->stack->data[k ]; |
|
3679 if (PyDict_SetItem(dict, key, value) < 0) { |
|
3680 Py_DECREF(dict); |
|
3681 return -1; |
|
3682 } |
|
3683 } |
|
3684 Pdata_clear(self->stack, i); |
|
3685 PDATA_PUSH(self->stack, dict, -1); |
|
3686 return 0; |
|
3687 } |
|
3688 |
|
3689 static PyObject * |
|
3690 Instance_New(PyObject *cls, PyObject *args) |
|
3691 { |
|
3692 PyObject *r = 0; |
|
3693 |
|
3694 if (PyClass_Check(cls)) { |
|
3695 int l; |
|
3696 |
|
3697 if ((l=PyObject_Size(args)) < 0) goto err; |
|
3698 if (!( l )) { |
|
3699 PyObject *__getinitargs__; |
|
3700 |
|
3701 __getinitargs__ = PyObject_GetAttr(cls, |
|
3702 __getinitargs___str); |
|
3703 if (!__getinitargs__) { |
|
3704 /* We have a class with no __getinitargs__, |
|
3705 so bypass usual construction */ |
|
3706 PyObject *inst; |
|
3707 |
|
3708 PyErr_Clear(); |
|
3709 if (!( inst=PyInstance_NewRaw(cls, NULL))) |
|
3710 goto err; |
|
3711 return inst; |
|
3712 } |
|
3713 Py_DECREF(__getinitargs__); |
|
3714 } |
|
3715 |
|
3716 if ((r=PyInstance_New(cls, args, NULL))) return r; |
|
3717 else goto err; |
|
3718 } |
|
3719 |
|
3720 if ((r=PyObject_CallObject(cls, args))) return r; |
|
3721 |
|
3722 err: |
|
3723 { |
|
3724 PyObject *tp, *v, *tb, *tmp_value; |
|
3725 |
|
3726 PyErr_Fetch(&tp, &v, &tb); |
|
3727 tmp_value = v; |
|
3728 /* NULL occurs when there was a KeyboardInterrupt */ |
|
3729 if (tmp_value == NULL) |
|
3730 tmp_value = Py_None; |
|
3731 if ((r = PyTuple_Pack(3, tmp_value, cls, args))) { |
|
3732 Py_XDECREF(v); |
|
3733 v=r; |
|
3734 } |
|
3735 PyErr_Restore(tp,v,tb); |
|
3736 } |
|
3737 return NULL; |
|
3738 } |
|
3739 |
|
3740 |
|
3741 static int |
|
3742 load_obj(Unpicklerobject *self) |
|
3743 { |
|
3744 PyObject *class, *tup, *obj=0; |
|
3745 int i; |
|
3746 |
|
3747 if ((i = marker(self)) < 0) return -1; |
|
3748 if (!( tup=Pdata_popTuple(self->stack, i+1))) return -1; |
|
3749 PDATA_POP(self->stack, class); |
|
3750 if (class) { |
|
3751 obj = Instance_New(class, tup); |
|
3752 Py_DECREF(class); |
|
3753 } |
|
3754 Py_DECREF(tup); |
|
3755 |
|
3756 if (! obj) return -1; |
|
3757 PDATA_PUSH(self->stack, obj, -1); |
|
3758 return 0; |
|
3759 } |
|
3760 |
|
3761 |
|
3762 static int |
|
3763 load_inst(Unpicklerobject *self) |
|
3764 { |
|
3765 PyObject *tup, *class=0, *obj=0, *module_name, *class_name; |
|
3766 int i, len; |
|
3767 char *s; |
|
3768 |
|
3769 if ((i = marker(self)) < 0) return -1; |
|
3770 |
|
3771 if ((len = self->readline_func(self, &s)) < 0) return -1; |
|
3772 if (len < 2) return bad_readline(); |
|
3773 module_name = PyString_FromStringAndSize(s, len - 1); |
|
3774 if (!module_name) return -1; |
|
3775 |
|
3776 if ((len = self->readline_func(self, &s)) >= 0) { |
|
3777 if (len < 2) return bad_readline(); |
|
3778 if ((class_name = PyString_FromStringAndSize(s, len - 1))) { |
|
3779 class = find_class(module_name, class_name, |
|
3780 self->find_class); |
|
3781 Py_DECREF(class_name); |
|
3782 } |
|
3783 } |
|
3784 Py_DECREF(module_name); |
|
3785 |
|
3786 if (! class) return -1; |
|
3787 |
|
3788 if ((tup=Pdata_popTuple(self->stack, i))) { |
|
3789 obj = Instance_New(class, tup); |
|
3790 Py_DECREF(tup); |
|
3791 } |
|
3792 Py_DECREF(class); |
|
3793 |
|
3794 if (! obj) return -1; |
|
3795 |
|
3796 PDATA_PUSH(self->stack, obj, -1); |
|
3797 return 0; |
|
3798 } |
|
3799 |
|
3800 static int |
|
3801 load_newobj(Unpicklerobject *self) |
|
3802 { |
|
3803 PyObject *args = NULL; |
|
3804 PyObject *clsraw = NULL; |
|
3805 PyTypeObject *cls; /* clsraw cast to its true type */ |
|
3806 PyObject *obj; |
|
3807 |
|
3808 /* Stack is ... cls argtuple, and we want to call |
|
3809 * cls.__new__(cls, *argtuple). |
|
3810 */ |
|
3811 PDATA_POP(self->stack, args); |
|
3812 if (args == NULL) goto Fail; |
|
3813 if (! PyTuple_Check(args)) { |
|
3814 PyErr_SetString(UnpicklingError, "NEWOBJ expected an arg " |
|
3815 "tuple."); |
|
3816 goto Fail; |
|
3817 } |
|
3818 |
|
3819 PDATA_POP(self->stack, clsraw); |
|
3820 cls = (PyTypeObject *)clsraw; |
|
3821 if (cls == NULL) goto Fail; |
|
3822 if (! PyType_Check(cls)) { |
|
3823 PyErr_SetString(UnpicklingError, "NEWOBJ class argument " |
|
3824 "isn't a type object"); |
|
3825 goto Fail; |
|
3826 } |
|
3827 if (cls->tp_new == NULL) { |
|
3828 PyErr_SetString(UnpicklingError, "NEWOBJ class argument " |
|
3829 "has NULL tp_new"); |
|
3830 goto Fail; |
|
3831 } |
|
3832 |
|
3833 /* Call __new__. */ |
|
3834 obj = cls->tp_new(cls, args, NULL); |
|
3835 if (obj == NULL) goto Fail; |
|
3836 |
|
3837 Py_DECREF(args); |
|
3838 Py_DECREF(clsraw); |
|
3839 PDATA_PUSH(self->stack, obj, -1); |
|
3840 return 0; |
|
3841 |
|
3842 Fail: |
|
3843 Py_XDECREF(args); |
|
3844 Py_XDECREF(clsraw); |
|
3845 return -1; |
|
3846 } |
|
3847 |
|
3848 static int |
|
3849 load_global(Unpicklerobject *self) |
|
3850 { |
|
3851 PyObject *class = 0, *module_name = 0, *class_name = 0; |
|
3852 int len; |
|
3853 char *s; |
|
3854 |
|
3855 if ((len = self->readline_func(self, &s)) < 0) return -1; |
|
3856 if (len < 2) return bad_readline(); |
|
3857 module_name = PyString_FromStringAndSize(s, len - 1); |
|
3858 if (!module_name) return -1; |
|
3859 |
|
3860 if ((len = self->readline_func(self, &s)) >= 0) { |
|
3861 if (len < 2) { |
|
3862 Py_DECREF(module_name); |
|
3863 return bad_readline(); |
|
3864 } |
|
3865 if ((class_name = PyString_FromStringAndSize(s, len - 1))) { |
|
3866 class = find_class(module_name, class_name, |
|
3867 self->find_class); |
|
3868 Py_DECREF(class_name); |
|
3869 } |
|
3870 } |
|
3871 Py_DECREF(module_name); |
|
3872 |
|
3873 if (! class) return -1; |
|
3874 PDATA_PUSH(self->stack, class, -1); |
|
3875 return 0; |
|
3876 } |
|
3877 |
|
3878 |
|
3879 static int |
|
3880 load_persid(Unpicklerobject *self) |
|
3881 { |
|
3882 PyObject *pid = 0; |
|
3883 int len; |
|
3884 char *s; |
|
3885 |
|
3886 if (self->pers_func) { |
|
3887 if ((len = self->readline_func(self, &s)) < 0) return -1; |
|
3888 if (len < 2) return bad_readline(); |
|
3889 |
|
3890 pid = PyString_FromStringAndSize(s, len - 1); |
|
3891 if (!pid) return -1; |
|
3892 |
|
3893 if (PyList_Check(self->pers_func)) { |
|
3894 if (PyList_Append(self->pers_func, pid) < 0) { |
|
3895 Py_DECREF(pid); |
|
3896 return -1; |
|
3897 } |
|
3898 } |
|
3899 else { |
|
3900 ARG_TUP(self, pid); |
|
3901 if (self->arg) { |
|
3902 pid = PyObject_Call(self->pers_func, self->arg, |
|
3903 NULL); |
|
3904 FREE_ARG_TUP(self); |
|
3905 } |
|
3906 } |
|
3907 |
|
3908 if (! pid) return -1; |
|
3909 |
|
3910 PDATA_PUSH(self->stack, pid, -1); |
|
3911 return 0; |
|
3912 } |
|
3913 else { |
|
3914 PyErr_SetString(UnpicklingError, |
|
3915 "A load persistent id instruction was encountered,\n" |
|
3916 "but no persistent_load function was specified."); |
|
3917 return -1; |
|
3918 } |
|
3919 } |
|
3920 |
|
3921 static int |
|
3922 load_binpersid(Unpicklerobject *self) |
|
3923 { |
|
3924 PyObject *pid = 0; |
|
3925 |
|
3926 if (self->pers_func) { |
|
3927 PDATA_POP(self->stack, pid); |
|
3928 if (! pid) return -1; |
|
3929 |
|
3930 if (PyList_Check(self->pers_func)) { |
|
3931 if (PyList_Append(self->pers_func, pid) < 0) { |
|
3932 Py_DECREF(pid); |
|
3933 return -1; |
|
3934 } |
|
3935 } |
|
3936 else { |
|
3937 ARG_TUP(self, pid); |
|
3938 if (self->arg) { |
|
3939 pid = PyObject_Call(self->pers_func, self->arg, |
|
3940 NULL); |
|
3941 FREE_ARG_TUP(self); |
|
3942 } |
|
3943 if (! pid) return -1; |
|
3944 } |
|
3945 |
|
3946 PDATA_PUSH(self->stack, pid, -1); |
|
3947 return 0; |
|
3948 } |
|
3949 else { |
|
3950 PyErr_SetString(UnpicklingError, |
|
3951 "A load persistent id instruction was encountered,\n" |
|
3952 "but no persistent_load function was specified."); |
|
3953 return -1; |
|
3954 } |
|
3955 } |
|
3956 |
|
3957 |
|
3958 static int |
|
3959 load_pop(Unpicklerobject *self) |
|
3960 { |
|
3961 int len; |
|
3962 |
|
3963 if (!( (len=self->stack->length) > 0 )) return stackUnderflow(); |
|
3964 |
|
3965 /* Note that we split the (pickle.py) stack into two stacks, |
|
3966 an object stack and a mark stack. We have to be clever and |
|
3967 pop the right one. We do this by looking at the top of the |
|
3968 mark stack. |
|
3969 */ |
|
3970 |
|
3971 if ((self->num_marks > 0) && |
|
3972 (self->marks[self->num_marks - 1] == len)) |
|
3973 self->num_marks--; |
|
3974 else { |
|
3975 len--; |
|
3976 Py_DECREF(self->stack->data[len]); |
|
3977 self->stack->length=len; |
|
3978 } |
|
3979 |
|
3980 return 0; |
|
3981 } |
|
3982 |
|
3983 |
|
3984 static int |
|
3985 load_pop_mark(Unpicklerobject *self) |
|
3986 { |
|
3987 int i; |
|
3988 |
|
3989 if ((i = marker(self)) < 0) |
|
3990 return -1; |
|
3991 |
|
3992 Pdata_clear(self->stack, i); |
|
3993 |
|
3994 return 0; |
|
3995 } |
|
3996 |
|
3997 |
|
3998 static int |
|
3999 load_dup(Unpicklerobject *self) |
|
4000 { |
|
4001 PyObject *last; |
|
4002 int len; |
|
4003 |
|
4004 if ((len = self->stack->length) <= 0) return stackUnderflow(); |
|
4005 last=self->stack->data[len-1]; |
|
4006 Py_INCREF(last); |
|
4007 PDATA_PUSH(self->stack, last, -1); |
|
4008 return 0; |
|
4009 } |
|
4010 |
|
4011 |
|
4012 static int |
|
4013 load_get(Unpicklerobject *self) |
|
4014 { |
|
4015 PyObject *py_str = 0, *value = 0; |
|
4016 int len; |
|
4017 char *s; |
|
4018 int rc; |
|
4019 |
|
4020 if ((len = self->readline_func(self, &s)) < 0) return -1; |
|
4021 if (len < 2) return bad_readline(); |
|
4022 |
|
4023 if (!( py_str = PyString_FromStringAndSize(s, len - 1))) return -1; |
|
4024 |
|
4025 value = PyDict_GetItem(self->memo, py_str); |
|
4026 if (! value) { |
|
4027 PyErr_SetObject(BadPickleGet, py_str); |
|
4028 rc = -1; |
|
4029 } |
|
4030 else { |
|
4031 PDATA_APPEND(self->stack, value, -1); |
|
4032 rc = 0; |
|
4033 } |
|
4034 |
|
4035 Py_DECREF(py_str); |
|
4036 return rc; |
|
4037 } |
|
4038 |
|
4039 |
|
4040 static int |
|
4041 load_binget(Unpicklerobject *self) |
|
4042 { |
|
4043 PyObject *py_key = 0, *value = 0; |
|
4044 unsigned char key; |
|
4045 char *s; |
|
4046 int rc; |
|
4047 |
|
4048 if (self->read_func(self, &s, 1) < 0) return -1; |
|
4049 |
|
4050 key = (unsigned char)s[0]; |
|
4051 if (!( py_key = PyInt_FromLong((long)key))) return -1; |
|
4052 |
|
4053 value = PyDict_GetItem(self->memo, py_key); |
|
4054 if (! value) { |
|
4055 PyErr_SetObject(BadPickleGet, py_key); |
|
4056 rc = -1; |
|
4057 } |
|
4058 else { |
|
4059 PDATA_APPEND(self->stack, value, -1); |
|
4060 rc = 0; |
|
4061 } |
|
4062 |
|
4063 Py_DECREF(py_key); |
|
4064 return rc; |
|
4065 } |
|
4066 |
|
4067 |
|
4068 static int |
|
4069 load_long_binget(Unpicklerobject *self) |
|
4070 { |
|
4071 PyObject *py_key = 0, *value = 0; |
|
4072 unsigned char c; |
|
4073 char *s; |
|
4074 long key; |
|
4075 int rc; |
|
4076 |
|
4077 if (self->read_func(self, &s, 4) < 0) return -1; |
|
4078 |
|
4079 c = (unsigned char)s[0]; |
|
4080 key = (long)c; |
|
4081 c = (unsigned char)s[1]; |
|
4082 key |= (long)c << 8; |
|
4083 c = (unsigned char)s[2]; |
|
4084 key |= (long)c << 16; |
|
4085 c = (unsigned char)s[3]; |
|
4086 key |= (long)c << 24; |
|
4087 |
|
4088 if (!( py_key = PyInt_FromLong((long)key))) return -1; |
|
4089 |
|
4090 value = PyDict_GetItem(self->memo, py_key); |
|
4091 if (! value) { |
|
4092 PyErr_SetObject(BadPickleGet, py_key); |
|
4093 rc = -1; |
|
4094 } |
|
4095 else { |
|
4096 PDATA_APPEND(self->stack, value, -1); |
|
4097 rc = 0; |
|
4098 } |
|
4099 |
|
4100 Py_DECREF(py_key); |
|
4101 return rc; |
|
4102 } |
|
4103 |
|
4104 /* Push an object from the extension registry (EXT[124]). nbytes is |
|
4105 * the number of bytes following the opcode, holding the index (code) value. |
|
4106 */ |
|
4107 static int |
|
4108 load_extension(Unpicklerobject *self, int nbytes) |
|
4109 { |
|
4110 char *codebytes; /* the nbytes bytes after the opcode */ |
|
4111 long code; /* calc_binint returns long */ |
|
4112 PyObject *py_code; /* code as a Python int */ |
|
4113 PyObject *obj; /* the object to push */ |
|
4114 PyObject *pair; /* (module_name, class_name) */ |
|
4115 PyObject *module_name, *class_name; |
|
4116 |
|
4117 assert(nbytes == 1 || nbytes == 2 || nbytes == 4); |
|
4118 if (self->read_func(self, &codebytes, nbytes) < 0) return -1; |
|
4119 code = calc_binint(codebytes, nbytes); |
|
4120 if (code <= 0) { /* note that 0 is forbidden */ |
|
4121 /* Corrupt or hostile pickle. */ |
|
4122 PyErr_SetString(UnpicklingError, "EXT specifies code <= 0"); |
|
4123 return -1; |
|
4124 } |
|
4125 |
|
4126 /* Look for the code in the cache. */ |
|
4127 py_code = PyInt_FromLong(code); |
|
4128 if (py_code == NULL) return -1; |
|
4129 obj = PyDict_GetItem(extension_cache, py_code); |
|
4130 if (obj != NULL) { |
|
4131 /* Bingo. */ |
|
4132 Py_DECREF(py_code); |
|
4133 PDATA_APPEND(self->stack, obj, -1); |
|
4134 return 0; |
|
4135 } |
|
4136 |
|
4137 /* Look up the (module_name, class_name) pair. */ |
|
4138 pair = PyDict_GetItem(inverted_registry, py_code); |
|
4139 if (pair == NULL) { |
|
4140 Py_DECREF(py_code); |
|
4141 PyErr_Format(PyExc_ValueError, "unregistered extension " |
|
4142 "code %ld", code); |
|
4143 return -1; |
|
4144 } |
|
4145 /* Since the extension registry is manipulable via Python code, |
|
4146 * confirm that pair is really a 2-tuple of strings. |
|
4147 */ |
|
4148 if (!PyTuple_Check(pair) || PyTuple_Size(pair) != 2 || |
|
4149 !PyString_Check(module_name = PyTuple_GET_ITEM(pair, 0)) || |
|
4150 !PyString_Check(class_name = PyTuple_GET_ITEM(pair, 1))) { |
|
4151 Py_DECREF(py_code); |
|
4152 PyErr_Format(PyExc_ValueError, "_inverted_registry[%ld] " |
|
4153 "isn't a 2-tuple of strings", code); |
|
4154 return -1; |
|
4155 } |
|
4156 /* Load the object. */ |
|
4157 obj = find_class(module_name, class_name, self->find_class); |
|
4158 if (obj == NULL) { |
|
4159 Py_DECREF(py_code); |
|
4160 return -1; |
|
4161 } |
|
4162 /* Cache code -> obj. */ |
|
4163 code = PyDict_SetItem(extension_cache, py_code, obj); |
|
4164 Py_DECREF(py_code); |
|
4165 if (code < 0) { |
|
4166 Py_DECREF(obj); |
|
4167 return -1; |
|
4168 } |
|
4169 PDATA_PUSH(self->stack, obj, -1); |
|
4170 return 0; |
|
4171 } |
|
4172 |
|
4173 static int |
|
4174 load_put(Unpicklerobject *self) |
|
4175 { |
|
4176 PyObject *py_str = 0, *value = 0; |
|
4177 int len, l; |
|
4178 char *s; |
|
4179 |
|
4180 if ((l = self->readline_func(self, &s)) < 0) return -1; |
|
4181 if (l < 2) return bad_readline(); |
|
4182 if (!( len=self->stack->length )) return stackUnderflow(); |
|
4183 if (!( py_str = PyString_FromStringAndSize(s, l - 1))) return -1; |
|
4184 value=self->stack->data[len-1]; |
|
4185 l=PyDict_SetItem(self->memo, py_str, value); |
|
4186 Py_DECREF(py_str); |
|
4187 return l; |
|
4188 } |
|
4189 |
|
4190 |
|
4191 static int |
|
4192 load_binput(Unpicklerobject *self) |
|
4193 { |
|
4194 PyObject *py_key = 0, *value = 0; |
|
4195 unsigned char key; |
|
4196 char *s; |
|
4197 int len; |
|
4198 |
|
4199 if (self->read_func(self, &s, 1) < 0) return -1; |
|
4200 if (!( (len=self->stack->length) > 0 )) return stackUnderflow(); |
|
4201 |
|
4202 key = (unsigned char)s[0]; |
|
4203 |
|
4204 if (!( py_key = PyInt_FromLong((long)key))) return -1; |
|
4205 value=self->stack->data[len-1]; |
|
4206 len=PyDict_SetItem(self->memo, py_key, value); |
|
4207 Py_DECREF(py_key); |
|
4208 return len; |
|
4209 } |
|
4210 |
|
4211 |
|
4212 static int |
|
4213 load_long_binput(Unpicklerobject *self) |
|
4214 { |
|
4215 PyObject *py_key = 0, *value = 0; |
|
4216 long key; |
|
4217 unsigned char c; |
|
4218 char *s; |
|
4219 int len; |
|
4220 |
|
4221 if (self->read_func(self, &s, 4) < 0) return -1; |
|
4222 if (!( len=self->stack->length )) return stackUnderflow(); |
|
4223 |
|
4224 c = (unsigned char)s[0]; |
|
4225 key = (long)c; |
|
4226 c = (unsigned char)s[1]; |
|
4227 key |= (long)c << 8; |
|
4228 c = (unsigned char)s[2]; |
|
4229 key |= (long)c << 16; |
|
4230 c = (unsigned char)s[3]; |
|
4231 key |= (long)c << 24; |
|
4232 |
|
4233 if (!( py_key = PyInt_FromLong(key))) return -1; |
|
4234 value=self->stack->data[len-1]; |
|
4235 len=PyDict_SetItem(self->memo, py_key, value); |
|
4236 Py_DECREF(py_key); |
|
4237 return len; |
|
4238 } |
|
4239 |
|
4240 |
|
4241 static int |
|
4242 do_append(Unpicklerobject *self, int x) |
|
4243 { |
|
4244 PyObject *value = 0, *list = 0, *append_method = 0; |
|
4245 int len, i; |
|
4246 |
|
4247 len=self->stack->length; |
|
4248 if (!( len >= x && x > 0 )) return stackUnderflow(); |
|
4249 /* nothing to do */ |
|
4250 if (len==x) return 0; |
|
4251 |
|
4252 list=self->stack->data[x-1]; |
|
4253 |
|
4254 if (PyList_Check(list)) { |
|
4255 PyObject *slice; |
|
4256 int list_len; |
|
4257 |
|
4258 slice=Pdata_popList(self->stack, x); |
|
4259 if (! slice) return -1; |
|
4260 list_len = PyList_GET_SIZE(list); |
|
4261 i=PyList_SetSlice(list, list_len, list_len, slice); |
|
4262 Py_DECREF(slice); |
|
4263 return i; |
|
4264 } |
|
4265 else { |
|
4266 |
|
4267 if (!( append_method = PyObject_GetAttr(list, append_str))) |
|
4268 return -1; |
|
4269 |
|
4270 for (i = x; i < len; i++) { |
|
4271 PyObject *junk; |
|
4272 |
|
4273 value=self->stack->data[i]; |
|
4274 junk=0; |
|
4275 ARG_TUP(self, value); |
|
4276 if (self->arg) { |
|
4277 junk = PyObject_Call(append_method, self->arg, |
|
4278 NULL); |
|
4279 FREE_ARG_TUP(self); |
|
4280 } |
|
4281 if (! junk) { |
|
4282 Pdata_clear(self->stack, i+1); |
|
4283 self->stack->length=x; |
|
4284 Py_DECREF(append_method); |
|
4285 return -1; |
|
4286 } |
|
4287 Py_DECREF(junk); |
|
4288 } |
|
4289 self->stack->length=x; |
|
4290 Py_DECREF(append_method); |
|
4291 } |
|
4292 |
|
4293 return 0; |
|
4294 } |
|
4295 |
|
4296 |
|
4297 static int |
|
4298 load_append(Unpicklerobject *self) |
|
4299 { |
|
4300 return do_append(self, self->stack->length - 1); |
|
4301 } |
|
4302 |
|
4303 |
|
4304 static int |
|
4305 load_appends(Unpicklerobject *self) |
|
4306 { |
|
4307 return do_append(self, marker(self)); |
|
4308 } |
|
4309 |
|
4310 |
|
4311 static int |
|
4312 do_setitems(Unpicklerobject *self, int x) |
|
4313 { |
|
4314 PyObject *value = 0, *key = 0, *dict = 0; |
|
4315 int len, i, r=0; |
|
4316 |
|
4317 if (!( (len=self->stack->length) >= x |
|
4318 && x > 0 )) return stackUnderflow(); |
|
4319 |
|
4320 dict=self->stack->data[x-1]; |
|
4321 |
|
4322 for (i = x+1; i < len; i += 2) { |
|
4323 key =self->stack->data[i-1]; |
|
4324 value=self->stack->data[i ]; |
|
4325 if (PyObject_SetItem(dict, key, value) < 0) { |
|
4326 r=-1; |
|
4327 break; |
|
4328 } |
|
4329 } |
|
4330 |
|
4331 Pdata_clear(self->stack, x); |
|
4332 |
|
4333 return r; |
|
4334 } |
|
4335 |
|
4336 |
|
4337 static int |
|
4338 load_setitem(Unpicklerobject *self) |
|
4339 { |
|
4340 return do_setitems(self, self->stack->length - 2); |
|
4341 } |
|
4342 |
|
4343 static int |
|
4344 load_setitems(Unpicklerobject *self) |
|
4345 { |
|
4346 return do_setitems(self, marker(self)); |
|
4347 } |
|
4348 |
|
4349 |
|
4350 static int |
|
4351 load_build(Unpicklerobject *self) |
|
4352 { |
|
4353 PyObject *state, *inst, *slotstate; |
|
4354 PyObject *__setstate__; |
|
4355 PyObject *d_key, *d_value; |
|
4356 Py_ssize_t i; |
|
4357 int res = -1; |
|
4358 |
|
4359 /* Stack is ... instance, state. We want to leave instance at |
|
4360 * the stack top, possibly mutated via instance.__setstate__(state). |
|
4361 */ |
|
4362 if (self->stack->length < 2) |
|
4363 return stackUnderflow(); |
|
4364 PDATA_POP(self->stack, state); |
|
4365 if (state == NULL) |
|
4366 return -1; |
|
4367 inst = self->stack->data[self->stack->length - 1]; |
|
4368 |
|
4369 __setstate__ = PyObject_GetAttr(inst, __setstate___str); |
|
4370 if (__setstate__ != NULL) { |
|
4371 PyObject *junk = NULL; |
|
4372 |
|
4373 /* The explicit __setstate__ is responsible for everything. */ |
|
4374 ARG_TUP(self, state); |
|
4375 if (self->arg) { |
|
4376 junk = PyObject_Call(__setstate__, self->arg, NULL); |
|
4377 FREE_ARG_TUP(self); |
|
4378 } |
|
4379 Py_DECREF(__setstate__); |
|
4380 if (junk == NULL) |
|
4381 return -1; |
|
4382 Py_DECREF(junk); |
|
4383 return 0; |
|
4384 } |
|
4385 if (!PyErr_ExceptionMatches(PyExc_AttributeError)) |
|
4386 return -1; |
|
4387 PyErr_Clear(); |
|
4388 |
|
4389 /* A default __setstate__. First see whether state embeds a |
|
4390 * slot state dict too (a proto 2 addition). |
|
4391 */ |
|
4392 if (PyTuple_Check(state) && PyTuple_Size(state) == 2) { |
|
4393 PyObject *temp = state; |
|
4394 state = PyTuple_GET_ITEM(temp, 0); |
|
4395 slotstate = PyTuple_GET_ITEM(temp, 1); |
|
4396 Py_INCREF(state); |
|
4397 Py_INCREF(slotstate); |
|
4398 Py_DECREF(temp); |
|
4399 } |
|
4400 else |
|
4401 slotstate = NULL; |
|
4402 |
|
4403 /* Set inst.__dict__ from the state dict (if any). */ |
|
4404 if (state != Py_None) { |
|
4405 PyObject *dict; |
|
4406 if (! PyDict_Check(state)) { |
|
4407 PyErr_SetString(UnpicklingError, "state is not a " |
|
4408 "dictionary"); |
|
4409 goto finally; |
|
4410 } |
|
4411 dict = PyObject_GetAttr(inst, __dict___str); |
|
4412 if (dict == NULL) |
|
4413 goto finally; |
|
4414 |
|
4415 i = 0; |
|
4416 while (PyDict_Next(state, &i, &d_key, &d_value)) { |
|
4417 if (PyObject_SetItem(dict, d_key, d_value) < 0) |
|
4418 goto finally; |
|
4419 } |
|
4420 Py_DECREF(dict); |
|
4421 } |
|
4422 |
|
4423 /* Also set instance attributes from the slotstate dict (if any). */ |
|
4424 if (slotstate != NULL) { |
|
4425 if (! PyDict_Check(slotstate)) { |
|
4426 PyErr_SetString(UnpicklingError, "slot state is not " |
|
4427 "a dictionary"); |
|
4428 goto finally; |
|
4429 } |
|
4430 i = 0; |
|
4431 while (PyDict_Next(slotstate, &i, &d_key, &d_value)) { |
|
4432 if (PyObject_SetAttr(inst, d_key, d_value) < 0) |
|
4433 goto finally; |
|
4434 } |
|
4435 } |
|
4436 res = 0; |
|
4437 |
|
4438 finally: |
|
4439 Py_DECREF(state); |
|
4440 Py_XDECREF(slotstate); |
|
4441 return res; |
|
4442 } |
|
4443 |
|
4444 |
|
4445 static int |
|
4446 load_mark(Unpicklerobject *self) |
|
4447 { |
|
4448 int s; |
|
4449 |
|
4450 /* Note that we split the (pickle.py) stack into two stacks, an |
|
4451 object stack and a mark stack. Here we push a mark onto the |
|
4452 mark stack. |
|
4453 */ |
|
4454 |
|
4455 if ((self->num_marks + 1) >= self->marks_size) { |
|
4456 int *marks; |
|
4457 s=self->marks_size+20; |
|
4458 if (s <= self->num_marks) s=self->num_marks + 1; |
|
4459 if (self->marks == NULL) |
|
4460 marks=(int *)malloc(s * sizeof(int)); |
|
4461 else |
|
4462 marks=(int *)realloc(self->marks, |
|
4463 s * sizeof(int)); |
|
4464 if (!marks) { |
|
4465 PyErr_NoMemory(); |
|
4466 return -1; |
|
4467 } |
|
4468 self->marks = marks; |
|
4469 self->marks_size = s; |
|
4470 } |
|
4471 |
|
4472 self->marks[self->num_marks++] = self->stack->length; |
|
4473 |
|
4474 return 0; |
|
4475 } |
|
4476 |
|
4477 static int |
|
4478 load_reduce(Unpicklerobject *self) |
|
4479 { |
|
4480 PyObject *callable = 0, *arg_tup = 0, *ob = 0; |
|
4481 |
|
4482 PDATA_POP(self->stack, arg_tup); |
|
4483 if (! arg_tup) return -1; |
|
4484 PDATA_POP(self->stack, callable); |
|
4485 if (callable) { |
|
4486 ob = Instance_New(callable, arg_tup); |
|
4487 Py_DECREF(callable); |
|
4488 } |
|
4489 Py_DECREF(arg_tup); |
|
4490 |
|
4491 if (! ob) return -1; |
|
4492 |
|
4493 PDATA_PUSH(self->stack, ob, -1); |
|
4494 return 0; |
|
4495 } |
|
4496 |
|
4497 /* Just raises an error if we don't know the protocol specified. PROTO |
|
4498 * is the first opcode for protocols >= 2. |
|
4499 */ |
|
4500 static int |
|
4501 load_proto(Unpicklerobject *self) |
|
4502 { |
|
4503 int i; |
|
4504 char *protobyte; |
|
4505 |
|
4506 i = self->read_func(self, &protobyte, 1); |
|
4507 if (i < 0) |
|
4508 return -1; |
|
4509 |
|
4510 i = calc_binint(protobyte, 1); |
|
4511 /* No point checking for < 0, since calc_binint returns an unsigned |
|
4512 * int when chewing on 1 byte. |
|
4513 */ |
|
4514 assert(i >= 0); |
|
4515 if (i <= HIGHEST_PROTOCOL) |
|
4516 return 0; |
|
4517 |
|
4518 PyErr_Format(PyExc_ValueError, "unsupported pickle protocol: %d", i); |
|
4519 return -1; |
|
4520 } |
|
4521 |
|
4522 static PyObject * |
|
4523 load(Unpicklerobject *self) |
|
4524 { |
|
4525 PyObject *err = 0, *val = 0; |
|
4526 char *s; |
|
4527 |
|
4528 self->num_marks = 0; |
|
4529 if (self->stack->length) Pdata_clear(self->stack, 0); |
|
4530 |
|
4531 while (1) { |
|
4532 if (self->read_func(self, &s, 1) < 0) |
|
4533 break; |
|
4534 |
|
4535 switch (s[0]) { |
|
4536 case NONE: |
|
4537 if (load_none(self) < 0) |
|
4538 break; |
|
4539 continue; |
|
4540 |
|
4541 case BININT: |
|
4542 if (load_binint(self) < 0) |
|
4543 break; |
|
4544 continue; |
|
4545 |
|
4546 case BININT1: |
|
4547 if (load_binint1(self) < 0) |
|
4548 break; |
|
4549 continue; |
|
4550 |
|
4551 case BININT2: |
|
4552 if (load_binint2(self) < 0) |
|
4553 break; |
|
4554 continue; |
|
4555 |
|
4556 case INT: |
|
4557 if (load_int(self) < 0) |
|
4558 break; |
|
4559 continue; |
|
4560 |
|
4561 case LONG: |
|
4562 if (load_long(self) < 0) |
|
4563 break; |
|
4564 continue; |
|
4565 |
|
4566 case LONG1: |
|
4567 if (load_counted_long(self, 1) < 0) |
|
4568 break; |
|
4569 continue; |
|
4570 |
|
4571 case LONG4: |
|
4572 if (load_counted_long(self, 4) < 0) |
|
4573 break; |
|
4574 continue; |
|
4575 |
|
4576 case FLOAT: |
|
4577 if (load_float(self) < 0) |
|
4578 break; |
|
4579 continue; |
|
4580 |
|
4581 case BINFLOAT: |
|
4582 if (load_binfloat(self) < 0) |
|
4583 break; |
|
4584 continue; |
|
4585 |
|
4586 case BINSTRING: |
|
4587 if (load_binstring(self) < 0) |
|
4588 break; |
|
4589 continue; |
|
4590 |
|
4591 case SHORT_BINSTRING: |
|
4592 if (load_short_binstring(self) < 0) |
|
4593 break; |
|
4594 continue; |
|
4595 |
|
4596 case STRING: |
|
4597 if (load_string(self) < 0) |
|
4598 break; |
|
4599 continue; |
|
4600 |
|
4601 #ifdef Py_USING_UNICODE |
|
4602 case UNICODE: |
|
4603 if (load_unicode(self) < 0) |
|
4604 break; |
|
4605 continue; |
|
4606 |
|
4607 case BINUNICODE: |
|
4608 if (load_binunicode(self) < 0) |
|
4609 break; |
|
4610 continue; |
|
4611 #endif |
|
4612 |
|
4613 case EMPTY_TUPLE: |
|
4614 if (load_counted_tuple(self, 0) < 0) |
|
4615 break; |
|
4616 continue; |
|
4617 |
|
4618 case TUPLE1: |
|
4619 if (load_counted_tuple(self, 1) < 0) |
|
4620 break; |
|
4621 continue; |
|
4622 |
|
4623 case TUPLE2: |
|
4624 if (load_counted_tuple(self, 2) < 0) |
|
4625 break; |
|
4626 continue; |
|
4627 |
|
4628 case TUPLE3: |
|
4629 if (load_counted_tuple(self, 3) < 0) |
|
4630 break; |
|
4631 continue; |
|
4632 |
|
4633 case TUPLE: |
|
4634 if (load_tuple(self) < 0) |
|
4635 break; |
|
4636 continue; |
|
4637 |
|
4638 case EMPTY_LIST: |
|
4639 if (load_empty_list(self) < 0) |
|
4640 break; |
|
4641 continue; |
|
4642 |
|
4643 case LIST: |
|
4644 if (load_list(self) < 0) |
|
4645 break; |
|
4646 continue; |
|
4647 |
|
4648 case EMPTY_DICT: |
|
4649 if (load_empty_dict(self) < 0) |
|
4650 break; |
|
4651 continue; |
|
4652 |
|
4653 case DICT: |
|
4654 if (load_dict(self) < 0) |
|
4655 break; |
|
4656 continue; |
|
4657 |
|
4658 case OBJ: |
|
4659 if (load_obj(self) < 0) |
|
4660 break; |
|
4661 continue; |
|
4662 |
|
4663 case INST: |
|
4664 if (load_inst(self) < 0) |
|
4665 break; |
|
4666 continue; |
|
4667 |
|
4668 case NEWOBJ: |
|
4669 if (load_newobj(self) < 0) |
|
4670 break; |
|
4671 continue; |
|
4672 |
|
4673 case GLOBAL: |
|
4674 if (load_global(self) < 0) |
|
4675 break; |
|
4676 continue; |
|
4677 |
|
4678 case APPEND: |
|
4679 if (load_append(self) < 0) |
|
4680 break; |
|
4681 continue; |
|
4682 |
|
4683 case APPENDS: |
|
4684 if (load_appends(self) < 0) |
|
4685 break; |
|
4686 continue; |
|
4687 |
|
4688 case BUILD: |
|
4689 if (load_build(self) < 0) |
|
4690 break; |
|
4691 continue; |
|
4692 |
|
4693 case DUP: |
|
4694 if (load_dup(self) < 0) |
|
4695 break; |
|
4696 continue; |
|
4697 |
|
4698 case BINGET: |
|
4699 if (load_binget(self) < 0) |
|
4700 break; |
|
4701 continue; |
|
4702 |
|
4703 case LONG_BINGET: |
|
4704 if (load_long_binget(self) < 0) |
|
4705 break; |
|
4706 continue; |
|
4707 |
|
4708 case GET: |
|
4709 if (load_get(self) < 0) |
|
4710 break; |
|
4711 continue; |
|
4712 |
|
4713 case EXT1: |
|
4714 if (load_extension(self, 1) < 0) |
|
4715 break; |
|
4716 continue; |
|
4717 |
|
4718 case EXT2: |
|
4719 if (load_extension(self, 2) < 0) |
|
4720 break; |
|
4721 continue; |
|
4722 |
|
4723 case EXT4: |
|
4724 if (load_extension(self, 4) < 0) |
|
4725 break; |
|
4726 continue; |
|
4727 case MARK: |
|
4728 if (load_mark(self) < 0) |
|
4729 break; |
|
4730 continue; |
|
4731 |
|
4732 case BINPUT: |
|
4733 if (load_binput(self) < 0) |
|
4734 break; |
|
4735 continue; |
|
4736 |
|
4737 case LONG_BINPUT: |
|
4738 if (load_long_binput(self) < 0) |
|
4739 break; |
|
4740 continue; |
|
4741 |
|
4742 case PUT: |
|
4743 if (load_put(self) < 0) |
|
4744 break; |
|
4745 continue; |
|
4746 |
|
4747 case POP: |
|
4748 if (load_pop(self) < 0) |
|
4749 break; |
|
4750 continue; |
|
4751 |
|
4752 case POP_MARK: |
|
4753 if (load_pop_mark(self) < 0) |
|
4754 break; |
|
4755 continue; |
|
4756 |
|
4757 case SETITEM: |
|
4758 if (load_setitem(self) < 0) |
|
4759 break; |
|
4760 continue; |
|
4761 |
|
4762 case SETITEMS: |
|
4763 if (load_setitems(self) < 0) |
|
4764 break; |
|
4765 continue; |
|
4766 |
|
4767 case STOP: |
|
4768 break; |
|
4769 |
|
4770 case PERSID: |
|
4771 if (load_persid(self) < 0) |
|
4772 break; |
|
4773 continue; |
|
4774 |
|
4775 case BINPERSID: |
|
4776 if (load_binpersid(self) < 0) |
|
4777 break; |
|
4778 continue; |
|
4779 |
|
4780 case REDUCE: |
|
4781 if (load_reduce(self) < 0) |
|
4782 break; |
|
4783 continue; |
|
4784 |
|
4785 case PROTO: |
|
4786 if (load_proto(self) < 0) |
|
4787 break; |
|
4788 continue; |
|
4789 |
|
4790 case NEWTRUE: |
|
4791 if (load_bool(self, Py_True) < 0) |
|
4792 break; |
|
4793 continue; |
|
4794 |
|
4795 case NEWFALSE: |
|
4796 if (load_bool(self, Py_False) < 0) |
|
4797 break; |
|
4798 continue; |
|
4799 |
|
4800 case '\0': |
|
4801 /* end of file */ |
|
4802 PyErr_SetNone(PyExc_EOFError); |
|
4803 break; |
|
4804 |
|
4805 default: |
|
4806 cPickle_ErrFormat(UnpicklingError, |
|
4807 "invalid load key, '%s'.", |
|
4808 "c", s[0]); |
|
4809 return NULL; |
|
4810 } |
|
4811 |
|
4812 break; |
|
4813 } |
|
4814 |
|
4815 if ((err = PyErr_Occurred())) { |
|
4816 if (err == PyExc_EOFError) { |
|
4817 PyErr_SetNone(PyExc_EOFError); |
|
4818 } |
|
4819 return NULL; |
|
4820 } |
|
4821 |
|
4822 PDATA_POP(self->stack, val); |
|
4823 return val; |
|
4824 } |
|
4825 |
|
4826 |
|
4827 /* No-load functions to support noload, which is used to |
|
4828 find persistent references. */ |
|
4829 |
|
4830 static int |
|
4831 noload_obj(Unpicklerobject *self) |
|
4832 { |
|
4833 int i; |
|
4834 |
|
4835 if ((i = marker(self)) < 0) return -1; |
|
4836 return Pdata_clear(self->stack, i+1); |
|
4837 } |
|
4838 |
|
4839 |
|
4840 static int |
|
4841 noload_inst(Unpicklerobject *self) |
|
4842 { |
|
4843 int i; |
|
4844 char *s; |
|
4845 |
|
4846 if ((i = marker(self)) < 0) return -1; |
|
4847 Pdata_clear(self->stack, i); |
|
4848 if (self->readline_func(self, &s) < 0) return -1; |
|
4849 if (self->readline_func(self, &s) < 0) return -1; |
|
4850 PDATA_APPEND(self->stack, Py_None, -1); |
|
4851 return 0; |
|
4852 } |
|
4853 |
|
4854 static int |
|
4855 noload_newobj(Unpicklerobject *self) |
|
4856 { |
|
4857 PyObject *obj; |
|
4858 |
|
4859 PDATA_POP(self->stack, obj); /* pop argtuple */ |
|
4860 if (obj == NULL) return -1; |
|
4861 Py_DECREF(obj); |
|
4862 |
|
4863 PDATA_POP(self->stack, obj); /* pop cls */ |
|
4864 if (obj == NULL) return -1; |
|
4865 Py_DECREF(obj); |
|
4866 |
|
4867 PDATA_APPEND(self->stack, Py_None, -1); |
|
4868 return 0; |
|
4869 } |
|
4870 |
|
4871 static int |
|
4872 noload_global(Unpicklerobject *self) |
|
4873 { |
|
4874 char *s; |
|
4875 |
|
4876 if (self->readline_func(self, &s) < 0) return -1; |
|
4877 if (self->readline_func(self, &s) < 0) return -1; |
|
4878 PDATA_APPEND(self->stack, Py_None,-1); |
|
4879 return 0; |
|
4880 } |
|
4881 |
|
4882 static int |
|
4883 noload_reduce(Unpicklerobject *self) |
|
4884 { |
|
4885 |
|
4886 if (self->stack->length < 2) return stackUnderflow(); |
|
4887 Pdata_clear(self->stack, self->stack->length-2); |
|
4888 PDATA_APPEND(self->stack, Py_None,-1); |
|
4889 return 0; |
|
4890 } |
|
4891 |
|
4892 static int |
|
4893 noload_build(Unpicklerobject *self) { |
|
4894 |
|
4895 if (self->stack->length < 1) return stackUnderflow(); |
|
4896 Pdata_clear(self->stack, self->stack->length-1); |
|
4897 return 0; |
|
4898 } |
|
4899 |
|
4900 static int |
|
4901 noload_extension(Unpicklerobject *self, int nbytes) |
|
4902 { |
|
4903 char *codebytes; |
|
4904 |
|
4905 assert(nbytes == 1 || nbytes == 2 || nbytes == 4); |
|
4906 if (self->read_func(self, &codebytes, nbytes) < 0) return -1; |
|
4907 PDATA_APPEND(self->stack, Py_None, -1); |
|
4908 return 0; |
|
4909 } |
|
4910 |
|
4911 |
|
4912 static PyObject * |
|
4913 noload(Unpicklerobject *self) |
|
4914 { |
|
4915 PyObject *err = 0, *val = 0; |
|
4916 char *s; |
|
4917 |
|
4918 self->num_marks = 0; |
|
4919 Pdata_clear(self->stack, 0); |
|
4920 |
|
4921 while (1) { |
|
4922 if (self->read_func(self, &s, 1) < 0) |
|
4923 break; |
|
4924 |
|
4925 switch (s[0]) { |
|
4926 case NONE: |
|
4927 if (load_none(self) < 0) |
|
4928 break; |
|
4929 continue; |
|
4930 |
|
4931 case BININT: |
|
4932 if (load_binint(self) < 0) |
|
4933 break; |
|
4934 continue; |
|
4935 |
|
4936 case BININT1: |
|
4937 if (load_binint1(self) < 0) |
|
4938 break; |
|
4939 continue; |
|
4940 |
|
4941 case BININT2: |
|
4942 if (load_binint2(self) < 0) |
|
4943 break; |
|
4944 continue; |
|
4945 |
|
4946 case INT: |
|
4947 if (load_int(self) < 0) |
|
4948 break; |
|
4949 continue; |
|
4950 |
|
4951 case LONG: |
|
4952 if (load_long(self) < 0) |
|
4953 break; |
|
4954 continue; |
|
4955 |
|
4956 case LONG1: |
|
4957 if (load_counted_long(self, 1) < 0) |
|
4958 break; |
|
4959 continue; |
|
4960 |
|
4961 case LONG4: |
|
4962 if (load_counted_long(self, 4) < 0) |
|
4963 break; |
|
4964 continue; |
|
4965 |
|
4966 case FLOAT: |
|
4967 if (load_float(self) < 0) |
|
4968 break; |
|
4969 continue; |
|
4970 |
|
4971 case BINFLOAT: |
|
4972 if (load_binfloat(self) < 0) |
|
4973 break; |
|
4974 continue; |
|
4975 |
|
4976 case BINSTRING: |
|
4977 if (load_binstring(self) < 0) |
|
4978 break; |
|
4979 continue; |
|
4980 |
|
4981 case SHORT_BINSTRING: |
|
4982 if (load_short_binstring(self) < 0) |
|
4983 break; |
|
4984 continue; |
|
4985 |
|
4986 case STRING: |
|
4987 if (load_string(self) < 0) |
|
4988 break; |
|
4989 continue; |
|
4990 |
|
4991 #ifdef Py_USING_UNICODE |
|
4992 case UNICODE: |
|
4993 if (load_unicode(self) < 0) |
|
4994 break; |
|
4995 continue; |
|
4996 |
|
4997 case BINUNICODE: |
|
4998 if (load_binunicode(self) < 0) |
|
4999 break; |
|
5000 continue; |
|
5001 #endif |
|
5002 |
|
5003 case EMPTY_TUPLE: |
|
5004 if (load_counted_tuple(self, 0) < 0) |
|
5005 break; |
|
5006 continue; |
|
5007 |
|
5008 case TUPLE1: |
|
5009 if (load_counted_tuple(self, 1) < 0) |
|
5010 break; |
|
5011 continue; |
|
5012 |
|
5013 case TUPLE2: |
|
5014 if (load_counted_tuple(self, 2) < 0) |
|
5015 break; |
|
5016 continue; |
|
5017 |
|
5018 case TUPLE3: |
|
5019 if (load_counted_tuple(self, 3) < 0) |
|
5020 break; |
|
5021 continue; |
|
5022 |
|
5023 case TUPLE: |
|
5024 if (load_tuple(self) < 0) |
|
5025 break; |
|
5026 continue; |
|
5027 |
|
5028 case EMPTY_LIST: |
|
5029 if (load_empty_list(self) < 0) |
|
5030 break; |
|
5031 continue; |
|
5032 |
|
5033 case LIST: |
|
5034 if (load_list(self) < 0) |
|
5035 break; |
|
5036 continue; |
|
5037 |
|
5038 case EMPTY_DICT: |
|
5039 if (load_empty_dict(self) < 0) |
|
5040 break; |
|
5041 continue; |
|
5042 |
|
5043 case DICT: |
|
5044 if (load_dict(self) < 0) |
|
5045 break; |
|
5046 continue; |
|
5047 |
|
5048 case OBJ: |
|
5049 if (noload_obj(self) < 0) |
|
5050 break; |
|
5051 continue; |
|
5052 |
|
5053 case INST: |
|
5054 if (noload_inst(self) < 0) |
|
5055 break; |
|
5056 continue; |
|
5057 |
|
5058 case NEWOBJ: |
|
5059 if (noload_newobj(self) < 0) |
|
5060 break; |
|
5061 continue; |
|
5062 |
|
5063 case GLOBAL: |
|
5064 if (noload_global(self) < 0) |
|
5065 break; |
|
5066 continue; |
|
5067 |
|
5068 case APPEND: |
|
5069 if (load_append(self) < 0) |
|
5070 break; |
|
5071 continue; |
|
5072 |
|
5073 case APPENDS: |
|
5074 if (load_appends(self) < 0) |
|
5075 break; |
|
5076 continue; |
|
5077 |
|
5078 case BUILD: |
|
5079 if (noload_build(self) < 0) |
|
5080 break; |
|
5081 continue; |
|
5082 |
|
5083 case DUP: |
|
5084 if (load_dup(self) < 0) |
|
5085 break; |
|
5086 continue; |
|
5087 |
|
5088 case BINGET: |
|
5089 if (load_binget(self) < 0) |
|
5090 break; |
|
5091 continue; |
|
5092 |
|
5093 case LONG_BINGET: |
|
5094 if (load_long_binget(self) < 0) |
|
5095 break; |
|
5096 continue; |
|
5097 |
|
5098 case GET: |
|
5099 if (load_get(self) < 0) |
|
5100 break; |
|
5101 continue; |
|
5102 |
|
5103 case EXT1: |
|
5104 if (noload_extension(self, 1) < 0) |
|
5105 break; |
|
5106 continue; |
|
5107 |
|
5108 case EXT2: |
|
5109 if (noload_extension(self, 2) < 0) |
|
5110 break; |
|
5111 continue; |
|
5112 |
|
5113 case EXT4: |
|
5114 if (noload_extension(self, 4) < 0) |
|
5115 break; |
|
5116 continue; |
|
5117 |
|
5118 case MARK: |
|
5119 if (load_mark(self) < 0) |
|
5120 break; |
|
5121 continue; |
|
5122 |
|
5123 case BINPUT: |
|
5124 if (load_binput(self) < 0) |
|
5125 break; |
|
5126 continue; |
|
5127 |
|
5128 case LONG_BINPUT: |
|
5129 if (load_long_binput(self) < 0) |
|
5130 break; |
|
5131 continue; |
|
5132 |
|
5133 case PUT: |
|
5134 if (load_put(self) < 0) |
|
5135 break; |
|
5136 continue; |
|
5137 |
|
5138 case POP: |
|
5139 if (load_pop(self) < 0) |
|
5140 break; |
|
5141 continue; |
|
5142 |
|
5143 case POP_MARK: |
|
5144 if (load_pop_mark(self) < 0) |
|
5145 break; |
|
5146 continue; |
|
5147 |
|
5148 case SETITEM: |
|
5149 if (load_setitem(self) < 0) |
|
5150 break; |
|
5151 continue; |
|
5152 |
|
5153 case SETITEMS: |
|
5154 if (load_setitems(self) < 0) |
|
5155 break; |
|
5156 continue; |
|
5157 |
|
5158 case STOP: |
|
5159 break; |
|
5160 |
|
5161 case PERSID: |
|
5162 if (load_persid(self) < 0) |
|
5163 break; |
|
5164 continue; |
|
5165 |
|
5166 case BINPERSID: |
|
5167 if (load_binpersid(self) < 0) |
|
5168 break; |
|
5169 continue; |
|
5170 |
|
5171 case REDUCE: |
|
5172 if (noload_reduce(self) < 0) |
|
5173 break; |
|
5174 continue; |
|
5175 |
|
5176 case PROTO: |
|
5177 if (load_proto(self) < 0) |
|
5178 break; |
|
5179 continue; |
|
5180 |
|
5181 case NEWTRUE: |
|
5182 if (load_bool(self, Py_True) < 0) |
|
5183 break; |
|
5184 continue; |
|
5185 |
|
5186 case NEWFALSE: |
|
5187 if (load_bool(self, Py_False) < 0) |
|
5188 break; |
|
5189 continue; |
|
5190 default: |
|
5191 cPickle_ErrFormat(UnpicklingError, |
|
5192 "invalid load key, '%s'.", |
|
5193 "c", s[0]); |
|
5194 return NULL; |
|
5195 } |
|
5196 |
|
5197 break; |
|
5198 } |
|
5199 |
|
5200 if ((err = PyErr_Occurred())) { |
|
5201 if (err == PyExc_EOFError) { |
|
5202 PyErr_SetNone(PyExc_EOFError); |
|
5203 } |
|
5204 return NULL; |
|
5205 } |
|
5206 |
|
5207 PDATA_POP(self->stack, val); |
|
5208 return val; |
|
5209 } |
|
5210 |
|
5211 |
|
5212 static PyObject * |
|
5213 Unpickler_load(Unpicklerobject *self, PyObject *unused) |
|
5214 { |
|
5215 return load(self); |
|
5216 } |
|
5217 |
|
5218 static PyObject * |
|
5219 Unpickler_noload(Unpicklerobject *self, PyObject *unused) |
|
5220 { |
|
5221 return noload(self); |
|
5222 } |
|
5223 |
|
5224 |
|
5225 static struct PyMethodDef Unpickler_methods[] = { |
|
5226 {"load", (PyCFunction)Unpickler_load, METH_NOARGS, |
|
5227 PyDoc_STR("load() -- Load a pickle") |
|
5228 }, |
|
5229 {"noload", (PyCFunction)Unpickler_noload, METH_NOARGS, |
|
5230 PyDoc_STR( |
|
5231 "noload() -- not load a pickle, but go through most of the motions\n" |
|
5232 "\n" |
|
5233 "This function can be used to read past a pickle without instantiating\n" |
|
5234 "any objects or importing any modules. It can also be used to find all\n" |
|
5235 "persistent references without instantiating any objects or importing\n" |
|
5236 "any modules.\n") |
|
5237 }, |
|
5238 {NULL, NULL} /* sentinel */ |
|
5239 }; |
|
5240 |
|
5241 |
|
5242 static Unpicklerobject * |
|
5243 newUnpicklerobject(PyObject *f) |
|
5244 { |
|
5245 Unpicklerobject *self; |
|
5246 |
|
5247 if (!( self = PyObject_GC_New(Unpicklerobject, &Unpicklertype))) |
|
5248 return NULL; |
|
5249 |
|
5250 self->file = NULL; |
|
5251 self->arg = NULL; |
|
5252 self->stack = (Pdata*)Pdata_New(); |
|
5253 self->pers_func = NULL; |
|
5254 self->last_string = NULL; |
|
5255 self->marks = NULL; |
|
5256 self->num_marks = 0; |
|
5257 self->marks_size = 0; |
|
5258 self->buf_size = 0; |
|
5259 self->read = NULL; |
|
5260 self->readline = NULL; |
|
5261 self->find_class = NULL; |
|
5262 |
|
5263 if (!( self->memo = PyDict_New())) |
|
5264 goto err; |
|
5265 |
|
5266 if (!self->stack) |
|
5267 goto err; |
|
5268 |
|
5269 Py_INCREF(f); |
|
5270 self->file = f; |
|
5271 |
|
5272 /* Set read, readline based on type of f */ |
|
5273 if (PyFile_Check(f)) { |
|
5274 self->fp = PyFile_AsFile(f); |
|
5275 if (self->fp == NULL) { |
|
5276 PyErr_SetString(PyExc_ValueError, |
|
5277 "I/O operation on closed file"); |
|
5278 goto err; |
|
5279 } |
|
5280 self->read_func = read_file; |
|
5281 self->readline_func = readline_file; |
|
5282 } |
|
5283 else if (PycStringIO_InputCheck(f)) { |
|
5284 self->fp = NULL; |
|
5285 self->read_func = read_cStringIO; |
|
5286 self->readline_func = readline_cStringIO; |
|
5287 } |
|
5288 else { |
|
5289 |
|
5290 self->fp = NULL; |
|
5291 self->read_func = read_other; |
|
5292 self->readline_func = readline_other; |
|
5293 |
|
5294 if (!( (self->readline = PyObject_GetAttr(f, readline_str)) && |
|
5295 (self->read = PyObject_GetAttr(f, read_str)))) { |
|
5296 PyErr_Clear(); |
|
5297 PyErr_SetString( PyExc_TypeError, |
|
5298 "argument must have 'read' and " |
|
5299 "'readline' attributes" ); |
|
5300 goto err; |
|
5301 } |
|
5302 } |
|
5303 PyObject_GC_Track(self); |
|
5304 |
|
5305 return self; |
|
5306 |
|
5307 err: |
|
5308 Py_DECREF((PyObject *)self); |
|
5309 return NULL; |
|
5310 } |
|
5311 |
|
5312 |
|
5313 static PyObject * |
|
5314 get_Unpickler(PyObject *self, PyObject *file) |
|
5315 { |
|
5316 return (PyObject *)newUnpicklerobject(file); |
|
5317 } |
|
5318 |
|
5319 |
|
5320 static void |
|
5321 Unpickler_dealloc(Unpicklerobject *self) |
|
5322 { |
|
5323 PyObject_GC_UnTrack((PyObject *)self); |
|
5324 Py_XDECREF(self->readline); |
|
5325 Py_XDECREF(self->read); |
|
5326 Py_XDECREF(self->file); |
|
5327 Py_XDECREF(self->memo); |
|
5328 Py_XDECREF(self->stack); |
|
5329 Py_XDECREF(self->pers_func); |
|
5330 Py_XDECREF(self->arg); |
|
5331 Py_XDECREF(self->last_string); |
|
5332 Py_XDECREF(self->find_class); |
|
5333 |
|
5334 if (self->marks) { |
|
5335 free(self->marks); |
|
5336 } |
|
5337 |
|
5338 if (self->buf_size) { |
|
5339 free(self->buf); |
|
5340 } |
|
5341 |
|
5342 Py_TYPE(self)->tp_free((PyObject *)self); |
|
5343 } |
|
5344 |
|
5345 static int |
|
5346 Unpickler_traverse(Unpicklerobject *self, visitproc visit, void *arg) |
|
5347 { |
|
5348 Py_VISIT(self->readline); |
|
5349 Py_VISIT(self->read); |
|
5350 Py_VISIT(self->file); |
|
5351 Py_VISIT(self->memo); |
|
5352 Py_VISIT(self->stack); |
|
5353 Py_VISIT(self->pers_func); |
|
5354 Py_VISIT(self->arg); |
|
5355 Py_VISIT(self->last_string); |
|
5356 Py_VISIT(self->find_class); |
|
5357 return 0; |
|
5358 } |
|
5359 |
|
5360 static int |
|
5361 Unpickler_clear(Unpicklerobject *self) |
|
5362 { |
|
5363 Py_CLEAR(self->readline); |
|
5364 Py_CLEAR(self->read); |
|
5365 Py_CLEAR(self->file); |
|
5366 Py_CLEAR(self->memo); |
|
5367 Py_CLEAR(self->stack); |
|
5368 Py_CLEAR(self->pers_func); |
|
5369 Py_CLEAR(self->arg); |
|
5370 Py_CLEAR(self->last_string); |
|
5371 Py_CLEAR(self->find_class); |
|
5372 return 0; |
|
5373 } |
|
5374 |
|
5375 static PyObject * |
|
5376 Unpickler_getattr(Unpicklerobject *self, char *name) |
|
5377 { |
|
5378 if (!strcmp(name, "persistent_load")) { |
|
5379 if (!self->pers_func) { |
|
5380 PyErr_SetString(PyExc_AttributeError, name); |
|
5381 return NULL; |
|
5382 } |
|
5383 |
|
5384 Py_INCREF(self->pers_func); |
|
5385 return self->pers_func; |
|
5386 } |
|
5387 |
|
5388 if (!strcmp(name, "find_global")) { |
|
5389 if (!self->find_class) { |
|
5390 PyErr_SetString(PyExc_AttributeError, name); |
|
5391 return NULL; |
|
5392 } |
|
5393 |
|
5394 Py_INCREF(self->find_class); |
|
5395 return self->find_class; |
|
5396 } |
|
5397 |
|
5398 if (!strcmp(name, "memo")) { |
|
5399 if (!self->memo) { |
|
5400 PyErr_SetString(PyExc_AttributeError, name); |
|
5401 return NULL; |
|
5402 } |
|
5403 |
|
5404 Py_INCREF(self->memo); |
|
5405 return self->memo; |
|
5406 } |
|
5407 |
|
5408 if (!strcmp(name, "UnpicklingError")) { |
|
5409 Py_INCREF(UnpicklingError); |
|
5410 return UnpicklingError; |
|
5411 } |
|
5412 |
|
5413 return Py_FindMethod(Unpickler_methods, (PyObject *)self, name); |
|
5414 } |
|
5415 |
|
5416 |
|
5417 static int |
|
5418 Unpickler_setattr(Unpicklerobject *self, char *name, PyObject *value) |
|
5419 { |
|
5420 |
|
5421 if (!strcmp(name, "persistent_load")) { |
|
5422 Py_XDECREF(self->pers_func); |
|
5423 self->pers_func = value; |
|
5424 Py_XINCREF(value); |
|
5425 return 0; |
|
5426 } |
|
5427 |
|
5428 if (!strcmp(name, "find_global")) { |
|
5429 Py_XDECREF(self->find_class); |
|
5430 self->find_class = value; |
|
5431 Py_XINCREF(value); |
|
5432 return 0; |
|
5433 } |
|
5434 |
|
5435 if (! value) { |
|
5436 PyErr_SetString(PyExc_TypeError, |
|
5437 "attribute deletion is not supported"); |
|
5438 return -1; |
|
5439 } |
|
5440 |
|
5441 if (strcmp(name, "memo") == 0) { |
|
5442 if (!PyDict_Check(value)) { |
|
5443 PyErr_SetString(PyExc_TypeError, |
|
5444 "memo must be a dictionary"); |
|
5445 return -1; |
|
5446 } |
|
5447 Py_XDECREF(self->memo); |
|
5448 self->memo = value; |
|
5449 Py_INCREF(value); |
|
5450 return 0; |
|
5451 } |
|
5452 |
|
5453 PyErr_SetString(PyExc_AttributeError, name); |
|
5454 return -1; |
|
5455 } |
|
5456 |
|
5457 /* --------------------------------------------------------------------------- |
|
5458 * Module-level functions. |
|
5459 */ |
|
5460 |
|
5461 /* dump(obj, file, protocol=0). */ |
|
5462 static PyObject * |
|
5463 cpm_dump(PyObject *self, PyObject *args, PyObject *kwds) |
|
5464 { |
|
5465 static char *kwlist[] = {"obj", "file", "protocol", NULL}; |
|
5466 PyObject *ob, *file, *res = NULL; |
|
5467 Picklerobject *pickler = 0; |
|
5468 int proto = 0; |
|
5469 |
|
5470 if (!( PyArg_ParseTupleAndKeywords(args, kwds, "OO|i", kwlist, |
|
5471 &ob, &file, &proto))) |
|
5472 goto finally; |
|
5473 |
|
5474 if (!( pickler = newPicklerobject(file, proto))) |
|
5475 goto finally; |
|
5476 |
|
5477 if (dump(pickler, ob) < 0) |
|
5478 goto finally; |
|
5479 |
|
5480 Py_INCREF(Py_None); |
|
5481 res = Py_None; |
|
5482 |
|
5483 finally: |
|
5484 Py_XDECREF(pickler); |
|
5485 |
|
5486 return res; |
|
5487 } |
|
5488 |
|
5489 |
|
5490 /* dumps(obj, protocol=0). */ |
|
5491 static PyObject * |
|
5492 cpm_dumps(PyObject *self, PyObject *args, PyObject *kwds) |
|
5493 { |
|
5494 static char *kwlist[] = {"obj", "protocol", NULL}; |
|
5495 PyObject *ob, *file = 0, *res = NULL; |
|
5496 Picklerobject *pickler = 0; |
|
5497 int proto = 0; |
|
5498 |
|
5499 if (!( PyArg_ParseTupleAndKeywords(args, kwds, "O|i:dumps", kwlist, |
|
5500 &ob, &proto))) |
|
5501 goto finally; |
|
5502 |
|
5503 if (!( file = PycStringIO->NewOutput(128))) |
|
5504 goto finally; |
|
5505 |
|
5506 if (!( pickler = newPicklerobject(file, proto))) |
|
5507 goto finally; |
|
5508 |
|
5509 if (dump(pickler, ob) < 0) |
|
5510 goto finally; |
|
5511 |
|
5512 res = PycStringIO->cgetvalue(file); |
|
5513 |
|
5514 finally: |
|
5515 Py_XDECREF(pickler); |
|
5516 Py_XDECREF(file); |
|
5517 |
|
5518 return res; |
|
5519 } |
|
5520 |
|
5521 |
|
5522 /* load(fileobj). */ |
|
5523 static PyObject * |
|
5524 cpm_load(PyObject *self, PyObject *ob) |
|
5525 { |
|
5526 Unpicklerobject *unpickler = 0; |
|
5527 PyObject *res = NULL; |
|
5528 |
|
5529 if (!( unpickler = newUnpicklerobject(ob))) |
|
5530 goto finally; |
|
5531 |
|
5532 res = load(unpickler); |
|
5533 |
|
5534 finally: |
|
5535 Py_XDECREF(unpickler); |
|
5536 |
|
5537 return res; |
|
5538 } |
|
5539 |
|
5540 |
|
5541 /* loads(string) */ |
|
5542 static PyObject * |
|
5543 cpm_loads(PyObject *self, PyObject *args) |
|
5544 { |
|
5545 PyObject *ob, *file = 0, *res = NULL; |
|
5546 Unpicklerobject *unpickler = 0; |
|
5547 |
|
5548 if (!( PyArg_ParseTuple(args, "S:loads", &ob))) |
|
5549 goto finally; |
|
5550 |
|
5551 if (!( file = PycStringIO->NewInput(ob))) |
|
5552 goto finally; |
|
5553 |
|
5554 if (!( unpickler = newUnpicklerobject(file))) |
|
5555 goto finally; |
|
5556 |
|
5557 res = load(unpickler); |
|
5558 |
|
5559 finally: |
|
5560 Py_XDECREF(file); |
|
5561 Py_XDECREF(unpickler); |
|
5562 |
|
5563 return res; |
|
5564 } |
|
5565 |
|
5566 |
|
5567 PyDoc_STRVAR(Unpicklertype__doc__, |
|
5568 "Objects that know how to unpickle"); |
|
5569 |
|
5570 static PyTypeObject Unpicklertype = { |
|
5571 PyVarObject_HEAD_INIT(NULL, 0) |
|
5572 "cPickle.Unpickler", /*tp_name*/ |
|
5573 sizeof(Unpicklerobject), /*tp_basicsize*/ |
|
5574 0, |
|
5575 (destructor)Unpickler_dealloc, /* tp_dealloc */ |
|
5576 0, /* tp_print */ |
|
5577 (getattrfunc)Unpickler_getattr, /* tp_getattr */ |
|
5578 (setattrfunc)Unpickler_setattr, /* tp_setattr */ |
|
5579 0, /* tp_compare */ |
|
5580 0, /* tp_repr */ |
|
5581 0, /* tp_as_number */ |
|
5582 0, /* tp_as_sequence */ |
|
5583 0, /* tp_as_mapping */ |
|
5584 0, /* tp_hash */ |
|
5585 0, /* tp_call */ |
|
5586 0, /* tp_str */ |
|
5587 0, /* tp_getattro */ |
|
5588 0, /* tp_setattro */ |
|
5589 0, /* tp_as_buffer */ |
|
5590 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, |
|
5591 Unpicklertype__doc__, /* tp_doc */ |
|
5592 (traverseproc)Unpickler_traverse, /* tp_traverse */ |
|
5593 (inquiry)Unpickler_clear, /* tp_clear */ |
|
5594 }; |
|
5595 |
|
5596 static struct PyMethodDef cPickle_methods[] = { |
|
5597 {"dump", (PyCFunction)cpm_dump, METH_VARARGS | METH_KEYWORDS, |
|
5598 PyDoc_STR("dump(obj, file, protocol=0) -- " |
|
5599 "Write an object in pickle format to the given file.\n" |
|
5600 "\n" |
|
5601 "See the Pickler docstring for the meaning of optional argument proto.") |
|
5602 }, |
|
5603 |
|
5604 {"dumps", (PyCFunction)cpm_dumps, METH_VARARGS | METH_KEYWORDS, |
|
5605 PyDoc_STR("dumps(obj, protocol=0) -- " |
|
5606 "Return a string containing an object in pickle format.\n" |
|
5607 "\n" |
|
5608 "See the Pickler docstring for the meaning of optional argument proto.") |
|
5609 }, |
|
5610 |
|
5611 {"load", (PyCFunction)cpm_load, METH_O, |
|
5612 PyDoc_STR("load(file) -- Load a pickle from the given file")}, |
|
5613 |
|
5614 {"loads", (PyCFunction)cpm_loads, METH_VARARGS, |
|
5615 PyDoc_STR("loads(string) -- Load a pickle from the given string")}, |
|
5616 |
|
5617 {"Pickler", (PyCFunction)get_Pickler, METH_VARARGS | METH_KEYWORDS, |
|
5618 PyDoc_STR("Pickler(file, protocol=0) -- Create a pickler.\n" |
|
5619 "\n" |
|
5620 "This takes a file-like object for writing a pickle data stream.\n" |
|
5621 "The optional proto argument tells the pickler to use the given\n" |
|
5622 "protocol; supported protocols are 0, 1, 2. The default\n" |
|
5623 "protocol is 0, to be backwards compatible. (Protocol 0 is the\n" |
|
5624 "only protocol that can be written to a file opened in text\n" |
|
5625 "mode and read back successfully. When using a protocol higher\n" |
|
5626 "than 0, make sure the file is opened in binary mode, both when\n" |
|
5627 "pickling and unpickling.)\n" |
|
5628 "\n" |
|
5629 "Protocol 1 is more efficient than protocol 0; protocol 2 is\n" |
|
5630 "more efficient than protocol 1.\n" |
|
5631 "\n" |
|
5632 "Specifying a negative protocol version selects the highest\n" |
|
5633 "protocol version supported. The higher the protocol used, the\n" |
|
5634 "more recent the version of Python needed to read the pickle\n" |
|
5635 "produced.\n" |
|
5636 "\n" |
|
5637 "The file parameter must have a write() method that accepts a single\n" |
|
5638 "string argument. It can thus be an open file object, a StringIO\n" |
|
5639 "object, or any other custom object that meets this interface.\n") |
|
5640 }, |
|
5641 |
|
5642 {"Unpickler", (PyCFunction)get_Unpickler, METH_O, |
|
5643 PyDoc_STR("Unpickler(file) -- Create an unpickler.")}, |
|
5644 |
|
5645 { NULL, NULL } |
|
5646 }; |
|
5647 |
|
5648 static int |
|
5649 init_stuff(PyObject *module_dict) |
|
5650 { |
|
5651 PyObject *copyreg, *t, *r; |
|
5652 |
|
5653 #define INIT_STR(S) if (!( S ## _str=PyString_InternFromString(#S))) return -1; |
|
5654 |
|
5655 if (PyType_Ready(&Unpicklertype) < 0) |
|
5656 return -1; |
|
5657 if (PyType_Ready(&Picklertype) < 0) |
|
5658 return -1; |
|
5659 |
|
5660 INIT_STR(__class__); |
|
5661 INIT_STR(__getinitargs__); |
|
5662 INIT_STR(__dict__); |
|
5663 INIT_STR(__getstate__); |
|
5664 INIT_STR(__setstate__); |
|
5665 INIT_STR(__name__); |
|
5666 INIT_STR(__main__); |
|
5667 INIT_STR(__reduce__); |
|
5668 INIT_STR(__reduce_ex__); |
|
5669 INIT_STR(write); |
|
5670 INIT_STR(append); |
|
5671 INIT_STR(read); |
|
5672 INIT_STR(readline); |
|
5673 INIT_STR(copyreg); |
|
5674 INIT_STR(dispatch_table); |
|
5675 |
|
5676 if (!( copyreg = PyImport_ImportModule("copy_reg"))) |
|
5677 return -1; |
|
5678 |
|
5679 /* This is special because we want to use a different |
|
5680 one in restricted mode. */ |
|
5681 dispatch_table = PyObject_GetAttr(copyreg, dispatch_table_str); |
|
5682 if (!dispatch_table) return -1; |
|
5683 |
|
5684 extension_registry = PyObject_GetAttrString(copyreg, |
|
5685 "_extension_registry"); |
|
5686 if (!extension_registry) return -1; |
|
5687 |
|
5688 inverted_registry = PyObject_GetAttrString(copyreg, |
|
5689 "_inverted_registry"); |
|
5690 if (!inverted_registry) return -1; |
|
5691 |
|
5692 extension_cache = PyObject_GetAttrString(copyreg, |
|
5693 "_extension_cache"); |
|
5694 if (!extension_cache) return -1; |
|
5695 |
|
5696 Py_DECREF(copyreg); |
|
5697 |
|
5698 if (!(empty_tuple = PyTuple_New(0))) |
|
5699 return -1; |
|
5700 |
|
5701 two_tuple = PyTuple_New(2); |
|
5702 if (two_tuple == NULL) |
|
5703 return -1; |
|
5704 /* We use this temp container with no regard to refcounts, or to |
|
5705 * keeping containees alive. Exempt from GC, because we don't |
|
5706 * want anything looking at two_tuple() by magic. |
|
5707 */ |
|
5708 PyObject_GC_UnTrack(two_tuple); |
|
5709 |
|
5710 /* Ugh */ |
|
5711 if (!( t=PyImport_ImportModule("__builtin__"))) return -1; |
|
5712 if (PyDict_SetItemString(module_dict, "__builtins__", t) < 0) |
|
5713 return -1; |
|
5714 |
|
5715 if (!( t=PyDict_New())) return -1; |
|
5716 if (!( r=PyRun_String( |
|
5717 "def __str__(self):\n" |
|
5718 " return self.args and ('%s' % self.args[0]) or '(what)'\n", |
|
5719 Py_file_input, |
|
5720 module_dict, t) )) return -1; |
|
5721 Py_DECREF(r); |
|
5722 |
|
5723 PickleError = PyErr_NewException("cPickle.PickleError", NULL, t); |
|
5724 if (!PickleError) |
|
5725 return -1; |
|
5726 |
|
5727 Py_DECREF(t); |
|
5728 |
|
5729 PicklingError = PyErr_NewException("cPickle.PicklingError", |
|
5730 PickleError, NULL); |
|
5731 if (!PicklingError) |
|
5732 return -1; |
|
5733 |
|
5734 if (!( t=PyDict_New())) return -1; |
|
5735 if (!( r=PyRun_String( |
|
5736 "def __str__(self):\n" |
|
5737 " a=self.args\n" |
|
5738 " a=a and type(a[0]) or '(what)'\n" |
|
5739 " return 'Cannot pickle %s objects' % a\n" |
|
5740 , Py_file_input, |
|
5741 module_dict, t) )) return -1; |
|
5742 Py_DECREF(r); |
|
5743 |
|
5744 if (!( UnpickleableError = PyErr_NewException( |
|
5745 "cPickle.UnpickleableError", PicklingError, t))) |
|
5746 return -1; |
|
5747 |
|
5748 Py_DECREF(t); |
|
5749 |
|
5750 if (!( UnpicklingError = PyErr_NewException("cPickle.UnpicklingError", |
|
5751 PickleError, NULL))) |
|
5752 return -1; |
|
5753 |
|
5754 if (!( BadPickleGet = PyErr_NewException("cPickle.BadPickleGet", |
|
5755 UnpicklingError, NULL))) |
|
5756 return -1; |
|
5757 |
|
5758 if (PyDict_SetItemString(module_dict, "PickleError", |
|
5759 PickleError) < 0) |
|
5760 return -1; |
|
5761 |
|
5762 if (PyDict_SetItemString(module_dict, "PicklingError", |
|
5763 PicklingError) < 0) |
|
5764 return -1; |
|
5765 |
|
5766 if (PyDict_SetItemString(module_dict, "UnpicklingError", |
|
5767 UnpicklingError) < 0) |
|
5768 return -1; |
|
5769 |
|
5770 if (PyDict_SetItemString(module_dict, "UnpickleableError", |
|
5771 UnpickleableError) < 0) |
|
5772 return -1; |
|
5773 |
|
5774 if (PyDict_SetItemString(module_dict, "BadPickleGet", |
|
5775 BadPickleGet) < 0) |
|
5776 return -1; |
|
5777 |
|
5778 PycString_IMPORT; |
|
5779 |
|
5780 return 0; |
|
5781 } |
|
5782 |
|
5783 #ifndef PyMODINIT_FUNC /* declarations for DLL import/export */ |
|
5784 #define PyMODINIT_FUNC void |
|
5785 #endif |
|
5786 PyMODINIT_FUNC |
|
5787 initcPickle(void) |
|
5788 { |
|
5789 PyObject *m, *d, *di, *v, *k; |
|
5790 Py_ssize_t i; |
|
5791 char *rev = "1.71"; /* XXX when does this change? */ |
|
5792 PyObject *format_version; |
|
5793 PyObject *compatible_formats; |
|
5794 |
|
5795 /* XXX: Should mention that the pickle module will include the C |
|
5796 XXX: optimized implementation automatically. */ |
|
5797 if (PyErr_WarnPy3k("the cPickle module has been removed in " |
|
5798 "Python 3.0", 2) < 0) |
|
5799 return; |
|
5800 |
|
5801 Py_TYPE(&Picklertype) = &PyType_Type; |
|
5802 Py_TYPE(&Unpicklertype) = &PyType_Type; |
|
5803 Py_TYPE(&PdataType) = &PyType_Type; |
|
5804 |
|
5805 /* Initialize some pieces. We need to do this before module creation, |
|
5806 * so we're forced to use a temporary dictionary. :( |
|
5807 */ |
|
5808 di = PyDict_New(); |
|
5809 if (!di) return; |
|
5810 if (init_stuff(di) < 0) return; |
|
5811 |
|
5812 /* Create the module and add the functions */ |
|
5813 m = Py_InitModule4("cPickle", cPickle_methods, |
|
5814 cPickle_module_documentation, |
|
5815 (PyObject*)NULL,PYTHON_API_VERSION); |
|
5816 if (m == NULL) |
|
5817 return; |
|
5818 |
|
5819 /* Add some symbolic constants to the module */ |
|
5820 d = PyModule_GetDict(m); |
|
5821 v = PyString_FromString(rev); |
|
5822 PyDict_SetItemString(d, "__version__", v); |
|
5823 Py_XDECREF(v); |
|
5824 |
|
5825 /* Copy data from di. Waaa. */ |
|
5826 for (i=0; PyDict_Next(di, &i, &k, &v); ) { |
|
5827 if (PyObject_SetItem(d, k, v) < 0) { |
|
5828 Py_DECREF(di); |
|
5829 return; |
|
5830 } |
|
5831 } |
|
5832 Py_DECREF(di); |
|
5833 |
|
5834 i = PyModule_AddIntConstant(m, "HIGHEST_PROTOCOL", HIGHEST_PROTOCOL); |
|
5835 if (i < 0) |
|
5836 return; |
|
5837 |
|
5838 /* These are purely informational; no code uses them. */ |
|
5839 /* File format version we write. */ |
|
5840 format_version = PyString_FromString("2.0"); |
|
5841 /* Format versions we can read. */ |
|
5842 compatible_formats = Py_BuildValue("[sssss]", |
|
5843 "1.0", /* Original protocol 0 */ |
|
5844 "1.1", /* Protocol 0 + INST */ |
|
5845 "1.2", /* Original protocol 1 */ |
|
5846 "1.3", /* Protocol 1 + BINFLOAT */ |
|
5847 "2.0"); /* Original protocol 2 */ |
|
5848 PyDict_SetItemString(d, "format_version", format_version); |
|
5849 PyDict_SetItemString(d, "compatible_formats", compatible_formats); |
|
5850 Py_XDECREF(format_version); |
|
5851 Py_XDECREF(compatible_formats); |
|
5852 } |