source: python/trunk/Modules/cPickle.c@ 389

Last change on this file since 389 was 2, checked in by Yuri Dario, 15 years ago

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