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