Python-2.7.3/Modules/cPickle.c

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();
Potential leak of memory pointed to by field 'buf'
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

Potential leak of memory pointed to by field 'buf'
(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,
Potential leak of memory pointed to by 'have_get'
(emitted by clang-analyzer)

TODO: a detailed trace is available in the data model (not yet rendered in this report)

Potential leak of memory pointed to by 'have_get'
(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;
Memory leak: have_get
(emitted by cppcheck)
Memory leak: have_get
(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)