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