source: trunk/essentials/dev-lang/python/Modules/cPickle.c@ 3310

Last change on this file since 3310 was 3225, checked in by bird, 19 years ago

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