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