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