Modules/cPickle.c

   1 /*
   2  * cPickle.c,v 1.63 1999/02/05 01:40:06 jim Exp
   3  *
   4  * Copyright (c) 1996-1998, Digital Creations, Fredericksburg, VA, USA.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions are
   9  * met:
  10  *
  11  *   o Redistributions of source code must retain the above copyright
  12  *     notice, this list of conditions, and the disclaimer that follows.
  13  *
  14  *   o Redistributions in binary form must reproduce the above copyright
  15  *     notice, this list of conditions, and the following disclaimer in
  16  *     the documentation and/or other materials provided with the
  17  *     distribution.
  18  *
  19  *   o Neither the name of Digital Creations nor the names of its
  20  *     contributors may be used to endorse or promote products derived
  21  *     from this software without specific prior written permission.
  22  *
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY DIGITAL CREATIONS AND CONTRIBUTORS *AS
  25  * IS* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  26  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  27  * PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL DIGITAL
  28  * CREATIONS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  29  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  30  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  31  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  32  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  33  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  34  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  35  * DAMAGE.
  36  *
  37  #
  38  # If you have questions regarding this software, contact:
  39  #
  40  #   Digital Creations, L.C.
  41  #   910 Princess Ann Street
  42  #   Fredericksburge, Virginia  22401
  43  #
  44  #   info@digicool.com
  45  #
  46  #   (540) 371-6909
  47  */
  48
  49 static char cPickle_module_documentation[] =
  50 "C implementation and optimization of the Python pickle module\n"
  51 "\n"
  52 "cPickle.c,v 1.63 1999/02/05 01:40:06 jim Exp\n"
  53 ;
  54
  55 #include "Python.h"
  56 #include "cStringIO.h"
  57 #include "mymath.h"
  58
  59 #ifndef Py_eval_input
  60 #include <graminit.h>
  61 #define Py_eval_input eval_input
  62 #endif /* Py_eval_input */
  63
  64 #include <errno.h>
  65
  66 #define UNLESS(E) if (!(E))
  67
  68 #define DEL_LIST_SLICE(list, from, to) (PyList_SetSlice(list, from, to, NULL))
  69
  70 #define WRITE_BUF_SIZE 256
  71
  72
  73 #define MARK        '('
  74 #define STOP        '.'
  75 #define POP         '0'
  76 #define POP_MARK    '1'
  77 #define DUP         '2'
  78 #define FLOAT       'F'
  79 #define BINFLOAT    'G'
  80 #define INT         'I'
  81 #define BININT      'J'
  82 #define BININT1     'K'
  83 #define LONG        'L'
  84 #define BININT2     'M'
  85 #define NONE        'N'
  86 #define PERSID      'P'
  87 #define BINPERSID   'Q'
  88 #define REDUCE      'R'
  89 #define STRING      'S'
  90 #define BINSTRING   'T'
  91 #define SHORT_BINSTRING 'U'
  92 #define APPEND      'a'
  93 #define BUILD       'b'
  94 #define GLOBAL      'c'
  95 #define DICT        'd'
  96 #define EMPTY_DICT  '}'
  97 #define APPENDS     'e'
  98 #define GET         'g'
  99 #define BINGET      'h'
 100 #define INST        'i'
 101 #define LONG_BINGET 'j'
 102 #define LIST        'l'
 103 #define EMPTY_LIST  ']'
 104 #define OBJ         'o'
 105 #define PUT         'p'
 106 #define BINPUT      'q'
 107 #define LONG_BINPUT 'r'
 108 #define SETITEM     's'
 109 #define TUPLE       't'
 110 #define EMPTY_TUPLE ')'
 111 #define SETITEMS    'u'
 112
 113 static char MARKv = MARK;
 114
 115 /* atol function from string module */
 116 static PyObject *atol_func;
 117
 118 static PyObject *PicklingError;
 119 static PyObject *UnpicklingError;
 120 static PyObject *BadPickleGet;
 121
 122
 123 static PyObject *dispatch_table;
 124 static PyObject *safe_constructors;
 125 static PyObject *empty_tuple;
 126
 127 static PyObject *__class___str, *__getinitargs___str, *__dict___str,
 128   *__getstate___str, *__setstate___str, *__name___str, *__reduce___str,
 129   *write_str, *__safe_for_unpickling___str, *append_str,
 130   *read_str, *readline_str, *__main___str, *__basicnew___str,
 131   *copy_reg_str, *dispatch_table_str, *safe_constructors_str, *empty_str;
 132
 133 static int save();
 134 static int put2();
 135
 136 #ifndef PyList_SET_ITEM
 137 #define PyList_SET_ITEM(op, i, v) (((PyListObject *)(op))->ob_item[i] = (v))
 138 #endif
 139 #ifndef PyList_GET_SIZE
 140 #define PyList_GET_SIZE(op)    (((PyListObject *)(op))->ob_size)
 141 #endif
 142 #ifndef PyTuple_SET_ITEM
 143 #define PyTuple_SET_ITEM(op, i, v) (((PyTupleObject *)(op))->ob_item[i] = (v))
 144 #endif
 145 #ifndef PyTuple_GET_SIZE
 146 #define PyTuple_GET_SIZE(op)    (((PyTupleObject *)(op))->ob_size)
 147 #endif
 148 #ifndef PyString_GET_SIZE
 149 #define PyString_GET_SIZE(op)    (((PyStringObject *)(op))->ob_size)
 150 #endif
 151
 152 /*************************************************************************
 153  Internal Data type for pickle data.                                     */
 154
 155 typedef struct {
 156      PyObject_HEAD
 157      int length, size;
 158      PyObject **data;
 159 } Pdata;
 160
 161 static void
 162 Pdata_dealloc(Pdata *self) {
 163     int i;
 164     PyObject **p;
 165
 166     for (i=self->length, p=self->data; --i >= 0; p++) Py_DECREF(*p);
 167
 168     if (self->data) free(self->data);
 169
 170     PyMem_DEL(self);
 171 }
 172
 173 static PyTypeObject PdataType = {
 174     PyObject_HEAD_INIT(NULL) 0, "Pdata", sizeof(Pdata), 0,
 175     (destructor)Pdata_dealloc,
 176     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0L,0L,0L,0L, ""
 177 };
 178
 179 #define Pdata_Check(O) ((O)->ob_type == &PdataType)
 180
 181 static PyObject *
 182 Pdata_New() {
 183     Pdata *self;
 184
 185     UNLESS (self = PyObject_NEW(Pdata, &PdataType)) return NULL;
 186     self->size=8;
 187     self->length=0;
 188     self->data=malloc(self->size * sizeof(PyObject*));
 189     if (self->data) return (PyObject*)self;
 190     Py_DECREF(self);
 191     return PyErr_NoMemory();
 192 }
 193
 194 static int
 195 stackUnderflow() {
 196     PyErr_SetString(UnpicklingError, "unpickling stack underflow");
 197     return -1;
 198 }
 199
 200 static int
 201 Pdata_clear(Pdata *self, int clearto) {
 202     int i;
 203     PyObject **p;
 204
 205     if (clearto < 0) return stackUnderflow();
 206     if (clearto >= self->length) return 0;
 207
 208     for (i=self->length, p=self->data+clearto; --i >= clearto; p++)
 209       Py_DECREF(*p);
 210     self->length=clearto;
 211
 212     return 0;
 213 }
 214
 215
 216 static int
 217 Pdata_grow(Pdata *self) {
 218   if (! self->size) {
 219       PyErr_NoMemory();
 220       return -1;
 221   }
 222   self->size *= 2;
 223   self->data = realloc(self->data, self->size*sizeof(PyObject*));
 224   if (! self->data) {
 225     self->size = 0;
 226     PyErr_NoMemory();
 227     return -1;
 228   }
 229   return 0;
 230 }
 231
 232 #define PDATA_POP(D,V) {                                      \
 233     if ((D)->length) V=D->data[--((D)->length)];              \
 234     else {                                                    \
 235         PyErr_SetString(UnpicklingError, "bad pickle data");  \
 236         V=NULL;                                               \
 237     }                                                         \
 238 }
 239
 240
 241 static PyObject *
 242 Pdata_popTuple(Pdata *self, int start) {
 243     PyObject *r;
 244     int i, j, l;
 245
 246     l=self->length-start;
 247     UNLESS (r=PyTuple_New(l)) return NULL;
 248     for (i=start, j=0 ; j < l; )
 249         PyTuple_SET_ITEM(r,j++,self->data[i++]);
 250
 251     self->length=start;
 252     return r;
 253 }
 254
 255 static PyObject *
 256 Pdata_popList(Pdata *self, int start) {
 257     PyObject *r;
 258     int i, j, l;
 259
 260     l=self->length-start;
 261     UNLESS (r=PyList_New(l)) return NULL;
 262     for (i=start, j=0 ; j < l; )
 263         PyList_SET_ITEM(r,j++,self->data[i++]);
 264
 265     self->length=start;
 266     return r;
 267 }
 268
 269 #define PDATA_APPEND_(D,O,ER) { \
 270   if (Pdata_Append(((Pdata*)(D)), O) < 0) return ER; \
 271 }
 272
 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 #define PDATA_PUSH(D,O,ER) {                                   \
 282     if (((Pdata*)(D))->length == ((Pdata*)(D))->size &&        \
 283         Pdata_grow((Pdata*)(D)) < 0) {                         \
 284         Py_DECREF(O);                                          \
 285         return ER;                                             \
 286     }                                                          \
 287     ((Pdata*)(D))->data[((Pdata*)(D))->length++]=O;            \
 288 }
 289
 290 /*************************************************************************/
 291
 292 #define ARG_TUP(self, o) {                          \
 293   if (self->arg || (self->arg=PyTuple_New(1))) {    \
 294       Py_XDECREF(PyTuple_GET_ITEM(self->arg,0));    \
 295       PyTuple_SET_ITEM(self->arg,0,o);              \
 296   }                                                 \
 297   else {                                            \
 298       Py_DECREF(o);                                 \
 299   }                                                 \
 300 }
 301
 302 #define FREE_ARG_TUP(self) {                        \
 303     if (self->arg->ob_refcnt > 1) {                 \
 304       Py_DECREF(self->arg);                         \
 305       self->arg=NULL;                               \
 306     }                                               \
 307   }
 308
 309 typedef struct {
 310      PyObject_HEAD
 311      FILE *fp;
 312      PyObject *write;
 313      PyObject *file;
 314      PyObject *memo;
 315      PyObject *arg;
 316      PyObject *pers_func;
 317      PyObject *inst_pers_func;
 318      int bin;
 319      int fast; /* Fast mode doesn't save in memo, don't use if circ ref */
 320      int (*write_func)();
 321      char *write_buf;
 322      int buf_size;
 323      PyObject *dispatch_table;
 324 } Picklerobject;
 325
 326 staticforward PyTypeObject Picklertype;
 327
 328 typedef struct {
 329      PyObject_HEAD
 330      FILE *fp;
 331      PyObject *file;
 332      PyObject *readline;
 333      PyObject *read;
 334      PyObject *memo;
 335      PyObject *arg;
 336      Pdata *stack;
 337      PyObject *mark;
 338      PyObject *pers_func;
 339      PyObject *last_string;
 340      int *marks;
 341      int num_marks;
 342      int marks_size;
 343      int (*read_func)();
 344      int (*readline_func)();
 345      int buf_size;
 346      char *buf;
 347      PyObject *safe_constructors;
 348 } Unpicklerobject;
 349
 350 staticforward PyTypeObject Unpicklertype;
 351
 352 int
 353 cPickle_PyMapping_HasKey(PyObject *o, PyObject *key) {
 354     PyObject *v;
 355
 356     if ((v = PyObject_GetItem(o,key))) {
 357         Py_DECREF(v);
 358         return 1;
 359     }
 360
 361     PyErr_Clear();
 362     return 0;
 363 }
 364
 365 static
 366 PyObject *
 367 #ifdef HAVE_STDARG_PROTOTYPES
 368 /* VARARGS 2 */
 369 cPickle_ErrFormat(PyObject *ErrType, char *stringformat, char *format, ...) {
 370 #else
 371 /* VARARGS */
 372 cPickle_ErrFormat(va_alist) va_dcl {
 373 #endif
 374   va_list va;
 375   PyObject *args=0, *retval=0;
 376 #ifdef HAVE_STDARG_PROTOTYPES
 377   va_start(va, format);
 378 #else
 379   PyObject *ErrType;
 380   char *stringformat, *format;
 381   va_start(va);
 382   ErrType = va_arg(va, PyObject *);
 383   stringformat   = va_arg(va, char *);
 384   format   = va_arg(va, char *);
 385 #endif
 386
 387   if (format) args = Py_VaBuildValue(format, va);
 388   va_end(va);
 389   if (format && ! args) return NULL;
 390   if (stringformat && !(retval=PyString_FromString(stringformat))) return NULL;
 391
 392   if (retval) {
 393       if (args) {
 394           PyObject *v;
 395           v=PyString_Format(retval, args);
 396           Py_DECREF(retval);
 397           Py_DECREF(args);
 398           if (! v) return NULL;
 399           retval=v;
 400         }
 401     }
 402   else
 403     if (args) retval=args;
 404     else {
 405         PyErr_SetObject(ErrType,Py_None);
 406         return NULL;
 407       }
 408   PyErr_SetObject(ErrType,retval);
 409   Py_DECREF(retval);
 410   return NULL;
 411 }
 412
 413 static int
 414 write_file(Picklerobject *self, char *s, int  n) {
 415     if (s == NULL) {
 416         return 0;
 417     }
 418
 419     if ((int)fwrite(s, sizeof(char), n, self->fp) != n) {
 420         PyErr_SetFromErrno(PyExc_IOError);
 421         return -1;
 422     }
 423
 424     return n;
 425 }
 426
 427 static int
 428 write_cStringIO(Picklerobject *self, char *s, int  n) {
 429     if (s == NULL) {
 430         return 0;
 431     }
 432
 433     if (PycStringIO->cwrite((PyObject *)self->file, s, n) != n) {
 434         return -1;
 435     }
 436
 437     return n;
 438 }
 439
 440 static int
 441 write_none(Picklerobject *self, char *s, int  n) {
 442     if (s == NULL) return 0;
 443     return n;
 444 }
 445
 446 static int
 447 write_other(Picklerobject *self, char *s, int  n) {
 448     PyObject *py_str = 0, *junk = 0;
 449
 450     if (s == NULL) {
 451         UNLESS (self->buf_size) return 0;
 452         UNLESS (py_str =
 453             PyString_FromStringAndSize(self->write_buf, self->buf_size))
 454             return -1;
 455     }
 456     else {
 457         if (self->buf_size && (n + self->buf_size) > WRITE_BUF_SIZE) {
 458             if (write_other(self, NULL, 0) < 0)
 459                 return -1;
 460         }
 461
 462         if (n > WRITE_BUF_SIZE) {
 463             UNLESS (py_str =
 464                 PyString_FromStringAndSize(s, n))
 465                 return -1;
 466         }
 467         else {
 468             memcpy(self->write_buf + self->buf_size, s, n);
 469             self->buf_size += n;
 470             return n;
 471         }
 472     }
 473
 474     if (self->write) {
 475         /* object with write method */
 476         ARG_TUP(self, py_str);
 477         if (self->arg) {
 478             junk = PyObject_CallObject(self->write, self->arg);
 479             FREE_ARG_TUP(self);
 480         }
 481         if (junk) Py_DECREF(junk);
 482         else return -1;
 483       }
 484     else
 485       PDATA_PUSH(self->file, py_str, -1);
 486
 487     self->buf_size = 0;
 488     return n;
 489 }
 490
 491
 492 static int
 493 read_file(Unpicklerobject *self, char **s, int  n) {
 494
 495     if (self->buf_size == 0) {
 496         int size;
 497
 498         size = ((n < 32) ? 32 : n);
 499         UNLESS (self->buf = (char *)malloc(size * sizeof(char))) {
 500             PyErr_NoMemory();
 501             return -1;
 502         }
 503
 504         self->buf_size = size;
 505     }
 506     else if (n > self->buf_size) {
 507         UNLESS (self->buf = (char *)realloc(self->buf, n * sizeof(char))) {
 508             PyErr_NoMemory();
 509             return -1;
 510         }
 511
 512         self->buf_size = n;
 513     }
 514
 515     if ((int)fread(self->buf, sizeof(char), n, self->fp) != n) {
 516         if (feof(self->fp)) {
 517             PyErr_SetNone(PyExc_EOFError);
 518             return -1;
 519         }
 520
 521         PyErr_SetFromErrno(PyExc_IOError);
 522         return -1;
 523     }
 524
 525     *s = self->buf;
 526
 527     return n;
 528 }
 529
 530
 531 static int
 532 readline_file(Unpicklerobject *self, char **s) {
 533     int i;
 534
 535     if (self->buf_size == 0) {
 536         UNLESS (self->buf = (char *)malloc(40 * sizeof(char))) {
 537             PyErr_NoMemory();
 538             return -1;
 539         }
 540
 541         self->buf_size = 40;
 542     }
 543
 544     i = 0;
 545     while (1) {
 546         for (; i < (self->buf_size - 1); i++) {
 547             if (feof(self->fp) || (self->buf[i] = getc(self->fp)) == '\n') {
 548                 self->buf[i + 1] = '\0';
 549                 *s = self->buf;
 550                 return i + 1;
 551             }
 552         }
 553
 554         UNLESS (self->buf = (char *)realloc(self->buf,
 555             (self->buf_size * 2) * sizeof(char))) {
 556             PyErr_NoMemory();
 557             return -1;
 558         }
 559
 560         self->buf_size *= 2;
 561     }
 562
 563 }
 564
 565
 566 static int
 567 read_cStringIO(Unpicklerobject *self, char **s, int  n) {
 568     char *ptr;
 569
 570     if (PycStringIO->cread((PyObject *)self->file, &ptr, n) != n) {
 571         PyErr_SetNone(PyExc_EOFError);
 572         return -1;
 573     }
 574
 575     *s = ptr;
 576
 577     return n;
 578 }
 579
 580
 581 static int
 582 readline_cStringIO(Unpicklerobject *self, char **s) {
 583     int n;
 584     char *ptr;
 585
 586     if ((n = PycStringIO->creadline((PyObject *)self->file, &ptr)) < 0) {
 587         return -1;
 588     }
 589
 590     *s = ptr;
 591
 592     return n;
 593 }
 594
 595
 596 static int
 597 read_other(Unpicklerobject *self, char **s, int  n) {
 598     PyObject *bytes, *str=0;
 599     int res = -1;
 600
 601     UNLESS (bytes = PyInt_FromLong(n)) return -1;
 602
 603     ARG_TUP(self, bytes);
 604     if (self->arg) {
 605         str = PyObject_CallObject(self->read, self->arg);
 606         FREE_ARG_TUP(self);
 607     }
 608     if (! str) return -1;
 609
 610     Py_XDECREF(self->last_string);
 611     self->last_string = str;
 612
 613     if (! (*s = PyString_AsString(str))) return -1;
 614     return n;
 615 }
 616
 617
 618 static int
 619 readline_other(Unpicklerobject *self, char **s) {
 620     PyObject *str;
 621     int str_size;
 622
 623     UNLESS (str = PyObject_CallObject(self->readline, empty_tuple)) {
 624         return -1;
 625     }
 626
 627     if ((str_size = PyString_Size(str)) < 0)
 628       return -1;
 629
 630     Py_XDECREF(self->last_string);
 631     self->last_string = str;
 632
 633     if (! (*s = PyString_AsString(str)))
 634       return -1;
 635
 636     return str_size;
 637 }
 638
 639
 640 static char *
 641 pystrndup(char *s, int l) {
 642   char *r;
 643   UNLESS (r=malloc((l+1)*sizeof(char))) return (char*)PyErr_NoMemory();
 644   memcpy(r,s,l);
 645   r[l]=0;
 646   return r;
 647 }
 648
 649
 650 static int
 651 get(Picklerobject *self, PyObject *id) {
 652     PyObject *value, *mv;
 653     long c_value;
 654     char s[30];
 655     int len;
 656
 657     UNLESS (mv = PyDict_GetItem(self->memo, id)) {
 658         PyErr_SetObject(PyExc_KeyError, id);
 659         return -1;
 660       }
 661
 662     UNLESS (value = PyTuple_GetItem(mv, 0))
 663         return -1;
 664
 665     UNLESS (PyInt_Check(value)) {
 666       PyErr_SetString(PicklingError, "no int where int expected in memo");
 667       return -1;
 668     }
 669     c_value = PyInt_AS_LONG((PyIntObject*)value);
 670
 671     if (!self->bin) {
 672         s[0] = GET;
 673         sprintf(s + 1, "%ld\n", c_value);
 674         len = strlen(s);
 675     }
 676     else if (Pdata_Check(self->file)) {
 677         if (write_other(self, NULL, 0) < 0) return -1;
 678         PDATA_APPEND(self->file, mv, -1);
 679         return 0;
 680       }
 681     else {
 682         if (c_value < 256) {
 683             s[0] = BINGET;
 684             s[1] = (int)(c_value & 0xff);
 685             len = 2;
 686         }
 687         else {
 688             s[0] = LONG_BINGET;
 689             s[1] = (int)(c_value & 0xff);
 690             s[2] = (int)((c_value >> 8)  & 0xff);
 691             s[3] = (int)((c_value >> 16) & 0xff);
 692             s[4] = (int)((c_value >> 24) & 0xff);
 693             len = 5;
 694         }
 695     }
 696
 697     if ((*self->write_func)(self, s, len) < 0)
 698         return -1;
 699
 700     return 0;
 701 }
 702
 703
 704 static int
 705 put(Picklerobject *self, PyObject *ob) {
 706     if (ob->ob_refcnt < 2 || self->fast)
 707         return 0;
 708
 709     return put2(self, ob);
 710 }
 711
 712
 713 static int
 714 put2(Picklerobject *self, PyObject *ob) {
 715     char c_str[30];
 716     int p, len, res = -1;
 717     PyObject *py_ob_id = 0, *memo_len = 0, *t = 0;
 718
 719     if (self->fast) return 0;
 720
 721     if ((p = PyDict_Size(self->memo)) < 0)
 722         goto finally;
 723
 724     p++;  /* Make sure memo keys are positive! */
 725
 726     UNLESS (py_ob_id = PyInt_FromLong((long)ob))
 727         goto finally;
 728
 729     UNLESS (memo_len = PyInt_FromLong(p))
 730         goto finally;
 731
 732     UNLESS (t = PyTuple_New(2))
 733         goto finally;
 734
 735     PyTuple_SET_ITEM(t, 0, memo_len);
 736     Py_INCREF(memo_len);
 737     PyTuple_SET_ITEM(t, 1, ob);
 738     Py_INCREF(ob);
 739
 740     if (PyDict_SetItem(self->memo, py_ob_id, t) < 0)
 741         goto finally;
 742
 743     if (!self->bin) {
 744         c_str[0] = PUT;
 745         sprintf(c_str + 1, "%d\n", p);
 746         len = strlen(c_str);
 747     }
 748     else if (Pdata_Check(self->file)) {
 749         if (write_other(self, NULL, 0) < 0) return -1;
 750         PDATA_APPEND(self->file, memo_len, -1);
 751         res=0;          /* Job well done ;) */
 752         goto finally;
 753     }
 754     else {
 755         if (p >= 256) {
 756             c_str[0] = LONG_BINPUT;
 757             c_str[1] = (int)(p & 0xff);
 758             c_str[2] = (int)((p >> 8)  & 0xff);
 759             c_str[3] = (int)((p >> 16) & 0xff);
 760             c_str[4] = (int)((p >> 24) & 0xff);
 761             len = 5;
 762         }
 763         else {
 764             c_str[0] = BINPUT;
 765             c_str[1] = p;
 766             len = 2;
 767         }
 768     }
 769
 770     if ((*self->write_func)(self, c_str, len) < 0)
 771         goto finally;
 772
 773     res = 0;
 774
 775 finally:
 776     Py_XDECREF(py_ob_id);
 777     Py_XDECREF(memo_len);
 778     Py_XDECREF(t);
 779
 780     return res;
 781 }
 782
 783 #define PyImport_Import cPickle_Import
 784
 785 static PyObject *
 786 PyImport_Import(PyObject *module_name) {
 787   static PyObject *silly_list=0, *__builtins___str=0, *__import___str;
 788   static PyObject *standard_builtins=0;
 789   PyObject *globals=0, *__import__=0, *__builtins__=0, *r=0;
 790
 791   UNLESS (silly_list) {
 792       UNLESS (__import___str=PyString_FromString("__import__"))
 793         return NULL;
 794       UNLESS (__builtins___str=PyString_FromString("__builtins__"))
 795         return NULL;
 796       UNLESS (silly_list=Py_BuildValue("[s]","__doc__"))
 797         return NULL;
 798     }
 799
 800   if ((globals=PyEval_GetGlobals())) {
 801       Py_INCREF(globals);
 802       UNLESS (__builtins__=PyObject_GetItem(globals,__builtins___str))
 803         goto err;
 804     }
 805   else {
 806       PyErr_Clear();
 807
 808       UNLESS (standard_builtins ||
 809              (standard_builtins=PyImport_ImportModule("__builtin__")))
 810         return NULL;
 811
 812       __builtins__=standard_builtins;
 813       Py_INCREF(__builtins__);
 814       UNLESS (globals = Py_BuildValue("{sO}", "__builtins__", __builtins__))
 815         goto err;
 816     }
 817
 818   if (PyDict_Check(__builtins__)) {
 819     UNLESS (__import__=PyObject_GetItem(__builtins__,__import___str)) goto err;
 820   }
 821   else {
 822     UNLESS (__import__=PyObject_GetAttr(__builtins__,__import___str)) goto err;
 823   }
 824
 825   UNLESS (r=PyObject_CallFunction(__import__,"OOOO",
 826                                  module_name, globals, globals, silly_list))
 827     goto err;
 828
 829   Py_DECREF(globals);
 830   Py_DECREF(__builtins__);
 831   Py_DECREF(__import__);
 832
 833   return r;
 834 err:
 835   Py_XDECREF(globals);
 836   Py_XDECREF(__builtins__);
 837   Py_XDECREF(__import__);
 838   return NULL;
 839 }
 840
 841 static PyObject *
 842 whichmodule(PyObject *global, PyObject *global_name) {
 843     int i, j;
 844     PyObject *module = 0, *modules_dict = 0,
 845         *global_name_attr = 0, *name = 0;
 846
 847     module = PyObject_GetAttrString(global, "__module__");
 848     if (module) return module;
 849     PyErr_Clear();
 850
 851     UNLESS (modules_dict = PySys_GetObject("modules"))
 852         return NULL;
 853
 854     i = 0;
 855     while ((j = PyDict_Next(modules_dict, &i, &name, &module))) {
 856
 857         if (PyObject_Compare(name, __main___str)==0) continue;
 858
 859         UNLESS (global_name_attr = PyObject_GetAttr(module, global_name)) {
 860             PyErr_Clear();
 861             continue;
 862         }
 863
 864         if (global_name_attr != global) {
 865             Py_DECREF(global_name_attr);
 866             continue;
 867         }
 868
 869         Py_DECREF(global_name_attr);
 870
 871         break;
 872     }
 873
 874     /* The following implements the rule in pickle.py added in 1.5
 875        that used __main__ if no module is found.  I don't actually
 876        like this rule. jlf
 877      */
 878     if (!j) {
 879         j=1;
 880         name=__main___str;
 881     }
 882
 883     Py_INCREF(name);
 884     return name;
 885 }
 886
 887
 888 static int
 889 save_none(Picklerobject *self, PyObject *args) {
 890     static char none = NONE;
 891     if ((*self->write_func)(self, &none, 1) < 0)
 892         return -1;
 893
 894     return 0;
 895 }
 896
 897
 898 static int
 899 save_int(Picklerobject *self, PyObject *args) {
 900     char c_str[32];
 901     long l = PyInt_AS_LONG((PyIntObject *)args);
 902     int len = 0;
 903
 904     if (!self->bin
 905 #if SIZEOF_LONG > 4
 906         || (l >> 32)
 907 #endif
 908             ) {
 909                 /* Save extra-long ints in non-binary mode, so that
 910                    we can use python long parsing code to restore,
 911                    if necessary. */
 912         c_str[0] = INT;
 913         sprintf(c_str + 1, "%ld\n", l);
 914         if ((*self->write_func)(self, c_str, strlen(c_str)) < 0)
 915             return -1;
 916     }
 917     else {
 918         c_str[1] = (int)( l        & 0xff);
 919         c_str[2] = (int)((l >> 8)  & 0xff);
 920         c_str[3] = (int)((l >> 16) & 0xff);
 921         c_str[4] = (int)((l >> 24) & 0xff);
 922
 923         if ((c_str[4] == 0) && (c_str[3] == 0)) {
 924             if (c_str[2] == 0) {
 925                 c_str[0] = BININT1;
 926                 len = 2;
 927             }
 928             else {
 929                 c_str[0] = BININT2;
 930                 len = 3;
 931             }
 932         }
 933         else {
 934             c_str[0] = BININT;
 935             len = 5;
 936         }
 937
 938         if ((*self->write_func)(self, c_str, len) < 0)
 939             return -1;
 940     }
 941
 942     return 0;
 943 }
 944
 945
 946 static int
 947 save_long(Picklerobject *self, PyObject *args) {
 948     int size, res = -1;
 949     PyObject *repr = 0;
 950
 951     static char l = LONG;
 952
 953     UNLESS (repr = PyObject_Repr(args))
 954         goto finally;
 955
 956     if ((size = PyString_Size(repr)) < 0)
 957         goto finally;
 958
 959     if ((*self->write_func)(self, &l, 1) < 0)
 960         goto finally;
 961
 962     if ((*self->write_func)(self,
 963         PyString_AS_STRING((PyStringObject *)repr), size) < 0)
 964         goto finally;
 965
 966     if ((*self->write_func)(self, "\n", 1) < 0)
 967         goto finally;
 968
 969     res = 0;
 970
 971 finally:
 972     Py_XDECREF(repr);
 973
 974     return res;
 975 }
 976
 977
 978 static int
 979 save_float(Picklerobject *self, PyObject *args) {
 980     double x = PyFloat_AS_DOUBLE((PyFloatObject *)args);
 981
 982     if (self->bin) {
 983         int s, e;
 984         double f;
 985         long fhi, flo;
 986         char str[9], *p = str;
 987
 988         *p = BINFLOAT;
 989         p++;
 990
 991         if (x < 0) {
 992             s = 1;
 993             x = -x;
 994         }
 995         else
 996             s = 0;
 997
 998         f = frexp(x, &e);
 999
1000         /* Normalize f to be in the range [1.0, 2.0) */
1001         if (0.5 <= f && f < 1.0) {
1002             f *= 2.0;
1003             e--;
1004         }
1005         else if (f == 0.0) {
1006             e = 0;
1007         }
1008         else {
1009             PyErr_SetString(PyExc_SystemError,
1010                             "frexp() result out of range");
1011             return -1;
1012         }
1013
1014         if (e >= 1024) {
1015             /* XXX 1024 itself is reserved for Inf/NaN */
1016             PyErr_SetString(PyExc_OverflowError,
1017                             "float too large to pack with d format");
1018             return -1;
1019         }
1020         else if (e < -1022) {
1021             /* Gradual underflow */
1022             f = ldexp(f, 1022 + e);
1023             e = 0;
1024         }
1025         else if (!(e == 0 && f == 0.0)) {
1026             e += 1023;
1027             f -= 1.0; /* Get rid of leading 1 */
1028         }
1029
1030         /* fhi receives the high 28 bits; flo the low 24 bits (== 52 bits) */
1031         f *= 268435456.0; /* 2**28 */
1032         fhi = (long) floor(f); /* Truncate */
1033         f -= (double)fhi;
1034         f *= 16777216.0; /* 2**24 */
1035         flo = (long) floor(f + 0.5); /* Round */
1036
1037         /* First byte */
1038         *p = (s<<7) | (e>>4);
1039         p++;
1040
1041         /* Second byte */
1042         *p = (char) (((e&0xF)<<4) | (fhi>>24));
1043         p++;
1044
1045         /* Third byte */
1046         *p = (fhi>>16) & 0xFF;
1047         p++;
1048
1049         /* Fourth byte */
1050         *p = (fhi>>8) & 0xFF;
1051         p++;
1052
1053         /* Fifth byte */
1054         *p = fhi & 0xFF;
1055         p++;
1056
1057         /* Sixth byte */
1058         *p = (flo>>16) & 0xFF;
1059         p++;
1060
1061         /* Seventh byte */
1062         *p = (flo>>8) & 0xFF;
1063         p++;
1064
1065         /* Eighth byte */
1066         *p = flo & 0xFF;
1067
1068         if ((*self->write_func)(self, str, 9) < 0)
1069             return -1;
1070     }
1071     else {
1072         char c_str[250];
1073         c_str[0] = FLOAT;
1074         sprintf(c_str + 1, "%.17g\n", x);
1075
1076         if ((*self->write_func)(self, c_str, strlen(c_str)) < 0)
1077             return -1;
1078     }
1079
1080     return 0;
1081 }
1082
1083
1084 static int
1085 save_string(Picklerobject *self, PyObject *args, int doput) {
1086     int size, len;
1087     PyObject *repr=0;
1088
1089     if ((size = PyString_Size(args)) < 0)
1090       return -1;
1091
1092     if (!self->bin) {
1093         char *repr_str;
1094
1095         static char string = STRING;
1096
1097         UNLESS (repr = PyObject_Repr(args))
1098             return -1;
1099
1100         if ((len = PyString_Size(repr)) < 0)
1101           goto err;
1102         repr_str = PyString_AS_STRING((PyStringObject *)repr);
1103
1104         if ((*self->write_func)(self, &string, 1) < 0)
1105             goto err;
1106
1107         if ((*self->write_func)(self, repr_str, len) < 0)
1108             goto err;
1109
1110         if ((*self->write_func)(self, "\n", 1) < 0)
1111             goto err;
1112
1113         Py_XDECREF(repr);
1114     }
1115     else {
1116         int i;
1117         char c_str[5];
1118
1119         if ((size = PyString_Size(args)) < 0)
1120           return -1;
1121
1122         if (size < 256) {
1123             c_str[0] = SHORT_BINSTRING;
1124             c_str[1] = size;
1125             len = 2;
1126         }
1127         else {
1128             c_str[0] = BINSTRING;
1129             for (i = 1; i < 5; i++)
1130                 c_str[i] = (int)(size >> ((i - 1) * 8));
1131             len = 5;
1132         }
1133
1134         if ((*self->write_func)(self, c_str, len) < 0)
1135             return -1;
1136
1137         if (size > 128 && Pdata_Check(self->file)) {
1138             if (write_other(self, NULL, 0) < 0) return -1;
1139             PDATA_APPEND(self->file, args, -1);
1140           }
1141         else {
1142           if ((*self->write_func)(self,
1143               PyString_AS_STRING((PyStringObject *)args), size) < 0)
1144             return -1;
1145         }
1146     }
1147
1148     if (doput)
1149       if (put(self, args) < 0)
1150         return -1;
1151
1152     return 0;
1153
1154 err:
1155     Py_XDECREF(repr);
1156     return -1;
1157 }
1158
1159
1160 static int
1161 save_tuple(Picklerobject *self, PyObject *args) {
1162     PyObject *element = 0, *py_tuple_id = 0;
1163     int len, i, has_key, res = -1;
1164
1165     static char tuple = TUPLE;
1166
1167     if ((*self->write_func)(self, &MARKv, 1) < 0)
1168         goto finally;
1169
1170     if ((len = PyTuple_Size(args)) < 0)
1171         goto finally;
1172
1173     for (i = 0; i < len; i++) {
1174         UNLESS (element = PyTuple_GET_ITEM((PyTupleObject *)args, i))
1175             goto finally;
1176
1177         if (save(self, element, 0) < 0)
1178             goto finally;
1179     }
1180
1181     UNLESS (py_tuple_id = PyInt_FromLong((long)args))
1182         goto finally;
1183
1184     if (len) {
1185         if ((has_key = cPickle_PyMapping_HasKey(self->memo, py_tuple_id)) < 0)
1186             goto finally;
1187
1188         if (has_key) {
1189             if (self->bin) {
1190                 static char pop_mark = POP_MARK;
1191
1192                 if ((*self->write_func)(self, &pop_mark, 1) < 0)
1193                     goto finally;
1194             }
1195             else {
1196                 static char pop = POP;
1197
1198                 for (i = 0; i <= len; i++) {
1199                     if ((*self->write_func)(self, &pop, 1) < 0)
1200                         goto finally;
1201                 }
1202             }
1203
1204             if (get(self, py_tuple_id) < 0)
1205                 goto finally;
1206
1207             res = 0;
1208             goto finally;
1209         }
1210     }
1211
1212     if ((*self->write_func)(self, &tuple, 1) < 0) {
1213         goto finally;
1214     }
1215
1216     if (put(self, args) < 0)
1217         goto finally;
1218
1219     res = 0;
1220
1221 finally:
1222     Py_XDECREF(py_tuple_id);
1223
1224     return res;
1225 }
1226
1227 static int
1228 save_empty_tuple(Picklerobject *self, PyObject *args) {
1229     static char tuple = EMPTY_TUPLE;
1230
1231     return (*self->write_func)(self, &tuple, 1);
1232 }
1233
1234
1235 static int
1236 save_list(Picklerobject *self, PyObject *args) {
1237     PyObject *element = 0;
1238     int s_len, len, i, using_appends, res = -1;
1239     char s[3];
1240
1241     static char append = APPEND, appends = APPENDS;
1242
1243     if (self->bin) {
1244         s[0] = EMPTY_LIST;
1245         s_len = 1;
1246     }
1247     else {
1248         s[0] = MARK;
1249         s[1] = LIST;
1250         s_len = 2;
1251     }
1252
1253     if ((len = PyList_Size(args)) < 0)
1254         goto finally;
1255
1256     if ((*self->write_func)(self, s, s_len) < 0)
1257         goto finally;
1258
1259     if (len == 0) {
1260         if (put(self, args) < 0)
1261             goto finally;
1262     }
1263     else {
1264         if (put2(self, args) < 0)
1265             goto finally;
1266     }
1267
1268     if ((using_appends = (self->bin && (len > 1))))
1269         if ((*self->write_func)(self, &MARKv, 1) < 0)
1270             goto finally;
1271
1272     for (i = 0; i < len; i++) {
1273         UNLESS (element = PyList_GET_ITEM((PyListObject *)args, i))
1274             goto finally;
1275
1276         if (save(self, element, 0) < 0)
1277             goto finally;
1278
1279         if (!using_appends) {
1280             if ((*self->write_func)(self, &append, 1) < 0)
1281                 goto finally;
1282         }
1283     }
1284
1285     if (using_appends) {
1286         if ((*self->write_func)(self, &appends, 1) < 0)
1287             goto finally;
1288     }
1289
1290     res = 0;
1291
1292 finally:
1293
1294     return res;
1295 }
1296
1297
1298 static int
1299 save_dict(Picklerobject *self, PyObject *args) {
1300     PyObject *key = 0, *value = 0;
1301     int i, len, res = -1, using_setitems;
1302     char s[3];
1303
1304     static char setitem = SETITEM, setitems = SETITEMS;
1305
1306     if (self->bin) {
1307         s[0] = EMPTY_DICT;
1308         len = 1;
1309     }
1310     else {
1311         s[0] = MARK;
1312         s[1] = DICT;
1313         len = 2;
1314     }
1315
1316     if ((*self->write_func)(self, s, len) < 0)
1317         goto finally;
1318
1319     if ((len = PyDict_Size(args)) < 0)
1320         goto finally;
1321
1322     if (len == 0) {
1323         if (put(self, args) < 0)
1324             goto finally;
1325     }
1326     else {
1327         if (put2(self, args) < 0)
1328             goto finally;
1329     }
1330
1331     if ((using_setitems = (self->bin && (PyDict_Size(args) > 1))))
1332         if ((*self->write_func)(self, &MARKv, 1) < 0)
1333             goto finally;
1334
1335     i = 0;
1336     while (PyDict_Next(args, &i, &key, &value)) {
1337         if (save(self, key, 0) < 0)
1338             goto finally;
1339
1340         if (save(self, value, 0) < 0)
1341             goto finally;
1342
1343         if (!using_setitems) {
1344             if ((*self->write_func)(self, &setitem, 1) < 0)
1345                 goto finally;
1346         }
1347     }
1348
1349     if (using_setitems) {
1350         if ((*self->write_func)(self, &setitems, 1) < 0)
1351             goto finally;
1352     }
1353
1354     res = 0;
1355
1356 finally:
1357
1358     return res;
1359 }
1360
1361
1362 static int
1363 save_inst(Picklerobject *self, PyObject *args) {
1364     PyObject *class = 0, *module = 0, *name = 0, *state = 0,
1365              *getinitargs_func = 0, *getstate_func = 0, *class_args = 0;
1366     char *module_str, *name_str;
1367     int module_size, name_size, res = -1;
1368
1369     static char inst = INST, obj = OBJ, build = BUILD;
1370
1371     if ((*self->write_func)(self, &MARKv, 1) < 0)
1372         goto finally;
1373
1374     UNLESS (class = PyObject_GetAttr(args, __class___str))
1375         goto finally;
1376
1377     if (self->bin) {
1378         if (save(self, class, 0) < 0)
1379             goto finally;
1380     }
1381
1382     if ((getinitargs_func = PyObject_GetAttr(args, __getinitargs___str))) {
1383         PyObject *element = 0;
1384         int i, len;
1385
1386         UNLESS (class_args =
1387             PyObject_CallObject(getinitargs_func, empty_tuple))
1388             goto finally;
1389
1390         if ((len = PyObject_Length(class_args)) < 0)
1391             goto finally;
1392
1393         for (i = 0; i < len; i++) {
1394             UNLESS (element = PySequence_GetItem(class_args, i))
1395                 goto finally;
1396
1397             if (save(self, element, 0) < 0) {
1398                 Py_DECREF(element);
1399                 goto finally;
1400             }
1401
1402             Py_DECREF(element);
1403         }
1404     }
1405     else {
1406         PyErr_Clear();
1407     }
1408
1409     if (!self->bin) {
1410         UNLESS (name = ((PyClassObject *)class)->cl_name) {
1411             PyErr_SetString(PicklingError, "class has no name");
1412             goto finally;
1413         }
1414
1415         UNLESS (module = whichmodule(class, name))
1416             goto finally;
1417
1418
1419         if ((module_size = PyString_Size(module)) < 0 ||
1420            (name_size = PyString_Size(name)) < 0)
1421           goto finally;
1422
1423         module_str = PyString_AS_STRING((PyStringObject *)module);
1424         name_str   = PyString_AS_STRING((PyStringObject *)name);
1425
1426         if ((*self->write_func)(self, &inst, 1) < 0)
1427             goto finally;
1428
1429         if ((*self->write_func)(self, module_str, module_size) < 0)
1430             goto finally;
1431
1432         if ((*self->write_func)(self, "\n", 1) < 0)
1433             goto finally;
1434
1435         if ((*self->write_func)(self, name_str, name_size) < 0)
1436             goto finally;
1437
1438         if ((*self->write_func)(self, "\n", 1) < 0)
1439             goto finally;
1440     }
1441     else if ((*self->write_func)(self, &obj, 1) < 0) {
1442         goto finally;
1443     }
1444
1445     if ((getstate_func = PyObject_GetAttr(args, __getstate___str))) {
1446         UNLESS (state = PyObject_CallObject(getstate_func, empty_tuple))
1447             goto finally;
1448     }
1449     else {
1450         PyErr_Clear();
1451
1452         UNLESS (state = PyObject_GetAttr(args, __dict___str)) {
1453             PyErr_Clear();
1454             res = 0;
1455             goto finally;
1456         }
1457     }
1458
1459     if (!PyDict_Check(state)) {
1460         if (put2(self, args) < 0)
1461             goto finally;
1462     }
1463     else {
1464         if (put(self, args) < 0)
1465             goto finally;
1466     }
1467
1468     if (save(self, state, 0) < 0)
1469         goto finally;
1470
1471     if ((*self->write_func)(self, &build, 1) < 0)
1472         goto finally;
1473
1474     res = 0;
1475
1476 finally:
1477     Py_XDECREF(module);
1478     Py_XDECREF(class);
1479     Py_XDECREF(state);
1480     Py_XDECREF(getinitargs_func);
1481     Py_XDECREF(getstate_func);
1482     Py_XDECREF(class_args);
1483
1484     return res;
1485 }
1486
1487
1488 static int
1489 save_global(Picklerobject *self, PyObject *args, PyObject *name) {
1490     PyObject *global_name = 0, *module = 0;
1491     char *name_str, *module_str;
1492     int module_size, name_size, res = -1;
1493
1494     static char global = GLOBAL;
1495
1496     if (name) {
1497         global_name = name;
1498         Py_INCREF(global_name);
1499     }
1500     else {
1501         UNLESS (global_name = PyObject_GetAttr(args, __name___str))
1502             goto finally;
1503     }
1504
1505     UNLESS (module = whichmodule(args, global_name))
1506         goto finally;
1507
1508     if ((module_size = PyString_Size(module)) < 0 ||
1509         (name_size = PyString_Size(global_name)) < 0)
1510       goto finally;
1511
1512     module_str = PyString_AS_STRING((PyStringObject *)module);
1513     name_str   = PyString_AS_STRING((PyStringObject *)global_name);
1514
1515     if ((*self->write_func)(self, &global, 1) < 0)
1516         goto finally;
1517
1518     if ((*self->write_func)(self, module_str, module_size) < 0)
1519         goto finally;
1520
1521     if ((*self->write_func)(self, "\n", 1) < 0)
1522         goto finally;
1523
1524     if ((*self->write_func)(self, name_str, name_size) < 0)
1525         goto finally;
1526
1527     if ((*self->write_func)(self, "\n", 1) < 0)
1528         goto finally;
1529
1530     if (put(self, args) < 0)
1531         goto finally;
1532
1533     res = 0;
1534
1535 finally:
1536     Py_XDECREF(module);
1537     Py_XDECREF(global_name);
1538
1539     return res;
1540 }
1541
1542 static int
1543 save_pers(Picklerobject *self, PyObject *args, PyObject *f) {
1544     PyObject *pid = 0;
1545     int size, res = -1;
1546
1547     static char persid = PERSID, binpersid = BINPERSID;
1548
1549     Py_INCREF(args);
1550     ARG_TUP(self, args);
1551     if (self->arg) {
1552         pid = PyObject_CallObject(f, self->arg);
1553         FREE_ARG_TUP(self);
1554     }
1555     if (! pid) return -1;
1556
1557     if (pid != Py_None) {
1558         if (!self->bin) {
1559             if (!PyString_Check(pid)) {
1560                 PyErr_SetString(PicklingError,
1561                     "persistent id must be string");
1562                 goto finally;
1563             }
1564
1565             if ((*self->write_func)(self, &persid, 1) < 0)
1566                 goto finally;
1567
1568             if ((size = PyString_Size(pid)) < 0)
1569                 goto finally;
1570
1571             if ((*self->write_func)(self,
1572                 PyString_AS_STRING((PyStringObject *)pid), size) < 0)
1573                 goto finally;
1574
1575             if ((*self->write_func)(self, "\n", 1) < 0)
1576                 goto finally;
1577
1578             res = 1;
1579             goto finally;
1580         }
1581         else if (save(self, pid, 1) >= 0) {
1582             if ((*self->write_func)(self, &binpersid, 1) < 0)
1583                 res = -1;
1584             else
1585                 res = 1;
1586         }
1587
1588         goto finally;
1589     }
1590
1591     res = 0;
1592
1593 finally:
1594     Py_XDECREF(pid);
1595
1596     return res;
1597 }
1598
1599
1600 static int
1601 save_reduce(Picklerobject *self, PyObject *callable,
1602             PyObject *tup, PyObject *state, PyObject *ob) {
1603     static char reduce = REDUCE, build = BUILD;
1604
1605     if (save(self, callable, 0) < 0)
1606         return -1;
1607
1608     if (save(self, tup, 0) < 0)
1609         return -1;
1610
1611     if ((*self->write_func)(self, &reduce, 1) < 0)
1612         return -1;
1613
1614     if (ob != NULL) {
1615         if (state && !PyDict_Check(state)) {
1616             if (put2(self, ob) < 0)
1617                 return -1;
1618         }
1619         else {
1620             if (put(self, ob) < 0)
1621                 return -1;
1622         }
1623     }
1624
1625     if (state) {
1626         if (save(self, state, 0) < 0)
1627             return -1;
1628
1629         if ((*self->write_func)(self, &build, 1) < 0)
1630             return -1;
1631     }
1632
1633     return 0;
1634 }
1635
1636 static int
1637 save(Picklerobject *self, PyObject *args, int  pers_save) {
1638     PyTypeObject *type;
1639     PyObject *py_ob_id = 0, *__reduce__ = 0, *t = 0, *arg_tup = 0,
1640              *callable = 0, *state = 0;
1641     int res = -1, tmp, size;
1642
1643     if (!pers_save && self->pers_func) {
1644         if ((tmp = save_pers(self, args, self->pers_func)) != 0) {
1645             res = tmp;
1646             goto finally;
1647         }
1648     }
1649
1650     if (args == Py_None) {
1651         res = save_none(self, args);
1652         goto finally;
1653     }
1654
1655     type = args->ob_type;
1656
1657     switch (type->tp_name[0]) {
1658         case 'i':
1659             if (type == &PyInt_Type) {
1660                 res = save_int(self, args);
1661                 goto finally;
1662             }
1663             break;
1664
1665         case 'l':
1666             if (type == &PyLong_Type) {
1667                 res = save_long(self, args);
1668                 goto finally;
1669             }
1670             break;
1671
1672         case 'f':
1673             if (type == &PyFloat_Type) {
1674                 res = save_float(self, args);
1675                 goto finally;
1676             }
1677             break;
1678
1679         case 't':
1680             if (type == &PyTuple_Type && PyTuple_Size(args)==0) {
1681                 if (self->bin) res = save_empty_tuple(self, args);
1682                 else          res = save_tuple(self, args);
1683                 goto finally;
1684             }
1685             break;
1686
1687         case 's':
1688             if ((type == &PyString_Type) && (PyString_GET_SIZE(args) < 2)) {
1689                 res = save_string(self, args, 0);
1690                 goto finally;
1691             }
1692     }
1693
1694     if (args->ob_refcnt > 1) {
1695         long ob_id;
1696         int  has_key;
1697
1698         ob_id = (long)args;
1699
1700         UNLESS (py_ob_id = PyInt_FromLong(ob_id))
1701             goto finally;
1702
1703         if ((has_key = cPickle_PyMapping_HasKey(self->memo, py_ob_id)) < 0)
1704             goto finally;
1705
1706         if (has_key) {
1707             if (get(self, py_ob_id) < 0)
1708                 goto finally;
1709
1710             res = 0;
1711             goto finally;
1712         }
1713     }
1714
1715     switch (type->tp_name[0]) {
1716         case 's':
1717             if (type == &PyString_Type) {
1718                 res = save_string(self, args, 1);
1719                 goto finally;
1720             }
1721             break;
1722
1723         case 't':
1724             if (type == &PyTuple_Type) {
1725                 res = save_tuple(self, args);
1726                 goto finally;
1727             }
1728             break;
1729
1730         case 'l':
1731             if (type == &PyList_Type) {
1732                 res = save_list(self, args);
1733                 goto finally;
1734             }
1735             break;
1736
1737         case 'd':
1738             if (type == &PyDict_Type) {
1739                 res = save_dict(self, args);
1740                 goto finally;
1741             }
1742             break;
1743
1744         case 'i':
1745             if (type == &PyInstance_Type) {
1746                 res = save_inst(self, args);
1747                 goto finally;
1748             }
1749             break;
1750
1751         case 'c':
1752             if (type == &PyClass_Type) {
1753                 res = save_global(self, args, NULL);
1754                 goto finally;
1755             }
1756             break;
1757
1758         case 'f':
1759             if (type == &PyFunction_Type) {
1760                 res = save_global(self, args, NULL);
1761                 goto finally;
1762             }
1763             break;
1764
1765         case 'b':
1766             if (type == &PyCFunction_Type) {
1767                 res = save_global(self, args, NULL);
1768                 goto finally;
1769             }
1770     }
1771
1772     if (!pers_save && self->inst_pers_func) {
1773         if ((tmp = save_pers(self, args, self->inst_pers_func)) != 0) {
1774             res = tmp;
1775             goto finally;
1776         }
1777     }
1778
1779     if ((__reduce__ = PyDict_GetItem(dispatch_table, (PyObject *)type))) {
1780         Py_INCREF(__reduce__);
1781
1782         Py_INCREF(args);
1783         ARG_TUP(self, args);
1784         if (self->arg) {
1785             t = PyObject_CallObject(__reduce__, self->arg);
1786             FREE_ARG_TUP(self);
1787         }
1788         if (! t) goto finally;
1789     }
1790     else {
1791         PyErr_Clear();
1792
1793         if ((__reduce__ = PyObject_GetAttr(args, __reduce___str))) {
1794             UNLESS (t = PyObject_CallObject(__reduce__, empty_tuple))
1795                 goto finally;
1796         }
1797         else {
1798             PyErr_Clear();
1799         }
1800     }
1801
1802     if (t) {
1803         if (PyString_Check(t)) {
1804             res = save_global(self, args, t);
1805             goto finally;
1806         }
1807
1808         if (!PyTuple_Check(t)) {
1809             cPickle_ErrFormat(PicklingError, "Value returned by %s must "
1810                 "be a tuple", "O", __reduce__);
1811             goto finally;
1812         }
1813
1814         size = PyTuple_Size(t);
1815
1816         if ((size != 3) && (size != 2)) {
1817             cPickle_ErrFormat(PicklingError, "tuple returned by %s must "
1818                 "contain only two or three elements", "O", __reduce__);
1819                 goto finally;
1820         }
1821
1822         callable = PyTuple_GET_ITEM(t, 0);
1823
1824         arg_tup = PyTuple_GET_ITEM(t, 1);
1825
1826         if (size > 2) {
1827             state = PyTuple_GET_ITEM(t, 2);
1828         }
1829
1830         UNLESS (PyTuple_Check(arg_tup) || arg_tup==Py_None) {
1831             cPickle_ErrFormat(PicklingError, "Second element of tuple "
1832                 "returned by %s must be a tuple", "O", __reduce__);
1833             goto finally;
1834         }
1835
1836         res = save_reduce(self, callable, arg_tup, state, args);
1837         goto finally;
1838     }
1839
1840     cPickle_ErrFormat(PicklingError, "Cannot pickle %s objects.",
1841         "O", (PyObject *)type);
1842
1843 finally:
1844     Py_XDECREF(py_ob_id);
1845     Py_XDECREF(__reduce__);
1846     Py_XDECREF(t);
1847
1848     return res;
1849 }
1850
1851
1852 static int
1853 dump(Picklerobject *self, PyObject *args) {
1854     static char stop = STOP;
1855
1856     if (save(self, args, 0) < 0)
1857         return -1;
1858
1859     if ((*self->write_func)(self, &stop, 1) < 0)
1860         return -1;
1861
1862     if ((*self->write_func)(self, NULL, 0) < 0)
1863         return -1;
1864
1865     return 0;
1866 }
1867
1868 static PyObject *
1869 Pickle_clear_memo(Picklerobject *self, PyObject *args) {
1870   if (args && ! PyArg_ParseTuple(args,"")) return NULL;
1871   if (self->memo) PyDict_Clear(self->memo);
1872   Py_INCREF(Py_None);
1873   return Py_None;
1874 }
1875
1876 static PyObject *
1877 Pickle_getvalue(Picklerobject *self, PyObject *args) {
1878   int l, i, rsize, ssize, clear=1, lm;
1879   long ik;
1880   PyObject *k, *r;
1881   char *s, *p, *have_get;
1882   Pdata *data;
1883
1884   if (args && ! PyArg_ParseTuple(args,"|i",&clear)) return NULL;
1885
1886   /* Check to make sure we are based on a list */
1887   if (! Pdata_Check(self->file)) {
1888       PyErr_SetString(PicklingError,
1889                       "Attempt to getvalue a non-list-based pickler");
1890       return NULL;
1891     }
1892
1893   /* flush write buffer */
1894   if (write_other(self, NULL, 0) < 0) return NULL;
1895
1896   data=(Pdata*)self->file;
1897   l=data->length;
1898
1899   /* set up an array to hold get/put status */
1900   if ((lm=PyDict_Size(self->memo)) < 0) return NULL;
1901   lm++;
1902   if (! (have_get=malloc((lm)*sizeof(char)))) return PyErr_NoMemory();
1903   memset(have_get,0,lm);
1904
1905   /* Scan for gets. */
1906   for (rsize=0, i=l; --i >= 0; ) {
1907       k=data->data[i];
1908
1909       if (PyString_Check(k)) {
1910         rsize += PyString_GET_SIZE(k);
1911       }
1912
1913       else if (PyInt_Check(k)) { /* put */
1914         ik=PyInt_AS_LONG((PyIntObject*)k);
1915         if (ik >= lm || ik==0) {
1916           PyErr_SetString(PicklingError,
1917                           "Invalid get data");
1918           return NULL;
1919         }
1920         if (have_get[ik]) { /* with matching get */
1921           if (ik < 256) rsize += 2;
1922           else rsize+=5;
1923         }
1924       }
1925
1926       else if (! (PyTuple_Check(k) &&
1927                   PyTuple_GET_SIZE(k) == 2 &&
1928                   PyInt_Check((k=PyTuple_GET_ITEM(k,0))))
1929                ) {
1930         PyErr_SetString(PicklingError,
1931                         "Unexpected data in internal list");
1932         return NULL;
1933       }
1934
1935       else { /* put */
1936         ik=PyInt_AS_LONG((PyIntObject*)k);
1937         if (ik >= lm || ik==0) {
1938           PyErr_SetString(PicklingError,
1939                           "Invalid get data");
1940           return NULL;
1941         }
1942         have_get[ik]=1;
1943         if (ik < 256) rsize += 2;
1944         else rsize+=5;
1945       }
1946
1947     }
1948
1949   /* Now generate the result */
1950   UNLESS (r=PyString_FromStringAndSize(NULL,rsize)) goto err;
1951   s=PyString_AS_STRING((PyStringObject*)r);
1952
1953   for (i=0; i<l; i++) {
1954       k=data->data[i];
1955
1956       if (PyString_Check(k)) {
1957         ssize=PyString_GET_SIZE(k);
1958         if (ssize) {
1959             p=PyString_AS_STRING((PyStringObject*)k);
1960             while (--ssize >= 0) *s++=*p++;
1961           }
1962       }
1963
1964       else if (PyTuple_Check(k)) { /* get */
1965         ik=PyInt_AS_LONG((PyIntObject*)PyTuple_GET_ITEM(k,0));
1966         if (ik < 256) {
1967           *s++ = BINGET;
1968           *s++ = (int)(ik & 0xff);
1969         }
1970         else {
1971           *s++ = LONG_BINGET;
1972           *s++ = (int)(ik & 0xff);
1973           *s++ = (int)((ik >> 8)  & 0xff);
1974           *s++ = (int)((ik >> 16) & 0xff);
1975           *s++ = (int)((ik >> 24) & 0xff);
1976         }
1977       }
1978
1979       else { /* put */
1980         ik=PyInt_AS_LONG((PyIntObject*)k);
1981
1982         if (have_get[ik]) { /* with matching get */
1983           if (ik < 256) {
1984             *s++ = BINPUT;
1985             *s++ = (int)(ik & 0xff);
1986           }
1987           else {
1988             *s++ = LONG_BINPUT;
1989             *s++ = (int)(ik & 0xff);
1990             *s++ = (int)((ik >> 8)  & 0xff);
1991             *s++ = (int)((ik >> 16) & 0xff);
1992             *s++ = (int)((ik >> 24) & 0xff);
1993           }
1994         }
1995       }
1996
1997     }
1998
1999   if (clear) {
2000     PyDict_Clear(self->memo);
2001     Pdata_clear(data,0);
2002   }
2003
2004   free(have_get);
2005   return r;
2006 err:
2007   free(have_get);
2008   return NULL;
2009 }
2010
2011 static PyObject *
2012 Pickler_dump(Picklerobject *self, PyObject *args) {
2013     PyObject *ob;
2014     int get=0;
2015
2016     UNLESS (PyArg_ParseTuple(args, "O|i", &ob, &get))
2017         return NULL;
2018
2019     if (dump(self, ob) < 0)
2020         return NULL;
2021
2022     if (get) return Pickle_getvalue(self, NULL);
2023
2024     Py_INCREF(self);
2025     return (PyObject*)self;
2026 }
2027
2028
2029 static struct PyMethodDef Pickler_methods[] = {
2030   {"dump",          (PyCFunction)Pickler_dump,  1,
2031    "dump(object) --"
2032    "Write an object in pickle format to the object's pickle stream\n"
2033   },
2034   {"clear_memo",  (PyCFunction)Pickle_clear_memo,  1,
2035    "clear_memo() -- Clear the picklers memo"},
2036   {"getvalue",  (PyCFunction)Pickle_getvalue,  1,
2037    "getvalue() -- Finish picking a list-based pickle"},
2038   {NULL,                NULL}           /* sentinel */
2039 };
2040
2041
2042 static Picklerobject *
2043 newPicklerobject(PyObject *file, int bin) {
2044     Picklerobject *self;
2045
2046     UNLESS (self = PyObject_NEW(Picklerobject, &Picklertype))
2047         return NULL;
2048
2049     self->fp = NULL;
2050     self->write = NULL;
2051     self->memo = NULL;
2052     self->arg = NULL;
2053     self->pers_func = NULL;
2054     self->inst_pers_func = NULL;
2055     self->write_buf = NULL;
2056     self->bin = bin;
2057     self->fast = 0;
2058     self->buf_size = 0;
2059     self->dispatch_table = NULL;
2060
2061     if (file)
2062       Py_INCREF(file);
2063     else
2064       file=Pdata_New();
2065
2066     self->file = file;
2067
2068     UNLESS (self->memo = PyDict_New()) {
2069        Py_XDECREF((PyObject *)self);
2070        return NULL;
2071     }
2072
2073     if (PyFile_Check(file)) {
2074         self->fp = PyFile_AsFile(file);
2075         self->write_func = write_file;
2076     }
2077     else if (PycStringIO_OutputCheck(file)) {
2078         self->write_func = write_cStringIO;
2079     }
2080     else if (file == Py_None) {
2081         self->write_func = write_none;
2082     }
2083     else {
2084         self->write_func = write_other;
2085
2086         if (! Pdata_Check(file)) {
2087           UNLESS (self->write = PyObject_GetAttr(file, write_str)) {
2088             PyErr_Clear();
2089             PyErr_SetString(PyExc_TypeError, "argument must have 'write' "
2090                             "attribute");
2091             goto err;
2092           }
2093         }
2094
2095         UNLESS (self->write_buf =
2096             (char *)malloc(WRITE_BUF_SIZE * sizeof(char))) {
2097             PyErr_NoMemory();
2098             goto err;
2099         }
2100     }
2101
2102     if (PyEval_GetRestricted()) {
2103         /* Restricted execution, get private tables */
2104         PyObject *m;
2105
2106         UNLESS (m=PyImport_Import(copy_reg_str)) goto err;
2107         self->dispatch_table=PyObject_GetAttr(m, dispatch_table_str);
2108         Py_DECREF(m);
2109         UNLESS (self->dispatch_table) goto err;
2110     }
2111     else {
2112         self->dispatch_table=dispatch_table;
2113         Py_INCREF(dispatch_table);
2114     }
2115
2116     return self;
2117
2118 err:
2119     Py_DECREF((PyObject *)self);
2120     return NULL;
2121 }
2122
2123
2124 static PyObject *
2125 get_Pickler(PyObject *self, PyObject *args) {
2126     PyObject *file=NULL;
2127     int bin;
2128
2129     bin=1;
2130     if (! PyArg_ParseTuple(args, "|i", &bin)) {
2131         PyErr_Clear();
2132         bin=0;
2133         if (! PyArg_ParseTuple(args, "O|i", &file, &bin))
2134           return NULL;
2135       }
2136     return (PyObject *)newPicklerobject(file, bin);
2137 }
2138
2139
2140 static void
2141 Pickler_dealloc(Picklerobject *self) {
2142     Py_XDECREF(self->write);
2143     Py_XDECREF(self->memo);
2144     Py_XDECREF(self->arg);
2145     Py_XDECREF(self->file);
2146     Py_XDECREF(self->pers_func);
2147     Py_XDECREF(self->inst_pers_func);
2148     Py_XDECREF(self->dispatch_table);
2149
2150     if (self->write_buf) {
2151         free(self->write_buf);
2152     }
2153
2154     PyMem_DEL(self);
2155 }
2156
2157
2158 static PyObject *
2159 Pickler_getattr(Picklerobject *self, char *name) {
2160
2161   switch (*name) {
2162   case 'p':
2163     if (strcmp(name, "persistent_id") == 0) {
2164         if (!self->pers_func) {
2165             PyErr_SetString(PyExc_AttributeError, name);
2166             return NULL;
2167         }
2168
2169         Py_INCREF(self->pers_func);
2170         return self->pers_func;
2171     }
2172     break;
2173   case 'm':
2174     if (strcmp(name, "memo") == 0) {
2175         if (!self->memo) {
2176             PyErr_SetString(PyExc_AttributeError, name);
2177             return NULL;
2178         }
2179
2180         Py_INCREF(self->memo);
2181         return self->memo;
2182     }
2183     break;
2184   case 'P':
2185     if (strcmp(name, "PicklingError") == 0) {
2186         Py_INCREF(PicklingError);
2187         return PicklingError;
2188     }
2189     break;
2190   case 'b':
2191     if (strcmp(name, "binary")==0)
2192       return PyInt_FromLong(self->bin);
2193     break;
2194   case 'f':
2195     if (strcmp(name, "fast")==0)
2196       return PyInt_FromLong(self->fast);
2197     break;
2198   case 'g':
2199     if (strcmp(name, "getvalue")==0 && ! Pdata_Check(self->file)) {
2200       PyErr_SetString(PyExc_AttributeError, name);
2201       return NULL;
2202     }
2203     break;
2204   }
2205   return Py_FindMethod(Pickler_methods, (PyObject *)self, name);
2206 }
2207
2208
2209 int
2210 Pickler_setattr(Picklerobject *self, char *name, PyObject *value) {
2211
2212     if (! value) {
2213         PyErr_SetString(PyExc_TypeError,
2214                         "attribute deletion is not supported");
2215         return -1;
2216     }
2217
2218     if (strcmp(name, "persistent_id") == 0) {
2219         Py_XDECREF(self->pers_func);
2220         self->pers_func = value;
2221         Py_INCREF(value);
2222         return 0;
2223     }
2224
2225     if (strcmp(name, "inst_persistent_id") == 0) {
2226         Py_XDECREF(self->inst_pers_func);
2227         self->inst_pers_func = value;
2228         Py_INCREF(value);
2229         return 0;
2230     }
2231
2232     if (strcmp(name, "memo") == 0) {
2233         if (! PyDict_Check(value)) {
2234           PyErr_SetString(PyExc_TypeError, "memo must be a dictionary");
2235           return -1;
2236         }
2237         Py_XDECREF(self->memo);
2238         self->memo = value;
2239         Py_INCREF(value);
2240         return 0;
2241     }
2242
2243     if (strcmp(name, "binary")==0) {
2244         self->bin=PyObject_IsTrue(value);
2245         return 0;
2246     }
2247
2248     if (strcmp(name, "fast")==0) {
2249         self->fast=PyObject_IsTrue(value);
2250         return 0;
2251     }
2252
2253     PyErr_SetString(PyExc_AttributeError, name);
2254     return -1;
2255 }
2256
2257
2258 static char Picklertype__doc__[] =
2259 "Objects that know how to pickle objects\n"
2260 ;
2261
2262 static PyTypeObject Picklertype = {
2263     PyObject_HEAD_INIT(NULL)
2264     0,                            /*ob_size*/
2265     "Pickler",                    /*tp_name*/
2266     sizeof(Picklerobject),                /*tp_basicsize*/
2267     0,                            /*tp_itemsize*/
2268     /* methods */
2269     (destructor)Pickler_dealloc,  /*tp_dealloc*/
2270     (printfunc)0,         /*tp_print*/
2271     (getattrfunc)Pickler_getattr, /*tp_getattr*/
2272     (setattrfunc)Pickler_setattr, /*tp_setattr*/
2273     (cmpfunc)0,           /*tp_compare*/
2274     (reprfunc)0,          /*tp_repr*/
2275     0,                    /*tp_as_number*/
2276     0,            /*tp_as_sequence*/
2277     0,            /*tp_as_mapping*/
2278     (hashfunc)0,          /*tp_hash*/
2279     (ternaryfunc)0,               /*tp_call*/
2280     (reprfunc)0,          /*tp_str*/
2281
2282     /* Space for future expansion */
2283     0L,0L,0L,0L,
2284     Picklertype__doc__ /* Documentation string */
2285 };
2286
2287 static PyObject *
2288 find_class(PyObject *py_module_name, PyObject *py_global_name) {
2289     PyObject *global = 0, *module;
2290
2291     module = PySys_GetObject("modules");
2292     if (module == NULL)
2293       return NULL;
2294
2295     module = PyDict_GetItem(module, py_module_name);
2296     if (module == NULL) {
2297       module = PyImport_Import(py_module_name);
2298       if (!module)
2299           return NULL;
2300       global = PyObject_GetAttr(module, py_global_name);
2301       Py_DECREF(module);
2302     }
2303     else
2304       global = PyObject_GetAttr(module, py_global_name);
2305     if (global == NULL) {
2306       char buf[256 + 37];
2307       sprintf(buf, "Failed to import class %.128s from module %.128s",
2308               PyString_AS_STRING((PyStringObject*)py_global_name),
2309               PyString_AS_STRING((PyStringObject*)py_module_name));
2310       PyErr_SetString(PyExc_SystemError, buf);
2311       return NULL;
2312     }
2313     return global;
2314 }
2315
2316 static int
2317 marker(Unpicklerobject *self) {
2318     if (self->num_marks < 1) {
2319         PyErr_SetString(UnpicklingError, "could not find MARK");
2320         return -1;
2321     }
2322
2323     return self->marks[--self->num_marks];
2324 }
2325
2326
2327 static int
2328 load_none(Unpicklerobject *self) {
2329     PDATA_APPEND(self->stack, Py_None, -1);
2330     return 0;
2331 }
2332
2333 static int
2334 bad_readline() {
2335     PyErr_SetString(UnpicklingError, "pickle data was truncated");
2336     return -1;
2337 }
2338
2339 static int
2340 load_int(Unpicklerobject *self) {
2341     PyObject *py_int = 0;
2342     char *endptr, *s;
2343     int len, res = -1;
2344     long l;
2345
2346     if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
2347     if (len < 2) return bad_readline();
2348     UNLESS (s=pystrndup(s,len)) return -1;
2349
2350     errno = 0;
2351     l = strtol(s, &endptr, 0);
2352
2353     if (errno || (*endptr != '\n') || (endptr[1] != '\0')) {
2354         /* Hm, maybe we've got something long.  Let's try reading
2355            it as a Python long object. */
2356         errno=0;
2357         UNLESS (py_int=PyLong_FromString(s,&endptr,0)) goto finally;
2358
2359         if ((*endptr != '\n') || (endptr[1] != '\0')) {
2360             PyErr_SetString(PyExc_ValueError,
2361                             "could not convert string to int");
2362             goto finally;
2363         }
2364     }
2365     else {
2366         UNLESS (py_int = PyInt_FromLong(l)) goto finally;
2367     }
2368
2369     free(s);
2370     PDATA_PUSH(self->stack, py_int, -1);
2371     return 0;
2372
2373 finally:
2374     free(s);
2375
2376     return res;
2377 }
2378
2379
2380 static long
2381 calc_binint(char *s, int  x) {
2382     unsigned char c;
2383     int i;
2384     long l;
2385
2386     for (i = 0, l = 0L; i < x; i++) {
2387         c = (unsigned char)s[i];
2388         l |= (long)c << (i * 8);
2389     }
2390
2391     return l;
2392 }
2393
2394
2395 static int
2396 load_binintx(Unpicklerobject *self, char *s, int  x) {
2397     PyObject *py_int = 0;
2398     long l;
2399
2400     l = calc_binint(s, x);
2401
2402     UNLESS (py_int = PyInt_FromLong(l))
2403         return -1;
2404
2405     PDATA_PUSH(self->stack, py_int, -1);
2406     return 0;
2407 }
2408
2409
2410 static int
2411 load_binint(Unpicklerobject *self) {
2412     char *s;
2413
2414     if ((*self->read_func)(self, &s, 4) < 0)
2415         return -1;
2416
2417     return load_binintx(self, s, 4);
2418 }
2419
2420
2421 static int
2422 load_binint1(Unpicklerobject *self) {
2423     char *s;
2424
2425     if ((*self->read_func)(self, &s, 1) < 0)
2426         return -1;
2427
2428     return load_binintx(self, s, 1);
2429 }
2430
2431
2432 static int
2433 load_binint2(Unpicklerobject *self) {
2434     char *s;
2435
2436     if ((*self->read_func)(self, &s, 2) < 0)
2437         return -1;
2438
2439     return load_binintx(self, s, 2);
2440 }
2441
2442 static int
2443 load_long(Unpicklerobject *self) {
2444     PyObject *l = 0;
2445     char *end, *s;
2446     int len, res = -1;
2447
2448     if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
2449     if (len < 2) return bad_readline();
2450     UNLESS (s=pystrndup(s,len)) return -1;
2451
2452     UNLESS (l = PyLong_FromString(s, &end, 0))
2453         goto finally;
2454
2455     free(s);
2456     PDATA_PUSH(self->stack, l, -1);
2457     return 0;
2458
2459 finally:
2460     free(s);
2461
2462     return res;
2463 }
2464
2465
2466 static int
2467 load_float(Unpicklerobject *self) {
2468     PyObject *py_float = 0;
2469     char *endptr, *s;
2470     int len, res = -1;
2471     double d;
2472
2473     if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
2474     if (len < 2) return bad_readline();
2475     UNLESS (s=pystrndup(s,len)) return -1;
2476
2477     errno = 0;
2478     d = strtod(s, &endptr);
2479
2480     if (errno || (endptr[0] != '\n') || (endptr[1] != '\0')) {
2481         PyErr_SetString(PyExc_ValueError,
2482         "could not convert string to float");
2483         goto finally;
2484     }
2485
2486     UNLESS (py_float = PyFloat_FromDouble(d))
2487         goto finally;
2488
2489     free(s);
2490     PDATA_PUSH(self->stack, py_float, -1);
2491     return 0;
2492
2493 finally:
2494     free(s);
2495
2496     return res;
2497 }
2498
2499 static int
2500 load_binfloat(Unpicklerobject *self) {
2501     PyObject *py_float = 0;
2502     int s, e, res = -1;
2503     long fhi, flo;
2504     double x;
2505     char *p;
2506
2507     if ((*self->read_func)(self, &p, 8) < 0)
2508         return -1;
2509
2510     /* First byte */
2511     s = (*p>>7) & 1;
2512     e = (*p & 0x7F) << 4;
2513     p++;
2514
2515     /* Second byte */
2516     e |= (*p>>4) & 0xF;
2517     fhi = (*p & 0xF) << 24;
2518     p++;
2519
2520     /* Third byte */
2521     fhi |= (*p & 0xFF) << 16;
2522     p++;
2523
2524     /* Fourth byte */
2525     fhi |= (*p & 0xFF) << 8;
2526     p++;
2527
2528     /* Fifth byte */
2529     fhi |= *p & 0xFF;
2530     p++;
2531
2532     /* Sixth byte */
2533     flo = (*p & 0xFF) << 16;
2534     p++;
2535
2536     /* Seventh byte */
2537     flo |= (*p & 0xFF) << 8;
2538     p++;
2539
2540     /* Eighth byte */
2541     flo |= *p & 0xFF;
2542
2543     x = (double)fhi + (double)flo / 16777216.0; /* 2**24 */
2544     x /= 268435456.0; /* 2**28 */
2545
2546     /* XXX This sadly ignores Inf/NaN */
2547     if (e == 0)
2548         e = -1022;
2549     else {
2550         x += 1.0;
2551         e -= 1023;
2552     }
2553     x = ldexp(x, e);
2554
2555     if (s)
2556         x = -x;
2557
2558     UNLESS (py_float = PyFloat_FromDouble(x)) return -1;
2559
2560     PDATA_PUSH(self->stack, py_float, -1);
2561     return 0;
2562 }
2563
2564 static int
2565 load_string(Unpicklerobject *self) {
2566     PyObject *str = 0;
2567     int len, res = -1, nslash;
2568     char *s, q, *p;
2569
2570     static PyObject *eval_dict = 0;
2571
2572     if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
2573     if (len < 2) return bad_readline();
2574     UNLESS (s=pystrndup(s,len)) return -1;
2575
2576     /* Check for unquoted quotes (evil strings) */
2577     q=*s;
2578     if (q != '"' && q != '\'') goto insecure;
2579     for (p=s+1, nslash=0; *p; p++) {
2580         if (*p==q && nslash%2==0) break;
2581         if (*p=='\\') nslash++;
2582         else nslash=0;
2583       }
2584     if (*p==q)
2585       {
2586         for (p++; *p; p++) if (*p > ' ') goto insecure;
2587       }
2588     else goto insecure;
2589     /********************************************/
2590
2591     UNLESS (eval_dict)
2592         UNLESS (eval_dict = Py_BuildValue("{s{}}", "__builtins__"))
2593             goto finally;
2594
2595     UNLESS (str = PyRun_String(s, Py_eval_input, eval_dict, eval_dict))
2596         goto finally;
2597
2598     free(s);
2599     PDATA_PUSH(self->stack, str, -1);
2600     return 0;
2601
2602 finally:
2603     free(s);
2604
2605     return res;
2606
2607 insecure:
2608     free(s);
2609     PyErr_SetString(PyExc_ValueError,"insecure string pickle");
2610     return -1;
2611 }
2612
2613
2614 static int
2615 load_binstring(Unpicklerobject *self) {
2616     PyObject *py_string = 0;
2617     long l;
2618     int res = -1;
2619     char *s;
2620
2621     if ((*self->read_func)(self, &s, 4) < 0) return -1;
2622
2623     l = calc_binint(s, 4);
2624
2625     if ((*self->read_func)(self, &s, l) < 0)
2626         return -1;
2627
2628     UNLESS (py_string = PyString_FromStringAndSize(s, l))
2629         return -1;
2630
2631     PDATA_PUSH(self->stack, py_string, -1);
2632     return 0;
2633 }
2634
2635
2636 static int
2637 load_short_binstring(Unpicklerobject *self) {
2638     PyObject *py_string = 0;
2639     unsigned char l;
2640     int res = -1;
2641     char *s;
2642
2643     if ((*self->read_func)(self, &s, 1) < 0)
2644         return -1;
2645
2646     l = (unsigned char)s[0];
2647
2648     if ((*self->read_func)(self, &s, l) < 0) return -1;
2649
2650     UNLESS (py_string = PyString_FromStringAndSize(s, l)) return -1;
2651
2652     PDATA_PUSH(self->stack, py_string, -1);
2653     return 0;
2654 }
2655
2656
2657 static int
2658 load_tuple(Unpicklerobject *self) {
2659     PyObject *tup;
2660     int i;
2661
2662     if ((i = marker(self)) < 0) return -1;
2663     UNLESS (tup=Pdata_popTuple(self->stack, i)) return -1;
2664     PDATA_PUSH(self->stack, tup, -1);
2665     return 0;
2666 }
2667
2668 static int
2669 load_empty_tuple(Unpicklerobject *self) {
2670     PyObject *tup;
2671
2672     UNLESS (tup=PyTuple_New(0)) return -1;
2673     PDATA_PUSH(self->stack, tup, -1);
2674     return 0;
2675 }
2676
2677 static int
2678 load_empty_list(Unpicklerobject *self) {
2679     PyObject *list;
2680
2681     UNLESS (list=PyList_New(0)) return -1;
2682     PDATA_PUSH(self->stack, list, -1);
2683     return 0;
2684 }
2685
2686 static int
2687 load_empty_dict(Unpicklerobject *self) {
2688     PyObject *dict;
2689
2690     UNLESS (dict=PyDict_New()) return -1;
2691     PDATA_PUSH(self->stack, dict, -1);
2692     return 0;
2693 }
2694
2695
2696 static int
2697 load_list(Unpicklerobject *self) {
2698     PyObject *list = 0;
2699     int i;
2700
2701     if ((i = marker(self)) < 0) return -1;
2702     UNLESS (list=Pdata_popList(self->stack, i)) return -1;
2703     PDATA_PUSH(self->stack, list, -1);
2704     return 0;
2705 }
2706
2707 static int
2708 load_dict(Unpicklerobject *self) {
2709     PyObject *dict, *key, *value;
2710     int i, j, k;
2711
2712     if ((i = marker(self)) < 0) return -1;
2713     j=self->stack->length;
2714
2715     UNLESS (dict = PyDict_New()) return -1;
2716
2717     for (k = i+1; k < j; k += 2) {
2718         key  =self->stack->data[k-1];
2719         value=self->stack->data[k  ];
2720         if (PyDict_SetItem(dict, key, value) < 0) {
2721             Py_DECREF(dict);
2722             return -1;
2723         }
2724     }
2725     Pdata_clear(self->stack, i);
2726     PDATA_PUSH(self->stack, dict, -1);
2727     return 0;
2728 }
2729
2730 static PyObject *
2731 Instance_New(PyObject *cls, PyObject *args) {
2732   int has_key;
2733   PyObject *safe=0, *r=0;
2734
2735   if (PyClass_Check(cls)) {
2736       int l;
2737
2738       if ((l=PyObject_Length(args)) < 0) goto err;
2739       UNLESS (l) {
2740           PyObject *__getinitargs__;
2741
2742           UNLESS (__getinitargs__=PyObject_GetAttr(cls, __getinitargs___str)) {
2743               /* We have a class with no __getinitargs__, so bypass usual
2744                  construction  */
2745               PyInstanceObject *inst;
2746
2747               PyErr_Clear();
2748               UNLESS (inst=PyObject_NEW(PyInstanceObject, &PyInstance_Type))
2749                 goto err;
2750               inst->in_class=(PyClassObject*)cls;
2751               Py_INCREF(cls);
2752               UNLESS (inst->in_dict=PyDict_New()) {
2753                 Py_DECREF(inst);
2754                 goto err;
2755               }
2756
2757               return (PyObject *)inst;
2758             }
2759           Py_DECREF(__getinitargs__);
2760         }
2761
2762       if ((r=PyInstance_New(cls, args, NULL))) return r;
2763       else goto err;
2764     }
2765
2766
2767   if ((has_key = cPickle_PyMapping_HasKey(safe_constructors, cls)) < 0)
2768     goto err;
2769
2770   if (!has_key)
2771     if (!(safe = PyObject_GetAttr(cls, __safe_for_unpickling___str)) ||
2772        !PyObject_IsTrue(safe)) {
2773       cPickle_ErrFormat(UnpicklingError,
2774                         "%s is not safe for unpickling", "O", cls);
2775       Py_XDECREF(safe);
2776       return NULL;
2777   }
2778
2779   if (args==Py_None) {
2780       /* Special case, call cls.__basicnew__() */
2781       PyObject *basicnew;
2782
2783       UNLESS (basicnew=PyObject_GetAttr(cls, __basicnew___str)) return NULL;
2784       r=PyObject_CallObject(basicnew, NULL);
2785       Py_DECREF(basicnew);
2786       if (r) return r;
2787     }
2788
2789   if ((r=PyObject_CallObject(cls, args))) return r;
2790
2791 err:
2792   {
2793     PyObject *tp, *v, *tb;
2794
2795     PyErr_Fetch(&tp, &v, &tb);
2796     if ((r=Py_BuildValue("OOO",v,cls,args))) {
2797         Py_XDECREF(v);
2798         v=r;
2799       }
2800     PyErr_Restore(tp,v,tb);
2801   }
2802   return NULL;
2803 }
2804
2805
2806 static int
2807 load_obj(Unpicklerobject *self) {
2808     PyObject *class, *tup, *obj=0;
2809     int i;
2810
2811     if ((i = marker(self)) < 0) return -1;
2812     UNLESS (tup=Pdata_popTuple(self->stack, i+1)) return -1;
2813     PDATA_POP(self->stack, class);
2814     if (class) {
2815         obj = Instance_New(class, tup);
2816         Py_DECREF(class);
2817     }
2818     Py_DECREF(tup);
2819
2820     if (! obj) return -1;
2821     PDATA_PUSH(self->stack, obj, -1);
2822     return 0;
2823 }
2824
2825
2826 static int
2827 load_inst(Unpicklerobject *self) {
2828     PyObject *tup, *class, *obj, *module_name, *class_name;
2829     int i, len;
2830     char *s;
2831
2832     if ((i = marker(self)) < 0) return -1;
2833
2834     if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
2835     if (len < 2) return bad_readline();
2836     UNLESS (module_name = PyString_FromStringAndSize(s, len - 1)) return -1;
2837
2838     if ((len = (*self->readline_func)(self, &s)) >= 0) {
2839         if (len < 2) return bad_readline();
2840         if (class_name = PyString_FromStringAndSize(s, len - 1)) {
2841             class = find_class(module_name, class_name);
2842             Py_DECREF(class_name);
2843         }
2844     }
2845     Py_DECREF(module_name);
2846
2847     if (! class) return -1;
2848
2849     if (tup=Pdata_popTuple(self->stack, i)) {
2850         obj = Instance_New(class, tup);
2851         Py_DECREF(tup);
2852     }
2853     Py_DECREF(class);
2854
2855     if (! obj) return -1;
2856
2857     PDATA_PUSH(self->stack, obj, -1);
2858     return 0;
2859 }
2860
2861
2862 static int
2863 load_global(Unpicklerobject *self) {
2864     PyObject *class = 0, *module_name = 0, *class_name = 0;
2865     int len;
2866     char *s;
2867
2868     if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
2869     if (len < 2) return bad_readline();
2870     UNLESS (module_name = PyString_FromStringAndSize(s, len - 1)) return -1;
2871
2872     if ((len = (*self->readline_func)(self, &s)) >= 0) {
2873         if (len < 2) return bad_readline();
2874         if (class_name = PyString_FromStringAndSize(s, len - 1)) {
2875             class = find_class(module_name, class_name);
2876             Py_DECREF(class_name);
2877         }
2878     }
2879     Py_DECREF(module_name);
2880
2881     if (! class) return -1;
2882     PDATA_PUSH(self->stack, class, -1);
2883     return 0;
2884 }
2885
2886
2887 static int
2888 load_persid(Unpicklerobject *self) {
2889     PyObject *pid = 0;
2890     int len, res = -1;
2891     char *s;
2892
2893     if (self->pers_func) {
2894         if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
2895         if (len < 2) return bad_readline();
2896
2897         UNLESS (pid = PyString_FromStringAndSize(s, len - 1)) return -1;
2898
2899         if (PyList_Check(self->pers_func)) {
2900             if (PyList_Append(self->pers_func, pid) < 0) {
2901                 Py_DECREF(pid);
2902                 return -1;
2903             }
2904         }
2905         else {
2906             ARG_TUP(self, pid);
2907             if (self->arg) {
2908                 pid = PyObject_CallObject(self->pers_func, self->arg);
2909                 FREE_ARG_TUP(self);
2910             }
2911         }
2912
2913         if (! pid) return -1;
2914
2915         PDATA_PUSH(self->stack, pid, -1);
2916         return 0;
2917     }
2918     else {
2919       PyErr_SetString(UnpicklingError,
2920                       "A load persistent id instruction was encountered,\n"
2921                       "but no persistent_load function was specified.");
2922       return -1;
2923     }
2924 }
2925
2926 static int
2927 load_binpersid(Unpicklerobject *self) {
2928     PyObject *pid = 0;
2929     int res = -1;
2930
2931     if (self->pers_func) {
2932         PDATA_POP(self->stack, pid);
2933         if (! pid) return -1;
2934
2935         if (PyList_Check(self->pers_func)) {
2936             if (PyList_Append(self->pers_func, pid) < 0) {
2937                 Py_DECREF(pid);
2938                 return -1;
2939             }
2940           }
2941         else {
2942             ARG_TUP(self, pid);
2943             if (self->arg) {
2944                 pid = PyObject_CallObject(self->pers_func, self->arg);
2945                 FREE_ARG_TUP(self);
2946             }
2947             if (! pid) return -1;
2948         }
2949
2950         PDATA_PUSH(self->stack, pid, -1);
2951         return 0;
2952     }
2953     else {
2954       PyErr_SetString(UnpicklingError,
2955                       "A load persistent id instruction was encountered,\n"
2956                       "but no persistent_load function was specified.");
2957       return -1;
2958     }
2959 }
2960
2961
2962 static int
2963 load_pop(Unpicklerobject *self) {
2964     int len;
2965
2966     UNLESS ((len=self->stack->length) > 0) return stackUnderflow();
2967
2968     if ((self->num_marks > 0) &&
2969         (self->marks[self->num_marks - 1] == len))
2970         self->num_marks--;
2971     else
2972         Py_DECREF(self->stack->data[--(self->stack->length)]);
2973
2974     return 0;
2975 }
2976
2977
2978 static int
2979 load_pop_mark(Unpicklerobject *self) {
2980     int i;
2981
2982     if ((i = marker(self)) < 0)
2983         return -1;
2984
2985     Pdata_clear(self->stack, i);
2986
2987     return 0;
2988 }
2989
2990
2991 static int
2992 load_dup(Unpicklerobject *self) {
2993     PyObject *last;
2994     int len;
2995
2996     if ((len = self->stack->length) <= 0) return stackUnderflow();
2997     last=self->stack->data[len-1];
2998     Py_INCREF(last);
2999     PDATA_PUSH(self->stack, last, -1);
3000     return 0;
3001 }
3002
3003
3004 static int
3005 load_get(Unpicklerobject *self) {
3006     PyObject *py_str = 0, *value = 0;
3007     int len, res = -1;
3008     char *s;
3009
3010     if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
3011     if (len < 2) return bad_readline();
3012
3013     UNLESS (py_str = PyString_FromStringAndSize(s, len - 1)) return -1;
3014
3015     value = PyDict_GetItem(self->memo, py_str);
3016     Py_DECREF(py_str);
3017     if (! value) {
3018         PyErr_SetObject(BadPickleGet, py_str);
3019         return -1;
3020       }
3021
3022     PDATA_APPEND(self->stack, value, -1);
3023     return 0;
3024 }
3025
3026
3027 static int
3028 load_binget(Unpicklerobject *self) {
3029     PyObject *py_key = 0, *value = 0;
3030     unsigned char key;
3031     int res = -1;
3032     char *s;
3033
3034     if ((*self->read_func)(self, &s, 1) < 0) return -1;
3035
3036     key = (unsigned char)s[0];
3037     UNLESS (py_key = PyInt_FromLong((long)key)) return -1;
3038
3039     value = PyDict_GetItem(self->memo, py_key);
3040     Py_DECREF(py_key);
3041     if (! value) {
3042         PyErr_SetObject(BadPickleGet, py_key);
3043         return -1;
3044       }
3045
3046     PDATA_APPEND(self->stack, value, -1);
3047     return 0;
3048 }
3049
3050
3051 static int
3052 load_long_binget(Unpicklerobject *self) {
3053     PyObject *py_key = 0, *value = 0;
3054     unsigned char c, *s;
3055     long key;
3056     int res = -1;
3057
3058     if ((*self->read_func)(self, &s, 4) < 0) return -1;
3059
3060     c = (unsigned char)s[0];
3061     key = (long)c;
3062     c = (unsigned char)s[1];
3063     key |= (long)c << 8;
3064     c = (unsigned char)s[2];
3065     key |= (long)c << 16;
3066     c = (unsigned char)s[3];
3067     key |= (long)c << 24;
3068
3069     UNLESS (py_key = PyInt_FromLong((long)key)) return -1;
3070
3071     value = PyDict_GetItem(self->memo, py_key);
3072     Py_DECREF(py_key);
3073     if (! value) {
3074         PyErr_SetObject(BadPickleGet, py_key);
3075         return -1;
3076       }
3077
3078     PDATA_APPEND(self->stack, value, -1);
3079     return 0;
3080 }
3081
3082
3083 static int
3084 load_put(Unpicklerobject *self) {
3085     PyObject *py_str = 0, *value = 0;
3086     int len, l;
3087     char *s;
3088
3089     if ((l = (*self->readline_func)(self, &s)) < 0) return -1;
3090     if (l < 2) return bad_readline();
3091     UNLESS (len=self->stack->length) return stackUnderflow();
3092     UNLESS (py_str = PyString_FromStringAndSize(s, l - 1)) return -1;
3093     value=self->stack->data[len-1];
3094     l=PyDict_SetItem(self->memo, py_str, value);
3095     Py_DECREF(py_str);
3096     return l;
3097 }
3098
3099
3100 static int
3101 load_binput(Unpicklerobject *self) {
3102     PyObject *py_key = 0, *value = 0;
3103     unsigned char key, *s;
3104     int len;
3105
3106     if ((*self->read_func)(self, &s, 1) < 0) return -1;
3107     UNLESS ((len=self->stack->length) > 0) return stackUnderflow();
3108
3109     key = (unsigned char)s[0];
3110
3111     UNLESS (py_key = PyInt_FromLong((long)key)) return -1;
3112     value=self->stack->data[len-1];
3113     len=PyDict_SetItem(self->memo, py_key, value);
3114     Py_DECREF(py_key);
3115     return len;
3116 }
3117
3118
3119 static int
3120 load_long_binput(Unpicklerobject *self) {
3121     PyObject *py_key = 0, *value = 0;
3122     long key;
3123     unsigned char c, *s;
3124     int len, res = -1;
3125
3126     if ((*self->read_func)(self, &s, 4) < 0) return -1;
3127     UNLESS (len=self->stack->length) return stackUnderflow();
3128
3129     c = (unsigned char)s[0];
3130     key = (long)c;
3131     c = (unsigned char)s[1];
3132     key |= (long)c << 8;
3133     c = (unsigned char)s[2];
3134     key |= (long)c << 16;
3135     c = (unsigned char)s[3];
3136     key |= (long)c << 24;
3137
3138     UNLESS (py_key = PyInt_FromLong(key)) return -1;
3139     value=self->stack->data[len-1];
3140     len=PyDict_SetItem(self->memo, py_key, value);
3141     Py_DECREF(py_key);
3142     return len;
3143 }
3144
3145
3146 static int
3147 do_append(Unpicklerobject *self, int  x) {
3148     PyObject *value = 0, *list = 0, *append_method = 0;
3149     int len, i;
3150
3151     UNLESS ((len=self->stack->length) >= x && x > 0) return stackUnderflow();
3152     if (len==x) return 0;       /* nothing to do */
3153
3154     list=self->stack->data[x-1];
3155
3156     if (PyList_Check(list)) {
3157         PyObject *slice;
3158         int list_len;
3159
3160         slice=Pdata_popList(self->stack, x);
3161         list_len = PyList_GET_SIZE(list);
3162         i=PyList_SetSlice(list, list_len, list_len, slice);
3163         Py_DECREF(slice);
3164         return i;
3165     }
3166     else {
3167
3168         UNLESS (append_method = PyObject_GetAttr(list, append_str))
3169             return -1;
3170
3171         for (i = x; i < len; i++) {
3172             PyObject *junk;
3173
3174             value=self->stack->data[i];
3175             junk=0;
3176             ARG_TUP(self, value);
3177             if (self->arg) {
3178               junk = PyObject_CallObject(append_method, self->arg);
3179               FREE_ARG_TUP(self);
3180             }
3181             if (! junk) {
3182                 Pdata_clear(self->stack, i+1);
3183                 self->stack->length=x;
3184                 Py_DECREF(append_method);
3185                 return -1;
3186             }
3187             Py_DECREF(junk);
3188         }
3189         self->stack->length=x;
3190         Py_DECREF(append_method);
3191     }
3192
3193     return 0;
3194 }
3195
3196
3197 static int
3198 load_append(Unpicklerobject *self) {
3199     return do_append(self, self->stack->length - 1);
3200 }
3201
3202
3203 static int
3204 load_appends(Unpicklerobject *self) {
3205     return do_append(self, marker(self));
3206 }
3207
3208
3209 static int
3210 do_setitems(Unpicklerobject *self, int  x) {
3211     PyObject *value = 0, *key = 0, *dict = 0;
3212     int len, i, r=0;
3213
3214     UNLESS ((len=self->stack->length) >= x
3215             && x > 0) return stackUnderflow();
3216
3217     dict=self->stack->data[x-1];
3218
3219     for (i = x+1; i < len; i += 2) {
3220         key  =self->stack->data[i-1];
3221         value=self->stack->data[i  ];
3222         if (PyObject_SetItem(dict, key, value) < 0) {
3223             r=-1;
3224             break;
3225         }
3226     }
3227
3228     Pdata_clear(self->stack, x);
3229
3230     return r;
3231 }
3232
3233
3234 static int
3235 load_setitem(Unpicklerobject *self) {
3236     return do_setitems(self, self->stack->length - 2);
3237 }
3238
3239 static int
3240 load_setitems(Unpicklerobject *self) {
3241     return do_setitems(self, marker(self));
3242 }
3243
3244
3245 static int
3246 load_build(Unpicklerobject *self) {
3247     PyObject *value = 0, *inst = 0, *instdict = 0, *d_key = 0, *d_value = 0,
3248              *junk = 0, *__setstate__ = 0;
3249     int i, r = 0;
3250
3251     if (self->stack->length < 2) return stackUnderflow();
3252     PDATA_POP(self->stack, value);
3253     if (! value) return -1;
3254     inst=self->stack->data[self->stack->length-1];
3255
3256     if ((__setstate__ = PyObject_GetAttr(inst, __setstate___str))) {
3257         ARG_TUP(self, value);
3258         if (self->arg) {
3259             junk = PyObject_CallObject(__setstate__, self->arg);
3260             FREE_ARG_TUP(self);
3261         }
3262         Py_DECREF(__setstate__);
3263         if (! junk) return -1;
3264         Py_DECREF(junk);
3265         return 0;
3266     }
3267
3268     PyErr_Clear();
3269     if ((instdict = PyObject_GetAttr(inst, __dict___str))) {
3270         i = 0;
3271         while (PyDict_Next(value, &i, &d_key, &d_value)) {
3272             if (PyObject_SetItem(instdict, d_key, d_value) < 0) {
3273                 r=-1;
3274                 break;
3275             }
3276         }
3277         Py_DECREF(instdict);
3278     }
3279     else r=-1;
3280
3281     Py_XDECREF(value);
3282
3283     return r;
3284 }
3285
3286
3287 static int
3288 load_mark(Unpicklerobject *self) {
3289     int s;
3290
3291     if ((self->num_marks + 1) >= self->marks_size) {
3292         s=self->marks_size+20;
3293         if (s <= self->num_marks) s=self->num_marks + 1;
3294         if (self->marks)
3295             self->marks=(int *)malloc(s * sizeof(int));
3296         else
3297             self->marks=(int *)realloc(self->marks, s * sizeof(int));
3298         if (! self->marks) {
3299             PyErr_NoMemory();
3300             return -1;
3301         }
3302         self->marks_size = s;
3303     }
3304
3305     self->marks[self->num_marks++] = self->stack->length;
3306
3307     return 0;
3308 }
3309
3310 static int
3311 load_reduce(Unpicklerobject *self) {
3312     PyObject *callable = 0, *arg_tup = 0, *ob = 0;
3313
3314     PDATA_POP(self->stack, arg_tup);
3315     if (! arg_tup) return -1;
3316     PDATA_POP(self->stack, callable);
3317     if (callable) {
3318         ob = Instance_New(callable, arg_tup);
3319         Py_DECREF(callable);
3320     }
3321     Py_DECREF(arg_tup);
3322
3323     if (! ob) return -1;
3324
3325     PDATA_PUSH(self->stack, ob, -1);
3326     return 0;
3327 }
3328
3329 static PyObject *
3330 load(Unpicklerobject *self) {
3331     PyObject *stack = 0, *err = 0, *val = 0;
3332     char *s;
3333
3334     self->num_marks = 0;
3335     if (self->stack->length) Pdata_clear(self->stack, 0);
3336
3337     while (1) {
3338         if ((*self->read_func)(self, &s, 1) < 0)
3339             break;
3340
3341         switch (s[0]) {
3342             case NONE:
3343                 if (load_none(self) < 0)
3344                     break;
3345                 continue;
3346
3347             case BININT:
3348                  if (load_binint(self) < 0)
3349                      break;
3350                  continue;
3351
3352             case BININT1:
3353                 if (load_binint1(self) < 0)
3354                     break;
3355                 continue;
3356
3357             case BININT2:
3358                 if (load_binint2(self) < 0)
3359                     break;
3360                 continue;
3361
3362             case INT:
3363                 if (load_int(self) < 0)
3364                     break;
3365                 continue;
3366
3367             case LONG:
3368                 if (load_long(self) < 0)
3369                     break;
3370                 continue;
3371
3372             case FLOAT:
3373                 if (load_float(self) < 0)
3374                     break;
3375                 continue;
3376
3377             case BINFLOAT:
3378                 if (load_binfloat(self) < 0)
3379                     break;
3380                 continue;
3381
3382             case BINSTRING:
3383                 if (load_binstring(self) < 0)
3384                     break;
3385                 continue;
3386
3387             case SHORT_BINSTRING:
3388                 if (load_short_binstring(self) < 0)
3389                     break;
3390                 continue;
3391
3392             case STRING:
3393                 if (load_string(self) < 0)
3394                     break;
3395                 continue;
3396
3397             case EMPTY_TUPLE:
3398                 if (load_empty_tuple(self) < 0)
3399                     break;
3400                 continue;
3401
3402             case TUPLE:
3403                 if (load_tuple(self) < 0)
3404                     break;
3405                 continue;
3406
3407             case EMPTY_LIST:
3408                 if (load_empty_list(self) < 0)
3409                     break;
3410                 continue;
3411
3412             case LIST:
3413                 if (load_list(self) < 0)
3414                     break;
3415                 continue;
3416
3417             case EMPTY_DICT:
3418                 if (load_empty_dict(self) < 0)
3419                     break;
3420                 continue;
3421
3422             case DICT:
3423                 if (load_dict(self) < 0)
3424                     break;
3425                 continue;
3426
3427             case OBJ:
3428                 if (load_obj(self) < 0)
3429                     break;
3430                 continue;
3431
3432             case INST:
3433                 if (load_inst(self) < 0)
3434                     break;
3435                 continue;
3436
3437             case GLOBAL:
3438                 if (load_global(self) < 0)
3439                     break;
3440                 continue;
3441
3442             case APPEND:
3443                 if (load_append(self) < 0)
3444                     break;
3445                 continue;
3446
3447             case APPENDS:
3448                 if (load_appends(self) < 0)
3449                     break;
3450                 continue;
3451
3452             case BUILD:
3453                 if (load_build(self) < 0)
3454                     break;
3455                 continue;
3456
3457             case DUP:
3458                 if (load_dup(self) < 0)
3459                     break;
3460                 continue;
3461
3462             case BINGET:
3463                 if (load_binget(self) < 0)
3464                     break;
3465                 continue;
3466
3467             case LONG_BINGET:
3468                 if (load_long_binget(self) < 0)
3469                     break;
3470                 continue;
3471
3472             case GET:
3473                 if (load_get(self) < 0)
3474                     break;
3475                 continue;
3476
3477             case MARK:
3478                 if (load_mark(self) < 0)
3479                     break;
3480                 continue;
3481
3482             case BINPUT:
3483                 if (load_binput(self) < 0)
3484                     break;
3485                 continue;
3486
3487             case LONG_BINPUT:
3488                 if (load_long_binput(self) < 0)
3489                     break;
3490                 continue;
3491
3492             case PUT:
3493                 if (load_put(self) < 0)
3494                     break;
3495                 continue;
3496
3497             case POP:
3498                 if (load_pop(self) < 0)
3499                     break;
3500                 continue;
3501
3502             case POP_MARK:
3503                 if (load_pop_mark(self) < 0)
3504                     break;
3505                 continue;
3506
3507             case SETITEM:
3508                 if (load_setitem(self) < 0)
3509                     break;
3510                 continue;
3511
3512             case SETITEMS:
3513                 if (load_setitems(self) < 0)
3514                     break;
3515                 continue;
3516
3517             case STOP:
3518                 break;
3519
3520             case PERSID:
3521                 if (load_persid(self) < 0)
3522                     break;
3523                 continue;
3524
3525             case BINPERSID:
3526                 if (load_binpersid(self) < 0)
3527                     break;
3528                 continue;
3529
3530             case REDUCE:
3531                 if (load_reduce(self) < 0)
3532                     break;
3533                 continue;
3534
3535             default:
3536                 cPickle_ErrFormat(UnpicklingError, "invalid load key, '%s'.",
3537                     "c", s[0]);
3538                 return NULL;
3539         }
3540
3541         break;
3542     }
3543
3544     if ((err = PyErr_Occurred())) {
3545         if (err == PyExc_EOFError) {
3546             PyErr_SetNone(PyExc_EOFError);
3547         }
3548         return NULL;
3549     }
3550
3551     PDATA_POP(self->stack, val);
3552     return val;
3553 }
3554
3555
3556 /* No-load functions to support noload, which is used to
3557    find persistent references. */
3558
3559 static int
3560 noload_obj(Unpicklerobject *self) {
3561     int i;
3562
3563     if ((i = marker(self)) < 0) return -1;
3564     return Pdata_clear(self->stack, i+1);
3565 }
3566
3567
3568 static int
3569 noload_inst(Unpicklerobject *self) {
3570     int i;
3571     char *s;
3572
3573     if ((i = marker(self)) < 0) return -1;
3574     Pdata_clear(self->stack, i);
3575     if ((*self->readline_func)(self, &s) < 0) return -1;
3576     if ((*self->readline_func)(self, &s) < 0) return -1;
3577     PDATA_APPEND(self->stack, Py_None,-1);
3578     return 0;
3579 }
3580
3581 static int
3582 noload_global(Unpicklerobject *self) {
3583     char *s;
3584
3585     if ((*self->readline_func)(self, &s) < 0) return -1;
3586     if ((*self->readline_func)(self, &s) < 0) return -1;
3587     PDATA_APPEND(self->stack, Py_None,-1);
3588     return 0;
3589 }
3590
3591 static int
3592 noload_reduce(Unpicklerobject *self) {
3593
3594     if (self->stack->length < 2) return stackUnderflow();
3595     Pdata_clear(self->stack, self->stack->length-2);
3596     PDATA_APPEND(self->stack, Py_None,-1);
3597     return 0;
3598 }
3599
3600 static int
3601 noload_build(Unpicklerobject *self) {
3602
3603   if (self->stack->length < 1) return stackUnderflow();
3604   Pdata_clear(self->stack, self->stack->length-1);
3605   return 0;
3606 }
3607
3608
3609 static PyObject *
3610 noload(Unpicklerobject *self) {
3611     PyObject *stack = 0, *err = 0, *val = 0;
3612     char *s;
3613
3614     self->num_marks = 0;
3615     Pdata_clear(self->stack, 0);
3616
3617     while (1) {
3618         if ((*self->read_func)(self, &s, 1) < 0)
3619             break;
3620
3621         switch (s[0]) {
3622             case NONE:
3623                 if (load_none(self) < 0)
3624                     break;
3625                 continue;
3626
3627             case BININT:
3628                  if (load_binint(self) < 0)
3629                      break;
3630                  continue;
3631
3632             case BININT1:
3633                 if (load_binint1(self) < 0)
3634                     break;
3635                 continue;
3636
3637             case BININT2:
3638                 if (load_binint2(self) < 0)
3639                     break;
3640                 continue;
3641
3642             case INT:
3643                 if (load_int(self) < 0)
3644                     break;
3645                 continue;
3646
3647             case LONG:
3648                 if (load_long(self) < 0)
3649                     break;
3650                 continue;
3651
3652             case FLOAT:
3653                 if (load_float(self) < 0)
3654                     break;
3655                 continue;
3656
3657             case BINFLOAT:
3658                 if (load_binfloat(self) < 0)
3659                     break;
3660                 continue;
3661
3662             case BINSTRING:
3663                 if (load_binstring(self) < 0)
3664                     break;
3665                 continue;
3666
3667             case SHORT_BINSTRING:
3668                 if (load_short_binstring(self) < 0)
3669                     break;
3670                 continue;
3671
3672             case STRING:
3673                 if (load_string(self) < 0)
3674                     break;
3675                 continue;
3676
3677             case EMPTY_TUPLE:
3678                 if (load_empty_tuple(self) < 0)
3679                     break;
3680                 continue;
3681
3682             case TUPLE:
3683                 if (load_tuple(self) < 0)
3684                     break;
3685                 continue;
3686
3687             case EMPTY_LIST:
3688                 if (load_empty_list(self) < 0)
3689                     break;
3690                 continue;
3691
3692             case LIST:
3693                 if (load_list(self) < 0)
3694                     break;
3695                 continue;
3696
3697             case EMPTY_DICT:
3698                 if (load_empty_dict(self) < 0)
3699                     break;
3700                 continue;
3701
3702             case DICT:
3703                 if (load_dict(self) < 0)
3704                     break;
3705                 continue;
3706
3707             case OBJ:
3708                 if (noload_obj(self) < 0)
3709                     break;
3710                 continue;
3711
3712             case INST:
3713                 if (noload_inst(self) < 0)
3714                     break;
3715                 continue;
3716
3717             case GLOBAL:
3718                 if (noload_global(self) < 0)
3719                     break;
3720                 continue;
3721
3722             case APPEND:
3723                 if (load_append(self) < 0)
3724                     break;
3725                 continue;
3726
3727             case APPENDS:
3728                 if (load_appends(self) < 0)
3729                     break;
3730                 continue;
3731
3732             case BUILD:
3733                 if (noload_build(self) < 0)
3734                     break;
3735                 continue;
3736
3737             case DUP:
3738                 if (load_dup(self) < 0)
3739                     break;
3740                 continue;
3741
3742             case BINGET:
3743                 if (load_binget(self) < 0)
3744                     break;
3745                 continue;
3746
3747             case LONG_BINGET:
3748                 if (load_long_binget(self) < 0)
3749                     break;
3750                 continue;
3751
3752             case GET:
3753                 if (load_get(self) < 0)
3754                     break;
3755                 continue;
3756
3757             case MARK:
3758                 if (load_mark(self) < 0)
3759                     break;
3760                 continue;
3761
3762             case BINPUT:
3763                 if (load_binput(self) < 0)
3764                     break;
3765                 continue;
3766
3767             case LONG_BINPUT:
3768                 if (load_long_binput(self) < 0)
3769                     break;
3770                 continue;
3771
3772             case PUT:
3773                 if (load_put(self) < 0)
3774                     break;
3775                 continue;
3776
3777             case POP:
3778                 if (load_pop(self) < 0)
3779                     break;
3780                 continue;
3781
3782             case POP_MARK:
3783                 if (load_pop_mark(self) < 0)
3784                     break;
3785                 continue;
3786
3787             case SETITEM:
3788                 if (load_setitem(self) < 0)
3789                     break;
3790                 continue;
3791
3792             case SETITEMS:
3793                 if (load_setitems(self) < 0)
3794                     break;
3795                 continue;
3796
3797             case STOP:
3798                 break;
3799
3800             case PERSID:
3801                 if (load_persid(self) < 0)
3802                     break;
3803                 continue;
3804
3805             case BINPERSID:
3806                 if (load_binpersid(self) < 0)
3807                     break;
3808                 continue;
3809
3810             case REDUCE:
3811                 if (noload_reduce(self) < 0)
3812                     break;
3813                 continue;
3814
3815             default:
3816                 cPickle_ErrFormat(UnpicklingError, "invalid load key, '%s'.",
3817                     "c", s[0]);
3818                 return NULL;
3819         }
3820
3821         break;
3822     }
3823
3824     if ((err = PyErr_Occurred())) {
3825         if (err == PyExc_EOFError) {
3826             PyErr_SetNone(PyExc_EOFError);
3827         }
3828         return NULL;
3829     }
3830
3831     PDATA_POP(self->stack, val);
3832     return val;
3833 }
3834
3835
3836 static PyObject *
3837 Unpickler_load(Unpicklerobject *self, PyObject *args) {
3838     UNLESS (PyArg_ParseTuple(args, ""))
3839         return NULL;
3840
3841     return load(self);
3842 }
3843
3844 static PyObject *
3845 Unpickler_noload(Unpicklerobject *self, PyObject *args) {
3846     UNLESS (PyArg_ParseTuple(args, ""))
3847         return NULL;
3848
3849     return noload(self);
3850 }
3851
3852
3853 static struct PyMethodDef Unpickler_methods[] = {
3854   {"load",         (PyCFunction)Unpickler_load,   1,
3855    "load() -- Load a pickle"
3856   },
3857   {"noload",         (PyCFunction)Unpickler_noload,   1,
3858    "noload() -- not load a pickle, but go through most of the motions\n"
3859    "\n"
3860    "This function can be used to read past a pickle without instantiating\n"
3861    "any objects or importing any modules.  It can also be used to find all\n"
3862    "persistent references without instantiating any objects or importing\n"
3863    "any modules.\n"
3864   },
3865   {NULL,              NULL}           /* sentinel */
3866 };
3867
3868
3869 static Unpicklerobject *
3870 newUnpicklerobject(PyObject *f) {
3871     Unpicklerobject *self;
3872
3873     UNLESS (self = PyObject_NEW(Unpicklerobject, &Unpicklertype))
3874         return NULL;
3875
3876     self->file = NULL;
3877     self->arg = NULL;
3878     self->stack = (Pdata*)Pdata_New();
3879     self->pers_func = NULL;
3880     self->last_string = NULL;
3881     self->marks = NULL;
3882     self->num_marks = 0;
3883     self->marks_size = 0;
3884     self->buf_size = 0;
3885     self->read = NULL;
3886     self->readline = NULL;
3887     self->safe_constructors = NULL;
3888
3889     UNLESS (self->memo = PyDict_New()) {
3890        Py_XDECREF((PyObject *)self);
3891        return NULL;
3892     }
3893
3894     Py_INCREF(f);
3895     self->file = f;
3896
3897     /* Set read, readline based on type of f */
3898     if (PyFile_Check(f)) {
3899         self->fp = PyFile_AsFile(f);
3900         self->read_func = read_file;
3901         self->readline_func = readline_file;
3902     }
3903     else if (PycStringIO_InputCheck(f)) {
3904         self->fp = NULL;
3905         self->read_func = read_cStringIO;
3906         self->readline_func = readline_cStringIO;
3907     }
3908     else {
3909
3910         self->fp = NULL;
3911         self->read_func = read_other;
3912         self->readline_func = readline_other;
3913
3914         UNLESS ((self->readline = PyObject_GetAttr(f, readline_str)) &&
3915             (self->read = PyObject_GetAttr(f, read_str))) {
3916             PyErr_Clear();
3917             PyErr_SetString( PyExc_TypeError, "argument must have 'read' and "
3918                 "'readline' attributes" );
3919             goto err;
3920         }
3921     }
3922
3923     if (PyEval_GetRestricted()) {
3924         /* Restricted execution, get private tables */
3925         PyObject *m;
3926
3927         UNLESS (m=PyImport_Import(copy_reg_str)) goto err;
3928         self->safe_constructors=PyObject_GetAttr(m, safe_constructors_str);
3929         Py_DECREF(m);
3930         UNLESS (self->safe_constructors) goto err;
3931     }
3932     else {
3933         self->safe_constructors=safe_constructors;
3934         Py_INCREF(safe_constructors);
3935     }
3936
3937     return self;
3938
3939 err:
3940     Py_DECREF((PyObject *)self);
3941     return NULL;
3942 }
3943
3944
3945 static PyObject *
3946 get_Unpickler(PyObject *self, PyObject *args) {
3947     PyObject *file;
3948
3949     UNLESS (PyArg_ParseTuple(args, "O", &file))
3950         return NULL;
3951     return (PyObject *)newUnpicklerobject(file);
3952 }
3953
3954
3955 static void
3956 Unpickler_dealloc(Unpicklerobject *self) {
3957     Py_XDECREF(self->readline);
3958     Py_XDECREF(self->read);
3959     Py_XDECREF(self->file);
3960     Py_XDECREF(self->memo);
3961     Py_XDECREF(self->stack);
3962     Py_XDECREF(self->pers_func);
3963     Py_XDECREF(self->arg);
3964     Py_XDECREF(self->last_string);
3965     Py_XDECREF(self->safe_constructors);
3966
3967     if (self->marks) {
3968         free(self->marks);
3969     }
3970
3971     if (self->buf_size) {
3972         free(self->buf);
3973     }
3974
3975     PyMem_DEL(self);
3976 }
3977
3978
3979 static PyObject *
3980 Unpickler_getattr(Unpicklerobject *self, char *name) {
3981     if (!strcmp(name, "persistent_load")) {
3982         if (!self->pers_func) {
3983             PyErr_SetString(PyExc_AttributeError, name);
3984             return NULL;
3985         }
3986
3987         Py_INCREF(self->pers_func);
3988         return self->pers_func;
3989     }
3990
3991     if (!strcmp(name, "memo")) {
3992         if (!self->memo) {
3993             PyErr_SetString(PyExc_AttributeError, name);
3994             return NULL;
3995         }
3996
3997         Py_INCREF(self->memo);
3998         return self->memo;
3999     }
4000
4001     if (!strcmp(name, "UnpicklingError")) {
4002         Py_INCREF(UnpicklingError);
4003         return UnpicklingError;
4004     }
4005
4006     return Py_FindMethod(Unpickler_methods, (PyObject *)self, name);
4007 }
4008
4009
4010 static int
4011 Unpickler_setattr(Unpicklerobject *self, char *name, PyObject *value) {
4012
4013     if (! value) {
4014         PyErr_SetString(PyExc_TypeError,
4015                         "attribute deletion is not supported");
4016         return -1;
4017     }
4018
4019     if (!strcmp(name, "persistent_load")) {
4020         Py_XDECREF(self->pers_func);
4021         self->pers_func = value;
4022         Py_INCREF(value);
4023         return 0;
4024     }
4025
4026     if (strcmp(name, "memo") == 0) {
4027         if (! PyDict_Check(value)) {
4028           PyErr_SetString(PyExc_TypeError, "memo must be a dictionary");
4029           return -1;
4030         }
4031         Py_XDECREF(self->memo);
4032         self->memo = value;
4033         Py_INCREF(value);
4034         return 0;
4035     }
4036
4037     PyErr_SetString(PyExc_AttributeError, name);
4038     return -1;
4039 }
4040
4041
4042 static PyObject *
4043 cpm_dump(PyObject *self, PyObject *args) {
4044     PyObject *ob, *file, *res = NULL;
4045     Picklerobject *pickler = 0;
4046     int bin = 0;
4047
4048     UNLESS (PyArg_ParseTuple(args, "OO|i", &ob, &file, &bin))
4049         goto finally;
4050
4051     UNLESS (pickler = newPicklerobject(file, bin))
4052         goto finally;
4053
4054     if (dump(pickler, ob) < 0)
4055         goto finally;
4056
4057     Py_INCREF(Py_None);
4058     res = Py_None;
4059
4060 finally:
4061     Py_XDECREF(pickler);
4062
4063     return res;
4064 }
4065
4066
4067 static PyObject *
4068 cpm_dumps(PyObject *self, PyObject *args) {
4069     PyObject *ob, *file = 0, *res = NULL;
4070     Picklerobject *pickler = 0;
4071     int bin = 0;
4072
4073     UNLESS (PyArg_ParseTuple(args, "O|i", &ob, &bin))
4074         goto finally;
4075
4076     UNLESS (file = PycStringIO->NewOutput(128))
4077         goto finally;
4078
4079     UNLESS (pickler = newPicklerobject(file, bin))
4080         goto finally;
4081
4082     if (dump(pickler, ob) < 0)
4083         goto finally;
4084
4085     res = PycStringIO->cgetvalue(file);
4086
4087 finally:
4088     Py_XDECREF(pickler);
4089     Py_XDECREF(file);
4090
4091     return res;
4092 }
4093
4094
4095 static PyObject *
4096 cpm_load(PyObject *self, PyObject *args) {
4097     Unpicklerobject *unpickler = 0;
4098     PyObject *ob, *res = NULL;
4099
4100     UNLESS (PyArg_ParseTuple(args, "O", &ob))
4101         goto finally;
4102
4103     UNLESS (unpickler = newUnpicklerobject(ob))
4104         goto finally;
4105
4106     res = load(unpickler);
4107
4108 finally:
4109     Py_XDECREF(unpickler);
4110
4111     return res;
4112 }
4113
4114
4115 static PyObject *
4116 cpm_loads(PyObject *self, PyObject *args) {
4117     PyObject *ob, *file = 0, *res = NULL;
4118     Unpicklerobject *unpickler = 0;
4119
4120     UNLESS (PyArg_ParseTuple(args, "S", &ob))
4121         goto finally;
4122
4123     UNLESS (file = PycStringIO->NewInput(ob))
4124         goto finally;
4125
4126     UNLESS (unpickler = newUnpicklerobject(file))
4127         goto finally;
4128
4129     res = load(unpickler);
4130
4131 finally:
4132     Py_XDECREF(file);
4133     Py_XDECREF(unpickler);
4134
4135     return res;
4136 }
4137
4138
4139 static char Unpicklertype__doc__[] =
4140 "Objects that know how to unpickle";
4141
4142 static PyTypeObject Unpicklertype = {
4143     PyObject_HEAD_INIT(NULL)
4144     0,                            /*ob_size*/
4145     "Unpickler",                  /*tp_name*/
4146     sizeof(Unpicklerobject),              /*tp_basicsize*/
4147     0,                            /*tp_itemsize*/
4148     /* methods */
4149     (destructor)Unpickler_dealloc,        /*tp_dealloc*/
4150     (printfunc)0,         /*tp_print*/
4151     (getattrfunc)Unpickler_getattr,       /*tp_getattr*/
4152     (setattrfunc)Unpickler_setattr,       /*tp_setattr*/
4153     (cmpfunc)0,           /*tp_compare*/
4154     (reprfunc)0,          /*tp_repr*/
4155     0,                    /*tp_as_number*/
4156     0,            /*tp_as_sequence*/
4157     0,            /*tp_as_mapping*/
4158     (hashfunc)0,          /*tp_hash*/
4159     (ternaryfunc)0,               /*tp_call*/
4160     (reprfunc)0,          /*tp_str*/
4161
4162     /* Space for future expansion */
4163     0L,0L,0L,0L,
4164     Unpicklertype__doc__ /* Documentation string */
4165 };
4166
4167 static struct PyMethodDef cPickle_methods[] = {
4168   {"dump",         (PyCFunction)cpm_dump,         1,
4169    "dump(object, file, [binary]) --"
4170    "Write an object in pickle format to the given file\n"
4171    "\n"
4172    "If the optional argument, binary, is provided and is true, then the\n"
4173    "pickle will be written in binary format, which is more space and\n"
4174    "computationally efficient. \n"
4175   },
4176   {"dumps",        (PyCFunction)cpm_dumps,        1,
4177    "dumps(object, [binary]) --"
4178    "Return a string containing an object in pickle format\n"
4179    "\n"
4180    "If the optional argument, binary, is provided and is true, then the\n"
4181    "pickle will be written in binary format, which is more space and\n"
4182    "computationally efficient. \n"
4183   },
4184   {"load",         (PyCFunction)cpm_load,         1,
4185    "load(file) -- Load a pickle from the given file"},
4186   {"loads",        (PyCFunction)cpm_loads,        1,
4187    "loads(string) -- Load a pickle from the given string"},
4188   {"Pickler",      (PyCFunction)get_Pickler,      1,
4189    "Pickler(file, [binary]) -- Create a pickler\n"
4190    "\n"
4191    "If the optional argument, binary, is provided and is true, then\n"
4192    "pickles will be written in binary format, which is more space and\n"
4193    "computationally efficient. \n"
4194   },
4195   {"Unpickler",    (PyCFunction)get_Unpickler,    1,
4196    "Unpickler(file) -- Create an unpickler"},
4197   { NULL, NULL }
4198 };
4199
4200
4201 #define CHECK_FOR_ERRORS(MESS) \
4202 if (PyErr_Occurred()) { \
4203     PyObject *__sys_exc_type, *__sys_exc_value, *__sys_exc_traceback; \
4204     PyErr_Fetch( &__sys_exc_type, &__sys_exc_value, &__sys_exc_traceback); \
4205     fprintf(stderr, # MESS ":\n\t"); \
4206     PyObject_Print(__sys_exc_type, stderr,0); \
4207     fprintf(stderr,", "); \
4208     PyObject_Print(__sys_exc_value, stderr,0); \
4209     fprintf(stderr,"\n"); \
4210     fflush(stderr); \
4211     Py_FatalError(# MESS); \
4212 }
4213
4214
4215 static int
4216 init_stuff(PyObject *module, PyObject *module_dict) {
4217     PyObject *string, *copy_reg;
4218
4219 #define INIT_STR(S) UNLESS(S ## _str=PyString_FromString(#S)) return -1;
4220
4221     INIT_STR(__class__);
4222     INIT_STR(__getinitargs__);
4223     INIT_STR(__dict__);
4224     INIT_STR(__getstate__);
4225     INIT_STR(__setstate__);
4226     INIT_STR(__name__);
4227     INIT_STR(__main__);
4228     INIT_STR(__reduce__);
4229     INIT_STR(write);
4230     INIT_STR(__safe_for_unpickling__);
4231     INIT_STR(append);
4232     INIT_STR(read);
4233     INIT_STR(readline);
4234     INIT_STR(copy_reg);
4235     INIT_STR(dispatch_table);
4236     INIT_STR(safe_constructors);
4237     INIT_STR(__basicnew__);
4238     UNLESS (empty_str=PyString_FromString("")) return -1;
4239
4240     UNLESS (copy_reg = PyImport_ImportModule("copy_reg"))
4241         return -1;
4242
4243     /* These next few are special because we want to use different
4244        ones in restricted mode. */
4245
4246     UNLESS (dispatch_table = PyObject_GetAttr(copy_reg, dispatch_table_str))
4247         return -1;
4248
4249     UNLESS (safe_constructors = PyObject_GetAttr(copy_reg,
4250                                                 safe_constructors_str))
4251         return -1;
4252
4253     Py_DECREF(copy_reg);
4254
4255     /* Down to here ********************************** */
4256
4257     UNLESS (string = PyImport_ImportModule("string"))
4258         return -1;
4259
4260     UNLESS (atol_func = PyObject_GetAttrString(string, "atol"))
4261         return -1;
4262
4263     Py_DECREF(string);
4264
4265     UNLESS (empty_tuple = PyTuple_New(0))
4266         return -1;
4267
4268     UNLESS (PicklingError = PyString_FromString("cPickle.PicklingError"))
4269         return -1;
4270
4271     if (PyDict_SetItemString(module_dict, "PicklingError",
4272         PicklingError) < 0)
4273         return -1;
4274
4275     UNLESS (UnpicklingError = PyString_FromString("cPickle.UnpicklingError"))
4276         return -1;
4277
4278     if (PyDict_SetItemString(module_dict, "UnpicklingError",
4279         UnpicklingError) < 0)
4280         return -1;
4281
4282     UNLESS (BadPickleGet = PyString_FromString("cPickle.BadPickleGet"))
4283         return -1;
4284
4285     if (PyDict_SetItemString(module_dict, "BadPickleGet",
4286         BadPickleGet) < 0)
4287         return -1;
4288
4289     PycString_IMPORT;
4290
4291     return 0;
4292 }
4293
4294 #ifndef DL_EXPORT       /* declarations for DLL import/export */
4295 #define DL_EXPORT(RTYPE) RTYPE
4296 #endif
4297 DL_EXPORT(void)
4298 initcPickle() {
4299     PyObject *m, *d, *v;
4300     char *rev="1.63";
4301     PyObject *format_version;
4302     PyObject *compatible_formats;
4303
4304     Picklertype.ob_type = &PyType_Type;
4305     Unpicklertype.ob_type = &PyType_Type;
4306     PdataType.ob_type = &PyType_Type;
4307
4308     /* Create the module and add the functions */
4309     m = Py_InitModule4("cPickle", cPickle_methods,
4310                      cPickle_module_documentation,
4311                      (PyObject*)NULL,PYTHON_API_VERSION);
4312
4313     /* Add some symbolic constants to the module */
4314     d = PyModule_GetDict(m);
4315     PyDict_SetItemString(d,"__version__", v = PyString_FromString(rev));
4316     Py_XDECREF(v);
4317
4318     format_version = PyString_FromString("1.3");
4319     compatible_formats = Py_BuildValue("[sss]", "1.0", "1.1", "1.2");
4320
4321     PyDict_SetItemString(d, "format_version", format_version);
4322     PyDict_SetItemString(d, "compatible_formats", compatible_formats);
4323     Py_XDECREF(format_version);
4324     Py_XDECREF(compatible_formats);
4325
4326     init_stuff(m, d);
4327     CHECK_FOR_ERRORS("can't initialize module cPickle");
4328 }