cPickle, version 0.1.

1 files changed, 3767 insertions, 0 deletions

diff --git a/Modules/cPickle.c b/Modules/cPickle.c
new file mode 100644
index 0000000..f342051
--- /dev/null
+++ b/Modules/cPickle.c
@@ -0,0 +1,3767 @@
+/*
+     $Id$
+
+     Copyright 
+
+       Copyright 1996 Digital Creations, L.C., 910 Princess Anne
+       Street, Suite 300, Fredericksburg, Virginia 22401 U.S.A. All
+       rights reserved.  Copyright in this software is owned by DCLC,
+       unless otherwise indicated. Permission to use, copy and
+       distribute this software is hereby granted, provided that the
+       above copyright notice appear in all copies and that both that
+       copyright notice and this permission notice appear. Note that
+       any product, process or technology described in this software
+       may be the subject of other Intellectual Property rights
+       reserved by Digital Creations, L.C. and are not licensed
+       hereunder.
+
+     Trademarks 
+
+       Digital Creations & DCLC, are trademarks of Digital Creations, L.C..
+       All other trademarks are owned by their respective companies. 
+
+     No Warranty 
+
+       The software is provided "as is" without warranty of any kind,
+       either express or implied, including, but not limited to, the
+       implied warranties of merchantability, fitness for a particular
+       purpose, or non-infringement. This software could include
+       technical inaccuracies or typographical errors. Changes are
+       periodically made to the software; these changes will be
+       incorporated in new editions of the software. DCLC may make
+       improvements and/or changes in this software at any time
+       without notice.
+
+     Limitation Of Liability 
+
+       In no event will DCLC be liable for direct, indirect, special,
+       incidental, economic, cover, or consequential damages arising
+       out of the use of or inability to use this software even if
+       advised of the possibility of such damages. Some states do not
+       allow the exclusion or limitation of implied warranties or
+       limitation of liability for incidental or consequential
+       damages, so the above limitation or exclusion may not apply to
+       you.
+
+    If you have questions regarding this software,
+    contact:
+   
+      Jim Fulton, jim@digicool.com
+      Digital Creations L.C.  
+   
+      (540) 371-6909
+*/
+
+static char cPickle_module_documentation[] = 
+""
+;
+
+#include "Python.h"
+#include "cStringIO.h"
+#include "graminit.h"
+
+#include <errno.h>
+
+static PyObject *ErrorObject;
+
+#ifdef __cplusplus
+#define ARG(T, N) T N
+#define ARGDECL(T, N)
+#else
+#define ARG(T, N) N
+#define ARGDECL(T, N) T N;
+#endif
+
+#define UNLESS(E) if (!(E))
+#define ASSIGN(V,E) {PyObject *__e; __e=(E); Py_XDECREF(V); (V)=__e;}
+#define UNLESS_ASSIGN(V,E) ASSIGN(V,E) UNLESS(V)
+
+#define DEL_LIST_SLICE(list, from, to) \
+        (PyList_SetSlice(list, from, to, empty_list))
+
+#define APPEND    'a'
+#define BUILD     'b'
+#define DUP       '2'
+#define GET       'g'
+#define BINGET    'h'
+#define INST      'i'
+#define OBJ       'o'
+#define MARK      '('
+static char MARKv = MARK;
+#define PUT       'p'
+#define BINPUT    'q'
+#define POP       '0'
+#define SETITEM   's'
+#define STOP      '.'
+#define CLASS     'c'
+#define DICT      'd'
+#define LIST      'l'
+#define TUPLE     't'
+#define NONE      'N'
+#define INT       'I'
+#define BININT    'J'
+#define BININT1   'K'
+#define BININT2   'M'
+#define BININT3   'O'
+#define LONG      'L'
+#define FLOAT     'F'
+#define STRING    'S'
+#define BINSTRING 'T'
+#define SHORT_BINSTRING 'U'
+#define PERSID    'P'
+
+
+PyTypeObject *BuiltinFunctionType;
+
+/* atol function from string module */
+static PyObject *atol_func;
+
+static PyObject *PicklingError;
+static PyObject *UnpicklingError;
+
+static PyObject *class_map;
+static PyObject *empty_list, *empty_tuple;
+
+static PyObject *save();
+
+
+typedef struct
+{
+  PyObject_HEAD
+  FILE *fp;
+  PyObject *write;
+  PyObject *file;
+  PyObject *memo;
+  PyObject *arg;
+  PyObject *pers_func;
+  char *mark;
+  int bin;
+  int (*write_func)();
+} Picklerobject;
+
+staticforward PyTypeObject Picklertype;
+
+
+typedef struct
+{
+  PyObject_HEAD
+  FILE *fp;
+  PyObject *file;
+  PyObject *readline;
+  PyObject *read;
+  PyObject *memo;
+  PyObject *arg;
+  PyObject *stack;
+  PyObject *mark;
+  PyObject *pers_func;
+  int *marks;
+  int num_marks;
+  int marks_size;
+  int (*read_func)();
+  int (*readline_func)();
+} Unpicklerobject;
+ 
+staticforward PyTypeObject Unpicklertype;
+
+
+static int 
+write_file(ARG(Picklerobject *, self), ARG(char *, s), ARG(int, n))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(char *, s)
+    ARGDECL(int, n)
+{
+  if (fwrite(s, sizeof(char), n, self->fp) != n)
+  {
+    PyErr_SetFromErrno(PyExc_IOError);
+    return -1;
+  }
+
+  return n;
+}
+
+
+static int 
+write_cStringIO(ARG(Picklerobject *, self), ARG(char *, s), ARG(int, n))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(char *, s)
+    ARGDECL(int, n)
+{
+  if ((*PycStringIO_cwrite)((PyObject *)self->file, s, n) != n)
+  {
+    return -1;
+  }
+
+  return n;
+}
+
+
+static int 
+write_other(ARG(Picklerobject *, self), ARG(char *, s), ARG(int, n))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(char *, s)
+    ARGDECL(int, n)
+{
+  PyObject *py_str, *junk;
+
+  UNLESS(py_str = PyString_FromStringAndSize(s, n))
+    return -1;
+
+  UNLESS(self->arg)
+    UNLESS(self->arg = PyTuple_New(1))
+    {
+      Py_DECREF(py_str);
+      return -1;
+    }
+
+  if (PyTuple_SetItem(self->arg, 0, py_str) == -1)
+  {
+    Py_DECREF(py_str);
+    return -1;
+  }
+
+  Py_INCREF(py_str);
+  UNLESS(junk = PyObject_CallObject(self->write, self->arg))
+  {
+    Py_DECREF(py_str);
+    return -1;
+  }
+
+  Py_DECREF(junk);
+
+  return n;
+}
+
+
+static int 
+read_file(ARG(Unpicklerobject *, self), ARG(char **, s), ARG(int, n))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(char **, s)
+    ARGDECL(int, n)
+{
+  if (fread(*s, sizeof(char), n, self->fp) != n)
+  {  
+    if (feof(self->fp))
+    {
+      PyErr_SetNone(PyExc_EOFError);
+      return -1;
+    }
+
+    PyErr_SetFromErrno(PyExc_IOError);
+    return -1;
+  }
+
+  return n;
+}
+
+
+static int 
+readline_file(ARG(Unpicklerobject *, self), ARG(char **, s))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(char **, s)
+{
+  int size, i;
+  char *str;
+
+  UNLESS(str = (char *)malloc(100))
+  {
+    PyErr_SetString(PyExc_MemoryError, "out of memory");
+    return -1;
+  }
+
+  size = 100;
+  i = 0;
+
+  while (1)
+  {
+    for (; i < size; i++)
+    {
+      if (feof(self->fp) || (str[i] = getc(self->fp)) == '\n')
+      {
+        str[i] = 0;
+        *s = str;
+        return i;
+      }
+    }
+
+    UNLESS(str = realloc(str, size += 100))
+    {
+      PyErr_SetString(PyExc_MemoryError, "out of memory");
+      return -1;
+    }
+  }
+}    
+
+
+static int 
+read_cStringIO(ARG(Unpicklerobject *, self), ARG(char **, s), ARG(int, n))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(char **, s)
+    ARGDECL(int, n)
+{
+  char *ptr;
+
+  if ((*PycStringIO_cread)((PyObject *)self->file, &ptr, n) != n)
+  {
+    PyErr_SetNone(PyExc_EOFError);
+    return -1;
+  }
+
+  memcpy(*s, ptr, n);
+  return n;
+}
+
+
+static int 
+readline_cStringIO(ARG(Unpicklerobject *, self), ARG(char **, s))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(char **, s)
+{
+  int n;
+  char *ptr, *str;
+
+  if ((n = (*PycStringIO_creadline)((PyObject *)self->file, &ptr)) == -1)
+  {
+    return -1;
+  }
+
+  UNLESS(str = (char *)malloc(n * sizeof(char) + 1))
+  {
+    PyErr_SetString(PyExc_MemoryError, "out of memory");
+    return -1;
+  }
+
+  memcpy(str, ptr, n);
+
+  str[((str[n - 1] == '\n') ? --n : n)] = 0;
+
+  *s = str;
+  return n;
+}
+
+
+static int 
+read_other(ARG(Unpicklerobject *, self), ARG(char **, s), ARG(int, n))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(char **, s)
+    ARGDECL(int, n)
+{
+  PyObject *bytes, *str;
+  char *ret_str;
+
+  UNLESS(bytes = PyInt_FromLong(n))
+  {
+    if (!PyErr_Occurred())
+      PyErr_SetNone(PyExc_EOFError);
+
+    return -1;
+  }
+
+  UNLESS(self->arg)
+    UNLESS(self->arg = PyTuple_New(1))
+    {
+      Py_DECREF(bytes);
+      return -1;
+    }
+
+  if (PyTuple_SetItem(self->arg, 0, bytes) == -1)
+  {
+    Py_DECREF(bytes);
+    return -1;
+  }
+  Py_INCREF(bytes);
+
+  UNLESS(str = PyObject_CallObject(self->read, self->arg))
+  {
+    Py_DECREF(bytes);
+    return -1;
+  }
+
+  memcpy(*s, PyString_AsString(str), n);
+
+  Py_DECREF(bytes);
+  Py_DECREF(str);
+
+  return n;
+}
+
+
+static int 
+readline_other(ARG(Unpicklerobject *, self), ARG(char **, s))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(char **, s)
+{
+  PyObject *str;
+  char *c_str;
+  int size;
+
+  UNLESS(str = PyObject_CallObject(self->readline, empty_tuple))
+  {
+    return -1;
+  }
+
+  size = PyString_Size(str);
+
+  UNLESS(c_str = (char *)malloc((size + 1) * sizeof(char)))
+  {
+    PyErr_SetString(PyExc_MemoryError, "out of memory");
+    return -1;
+  }
+
+  memcpy(c_str, PyString_AsString(str), size);
+
+  if (size > 0)
+  {
+    c_str[((c_str[size - 1] == '\n') ? --size : size)] = 0;
+  }
+
+  *s = c_str;
+
+  Py_DECREF(str);
+
+  return size;
+}
+
+
+static int
+put(ARG(Picklerobject *, self), ARG(PyObject *, ob))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(PyObject *, ob)
+{
+  char c_str[30];
+  int p, len;
+  PyObject *py_ob_id = 0, *memo_len = 0;
+
+  if ((p = PyDict_Size(self->memo)) == -1)
+    return -1;
+
+  if (!self->bin || (p >= 256))
+  {
+    c_str[0] = PUT;
+    sprintf(c_str + 1, "%d\n", p);
+    len = strlen(c_str);
+  }
+  else
+  {
+    c_str[0] = BINPUT;
+    c_str[1] = p;
+    len = 2;
+  }
+
+  if ((*self->write_func)(self, c_str, len) == -1)
+    return -1;
+
+  UNLESS(py_ob_id = PyInt_FromLong((long)ob))
+    return -1;
+
+  UNLESS(memo_len = PyInt_FromLong(p))
+    goto err;
+
+  if (PyDict_SetItem(self->memo, py_ob_id, memo_len) == -1)
+    goto err;
+
+  Py_DECREF(py_ob_id);
+  Py_DECREF(memo_len);
+
+  return 1;
+
+err:
+  Py_XDECREF(py_ob_id);
+  Py_XDECREF(memo_len);
+
+  return -1;
+}
+
+
+static int
+safe(ARG(PyObject *, ob))
+    ARGDECL(PyObject *, ob)
+{
+  PyTypeObject *type;
+  PyObject *this_item;
+  int len, res, i;
+  
+  type = ob->ob_type;
+
+  if (type == &PyInt_Type    || 
+      type == &PyFloat_Type  || 
+      type == &PyString_Type ||
+      ob == Py_None)
+  {
+    return 1;
+  }
+
+  if (type == &PyTuple_Type)
+  {
+    len = PyTuple_Size(ob);
+    for (i = 0; i < len; i++)
+    {
+      UNLESS(this_item = PyTuple_GET_ITEM((PyTupleObject *)ob, i))
+        return -1;
+    
+      if ((res = safe(this_item)) == 1)
+        continue;
+
+      return res;
+    }
+
+    return 1;
+  }
+
+  return 0;
+}
+
+
+static PyObject *
+whichmodule(ARG(PyObject *, class))
+    ARGDECL(PyObject *, class)
+{
+  int has_key, i, j;
+  PyObject *module = 0, *modules_dict = 0, *class_name = 0, *class_name_attr = 0, 
+      *name = 0;
+  char *name_str, *class_name_str;
+
+  static PyObject *__main__str;
+
+  if ((has_key = PyMapping_HasKey(class_map, class)) == -1)
+    return NULL;
+
+  if (has_key)
+  {
+    return ((module = PyDict_GetItem(class_map, class)) ? module : NULL);
+  }
+
+  UNLESS(modules_dict = PySys_GetObject("modules"))
+    return NULL;
+
+  UNLESS(class_name = ((PyClassObject *)class)->cl_name)
+  {
+    PyErr_SetString(PicklingError, "class has no name");
+    return NULL;
+  }
+
+  UNLESS(class_name_str = PyString_AsString(class_name))
+    return NULL;
+
+  i = 0;
+  while (j = PyDict_Next(modules_dict, &i, &name, &module))
+  {
+    UNLESS(name_str = PyString_AsString(name))
+      return NULL;
+
+    if (!strcmp(name_str, "__main__"))
+      continue;
+
+    UNLESS(class_name_attr = PyObject_GetAttr(module, class_name))
+    {
+      PyErr_Clear();
+      continue;
+    }
+
+    if (class_name_attr != class)
+    {
+      Py_DECREF(class_name_attr);
+      continue;
+    }
+
+    Py_DECREF(class_name_attr);
+
+    break;
+  }
+    
+  if (!j) /* previous while exited normally */
+  {
+    UNLESS(__main__str)
+      UNLESS(__main__str = PyString_FromString("__main__"))
+        return NULL;
+
+    name = __main__str;
+  }
+  else    /* previous while exited via break */
+  {
+    Py_INCREF(name);
+  }
+  
+  PyDict_SetItem(class_map, class, name);
+
+  return name;
+}
+
+
+static PyObject *
+save_none(ARG(Picklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  static char none[] = { NONE };
+
+  if ((*self->write_func)(self, none, 1) == -1)  
+    return NULL;
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+      
+static PyObject *
+save_int(ARG(Picklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  char c_str[25];
+  long l = PyInt_AS_LONG((PyIntObject *)args);
+  int len;
+
+  if (!self->bin)
+  {
+    c_str[0] = INT;
+    sprintf(c_str + 1, "%ld\n", l);
+    if ((*self->write_func)(self, c_str, strlen(c_str)) == -1)
+      return NULL;
+  }
+  else
+  {
+    c_str[1] = (int)(l & 0xff);
+    c_str[2] = (int)((l >> 8)  & 0xff);
+    c_str[3] = (int)((l >> 16) & 0xff);
+    c_str[4] = (int)((l >> 24) & 0xff);
+
+    if (!c_str[4])
+    {
+      if (!c_str[3])
+      {
+        if (!c_str[2])
+        {
+          c_str[0] = BININT3;
+          len = 2;
+        }
+        else
+        {
+          c_str[0] = BININT2;
+          len = 3;
+        }
+      }
+      else 
+      {
+        c_str[0] = BININT1;
+        len = 4;
+      }
+    }
+    else
+    {
+      c_str[0] = BININT;
+      len = 5;
+    }
+
+    if ((*self->write_func)(self, c_str, len) == -1)
+      return NULL;
+  }
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *
+save_long(ARG(Picklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  char *c_str;
+  int size;
+  PyObject *repr = 0;
+
+  UNLESS(repr = PyObject_Repr(args))
+    return NULL;
+
+  if ((size = PyString_Size(repr)) == -1)
+  {
+    Py_DECREF(repr);
+    return NULL;
+  }
+
+  UNLESS(c_str = (char *)malloc((size + 2) * sizeof(char)))
+  {
+    Py_DECREF(repr);
+    PyErr_SetString(PyExc_MemoryError, "out of memory");
+    return NULL;
+  }
+
+  c_str[0] = LONG;
+  memcpy(c_str + 1, PyString_AS_STRING((PyStringObject *)repr), size);
+  c_str[size + 1] = '\n';
+
+  Py_DECREF(repr);
+
+  if ((*self->write_func)(self, c_str, size + 2) == -1)
+  {
+    free(c_str);
+    return NULL;
+  }
+
+  free(c_str);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *
+save_float(ARG(Picklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  char c_str[250];
+
+  c_str[0] = FLOAT;
+  sprintf(c_str + 1, "%f\n", PyFloat_AS_DOUBLE((PyFloatObject *)args));
+
+  if ((*self->write_func)(self, c_str, strlen(c_str)) == -1)
+    return NULL;
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *
+save_string(ARG(Picklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  char *c_str;
+  int size, len;
+
+  if (!self->bin)
+  {
+    PyObject *repr;
+    char *repr_str;
+
+    UNLESS(repr = PyObject_Repr(args))
+      return NULL;
+
+    repr_str = PyString_AS_STRING((PyStringObject *)repr);
+    size = PyString_Size(repr);
+
+    UNLESS(c_str = (char *)malloc((size + 2) * sizeof(char)))
+    {
+      PyErr_SetString(PyExc_MemoryError, "out of memory");
+      return NULL;
+    }
+   
+    c_str[0] = STRING;
+    memcpy(c_str + 1, repr_str, size);
+    c_str[size + 1] = '\n';
+
+    len = size + 2;
+
+    Py_XDECREF(repr);
+  }
+  else
+  {
+    size = PyString_Size(args);
+
+    UNLESS(c_str = (char *)malloc((size + 30) * sizeof(char)))
+    {
+      PyErr_SetString(PyExc_MemoryError, "out of memory");
+      return NULL;
+    }
+
+    if (size < 256)
+    {
+      c_str[0] = SHORT_BINSTRING;
+      c_str[1] = size;
+      len = 2;
+    }
+    else  
+    {
+      c_str[0] = BINSTRING;
+      sprintf(c_str + 1, "%d\n", size);
+      len = strlen(c_str);
+    }
+
+    memcpy(c_str + len, PyString_AS_STRING((PyStringObject *)args), size);
+
+    len += size;
+  }
+
+  if ((*self->write_func)(self, c_str, len) == -1)
+  {
+    free(c_str);
+    return NULL;
+  }
+
+  free(c_str);
+
+  if (args->ob_refcnt > 1)
+  {
+    if (put(self, args) == -1)
+    {
+      return NULL;
+    }
+  }
+  
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *
+save_tuple(ARG(Picklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *element = 0, *junk = 0, *py_tuple_id = 0;
+  int len, i, dict_size;
+
+  static char tuple = TUPLE;
+
+  if ((*self->write_func)(self, &MARKv, 1) == -1)
+    return NULL;
+
+  UNLESS(py_tuple_id = PyInt_FromLong((long)args))  return NULL;
+
+  if ((len = PyTuple_Size(args)) == -1)  
+    goto err;
+
+  for (i = 0; i < len; i++)
+  {
+    UNLESS(element = PyTuple_GET_ITEM((PyTupleObject *)args, i))  
+      goto err;
+    
+    dict_size = PyDict_Size(self->memo);
+
+    UNLESS(junk = save(self, element))
+      goto err;
+    Py_DECREF(junk);
+
+    if (((PyDict_Size(self->memo) - dict_size) > 1)  && 
+        PyMapping_HasKey(self->memo, py_tuple_id))
+    {
+      char c_str[30];
+      long c_value;
+      int c_str_len;
+      PyObject *value;
+      static char pop = POP;
+
+      while (i-- >= 0)
+      {
+        if ((*self->write_func)(self, &pop, 1) == -1)
+          goto err;
+      }
+
+      UNLESS(value = PyDict_GetItem(self->memo, py_tuple_id))
+        goto err;
+
+      c_value = PyInt_AsLong(value);
+
+      if (self->bin && (c_value < 256))
+      {
+        c_str[0] = BINGET;
+        c_str[1] = c_value;
+        c_str_len = 2;
+      }
+      else
+      {
+        c_str[0] = GET;
+        sprintf(c_str + 1, "%ld\n", c_value);
+        c_str_len = strlen(c_str);
+      }
+
+      if ((*self->write_func)(self, c_str, c_str_len) == -1)
+        goto err;
+
+      break;
+    }
+  }
+
+  if (i >= len)
+  {
+    if ((*self->write_func)(self, &tuple, 1) == -1)
+      goto err;
+    
+    if (args->ob_refcnt > 1)
+    {
+      if (put(self, args) == -1)
+      {
+        goto err;
+      }
+    }
+  }
+ 
+  Py_DECREF(py_tuple_id);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(py_tuple_id);
+
+  return NULL;
+}
+
+
+static PyObject *
+save_list(ARG(Picklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *element = 0, *junk = 0;
+  int len, i, safe_val;
+  static char append = APPEND, list = LIST;
+
+  if ((*self->write_func)(self, &MARKv, 1) == -1)
+    return NULL;
+
+  if ((len = PyList_Size(args)) == -1)
+    return NULL;
+
+  for (i = 0; i < len; i++)
+  {
+    UNLESS(element = PyList_GET_ITEM((PyListObject *)args, i))  
+      return NULL;
+
+    if ((safe_val = safe(element)) == -1)  
+      return NULL;
+    UNLESS(safe_val)
+      break;
+
+    UNLESS(junk = save(self, element))  
+      return NULL;
+    Py_DECREF(junk);
+  }
+
+  if (args->ob_refcnt > 1)
+  {
+    if (put(self, args) == -1)
+    {
+      return NULL;
+    }
+  }
+
+  if ((*self->write_func)(self, &list, 1) == -1)
+    return NULL;
+
+  for (; i < len; i++)
+  {
+    UNLESS(element = PyList_GET_ITEM((PyListObject *)args, i))  
+      return NULL;
+
+    UNLESS(junk = save(self, element))  
+      return NULL;
+    Py_DECREF(junk);
+
+    if ((*self->write_func)(self, &append, 1) == -1)
+      return NULL;
+  }
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *
+save_dict(ARG(Picklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *key = 0, *value = 0, *junk = 0;
+  int i, safe_key, safe_value;
+
+  static char setitem = SETITEM, dict = DICT;
+
+  if ((*self->write_func)(self, &MARKv, 1) == -1)
+    return NULL;
+
+  i = 0;
+  
+  while (PyDict_Next(args, &i, &key, &value))
+  {
+    if ((safe_key = safe(key)) == -1)  
+      return NULL;
+
+    UNLESS(safe_key)  
+      break;
+   
+    if ((safe_value = safe(value)) == -1)  
+      return NULL;
+   
+    UNLESS(safe_value)  
+      break;
+
+    UNLESS(junk = save(self, key))
+      return NULL;
+    Py_DECREF(junk);
+
+    UNLESS(junk = save(self, value))
+      return NULL;
+    Py_DECREF(junk);
+  }
+
+  if ((*self->write_func)(self, &dict, 1) == -1)
+    return NULL;
+
+  if (args->ob_refcnt > 1)
+  {
+    if (put(self, args) == -1)
+    {
+      return NULL;
+    }
+  }
+
+  while (PyDict_Next(args, &i, &key, &value))
+  {
+    UNLESS(junk = save(self, key))
+      return NULL;
+    Py_DECREF(junk);
+
+    UNLESS(junk = save(self, value))
+      return NULL;
+    Py_DECREF(junk);
+
+    if ((*self->write_func)(self, &setitem, 1) == -1)
+      return NULL;
+  }
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *  
+save_inst(ARG(Picklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *class = 0, *module = 0, *name = 0, *py_inst_id = 0, *init_args = 0,
+           *junk = 0, *state = 0, *getinitargs_func = 0, *getstate_func = 0;
+  char *module_str, *name_str, *c_str;
+  int len, p, module_size, name_size, size;
+  static char build = BUILD;
+
+  if ((*self->write_func)(self, &MARKv, 1) == -1)
+    return NULL;
+
+  UNLESS(class = PyObject_GetAttrString(args, "__class__"))
+    return NULL;
+
+  if (self->bin)
+  {
+    UNLESS(junk = save(self, class))
+      goto err;
+    Py_DECREF(junk);
+  }
+
+  if (getinitargs_func = PyObject_GetAttrString(args, "__getinitargs__"))
+  {
+    PyObject *class_args = 0, *element = 0;
+    int i, len;
+
+    UNLESS(class_args = PyObject_CallObject(getinitargs_func, empty_tuple))
+    {
+      Py_DECREF(getinitargs_func);
+      goto err;
+    }
+
+    if ((len = PyObject_Length(class_args)) == -1)  
+    {
+      Py_DECREF(class_args);
+      goto err;
+    }
+
+    for (i = 0; i < len; i++)
+    {
+      UNLESS(element = PySequence_GetItem(class_args, i)) 
+      { 
+        Py_DECREF(class_args); 
+        goto err;
+      }
+
+      UNLESS(junk = save(self, element))
+      {
+        Py_DECREF(element); Py_DECREF(class_args);
+        goto err;
+      }
+
+      Py_DECREF(junk);
+      Py_DECREF(element);
+    }
+
+    Py_DECREF(class_args);
+  }
+  else
+  {
+    PyErr_Clear();
+  }
+
+  if (!self->bin)
+  {
+    UNLESS(module = whichmodule(class))
+      goto err;
+    
+    UNLESS(name = ((PyClassObject *)class)->cl_name)
+    {
+      PyErr_SetString(PicklingError, "class has no name");
+      goto err;
+    }
+
+    module_str = PyString_AS_STRING((PyStringObject *)module);
+    module_size = PyString_Size(module);
+    name_str   = PyString_AS_STRING((PyStringObject *)name);
+    name_size = PyString_Size(name);
+
+    size = name_size + module_size + 3;
+
+    UNLESS(c_str = (char *)malloc(size * sizeof(char)))
+    {
+      PyErr_SetString(PyExc_MemoryError, "out of memory");
+      return NULL;
+    }
+
+    c_str[0] = INST;
+    memcpy(c_str + 1, module_str, module_size);
+    c_str[module_size + 1] = '\n';
+    memcpy(c_str + module_size + 2, name_str, name_size);
+    c_str[module_size + name_size + 2] = '\n';
+
+    if ((*self->write_func)(self, c_str, size) == -1)
+    {
+      free(c_str);
+      goto err;
+                                                                                                                                                                      }
+
+    free(c_str);
+  }
+
+  if (args->ob_refcnt > 1)
+  {
+    if (put(self, args) == -1)
+    {
+      goto err;
+    }
+  }
+
+  if (getstate_func = PyObject_GetAttrString(args, "__getstate__"))
+  {
+    UNLESS(state = PyObject_CallObject(getstate_func, empty_tuple))
+    {
+      Py_DECREF(getstate_func);
+      goto err;
+    }
+  }
+  else
+  {
+    PyErr_Clear();
+
+    UNLESS(state = PyObject_GetAttrString(args, "__dict__"))
+      goto err;
+  }
+
+  UNLESS(junk = save(self, state))
+    goto err;
+  Py_DECREF(junk);
+
+  Py_XDECREF(getinitargs_func);
+  Py_XDECREF(getstate_func);
+  Py_XDECREF(module);
+  Py_XDECREF(state);
+
+  if ((*self->write_func)(self, &build, 1) == -1)
+    return NULL;
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(getinitargs_func);
+  Py_XDECREF(getstate_func);
+  Py_XDECREF(module);
+  Py_XDECREF(state);
+
+  return NULL;
+}
+
+
+static PyObject *
+save_class(ARG(Picklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *module = 0, *name = 0;
+  char *name_str, *module_str, *c_str;
+  int module_size, name_size, size;
+
+  UNLESS(module = whichmodule(args))
+    return NULL;
+
+  UNLESS(name = ((PyClassObject *)args)->cl_name)
+  {
+    PyErr_SetString(PicklingError, "class has no name");
+    goto err;
+  }
+
+  module_str = PyString_AS_STRING((PyStringObject *)module);
+  module_size = PyString_Size(module);
+  name_str   = PyString_AS_STRING((PyStringObject *)name);
+  name_size = PyString_Size(name);
+
+  size = name_size + module_size + 3;
+
+  UNLESS(c_str = (char *)malloc(size * sizeof(char)))
+  {
+    PyErr_SetString(PyExc_MemoryError, "out of memory");
+    return NULL;
+  }
+
+  c_str[0] = CLASS;
+  memcpy(c_str + 1, module_str, module_size);
+  c_str[module_size + 1] = '\n';
+  memcpy(c_str + module_size + 2, name_str, name_size);
+  c_str[module_size + name_size + 2] = '\n';
+
+  if ((*self->write_func)(self, c_str, size) == -1)
+  {
+    free(c_str);
+    goto err;
+  }
+ 
+  free(c_str);
+
+  if (args->ob_refcnt > 1)
+  {
+    if (put(self, args) == -1)
+    {
+      goto err;
+    }
+  }
+
+  Py_DECREF(module);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(module);
+
+  return NULL;
+}
+
+
+static PyObject *
+save(ARG(Picklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyTypeObject *type;
+  char *error_str, *name_c;
+  PyObject *name, *name_repr;
+
+  if (self->pers_func)
+  {
+    PyObject *pid;
+    int size;
+    
+    UNLESS(self->arg)
+      UNLESS(self->arg = PyTuple_New(1))
+        return NULL;
+    
+    if (PyTuple_SetItem(self->arg, 0, args) == -1)
+      return NULL;
+    Py_INCREF(args);
+    
+    UNLESS(pid = PyObject_CallObject(self->pers_func, self->arg))
+      return NULL;
+
+    if (pid != Py_None)
+    {
+      char *pid_str;
+
+      if ((size = PyString_Size(pid)) == -1)
+      {
+        Py_DECREF(pid);
+        return NULL;
+      }
+
+      UNLESS(pid_str = (char *)malloc((2 + size) * sizeof(char)))
+      {
+        PyErr_SetString(PyExc_MemoryError, "out of memory");
+        Py_DECREF(pid);
+        return NULL;
+      }
+
+      pid_str[0] = PERSID;
+      memcpy(pid_str + 1, PyString_AS_STRING((PyStringObject *)pid), size);
+      pid_str[size + 1] = '\n';
+
+      Py_DECREF(pid);
+  
+      if ((*self->write_func)(self, pid_str, size + 2) == -1)
+      {
+        free(pid_str);
+        return NULL;
+      }
+
+      free(pid_str);
+
+      Py_INCREF(Py_None);
+      return Py_None;
+    }
+
+    Py_DECREF(pid);
+  }
+
+  if (args == Py_None)
+  {
+    return save_none(self, args);
+  }
+
+  type = args->ob_type;
+
+  if (type == &PyInt_Type)
+  {
+    return save_int(self, args);
+  }
+
+  if (type == &PyLong_Type)
+  {
+    return save_long(self, args);
+  }
+
+  if (type == &PyFloat_Type)
+  {
+    return save_float(self, args);
+  }
+
+  if (args->ob_refcnt > 1)
+  {
+    long ob_id;
+    int  has_key;
+    PyObject *py_ob_id;
+
+    ob_id = (long)args;
+  
+    UNLESS(py_ob_id = PyInt_FromLong(ob_id))
+      return NULL;
+
+    if ((has_key = PyMapping_HasKey(self->memo, py_ob_id)) == -1)
+    {
+      Py_DECREF(py_ob_id);
+      return NULL;
+    }
+
+    if (has_key)
+    {
+      PyObject *value;
+      long c_value;
+      char get_str[30];
+      int len;
+
+      UNLESS(value = PyDict_GetItem(self->memo, py_ob_id))
+      {
+        Py_DECREF(py_ob_id);
+        return NULL;
+      }
+
+      Py_DECREF(py_ob_id);
+
+      c_value = PyInt_AsLong(value);
+
+      if (self->bin && (c_value < 256))
+      {
+        get_str[0] = BINGET;
+        get_str[1] = c_value;
+        len = 2;
+      }
+      else
+      {
+        get_str[0] = GET;
+        sprintf(get_str + 1, "%ld\n", c_value);
+        len = strlen(get_str);
+      }
+
+      if ((*self->write_func)(self, get_str, len) == -1)
+        return NULL;
+
+      Py_INCREF(Py_None);
+      return Py_None;
+    }
+
+    Py_DECREF(py_ob_id);
+  }
+
+  if (type == &PyString_Type)
+  {
+    return save_string(self, args);
+  }
+
+  if (type == &PyTuple_Type)
+  {
+    return save_tuple(self, args);
+  }
+
+  if (type == &PyList_Type)
+  {
+    return save_list(self, args);
+  }
+
+  if (type == &PyDict_Type)
+  {
+    return save_dict(self, args);
+  }
+
+  if (type == &PyInstance_Type)
+  {
+    return save_inst(self, args);
+  }
+
+  if (type == &PyClass_Type)
+  {
+    return save_class(self, args);
+  }
+
+  if (PyObject_HasAttrString(args, "__class__"))
+  {
+    return save_inst(self, args);
+  }
+
+  UNLESS(name = PyObject_GetAttrString((PyObject *)type, "__name__"))
+    return NULL;
+
+  UNLESS(name_repr = PyObject_Repr(name))
+  {
+    Py_DECREF(name);
+  }
+
+  name_c = PyString_AsString(name_repr);
+
+  UNLESS(error_str = (char *)malloc((strlen(name_c) + 25) * sizeof(char)))
+  {
+    PyErr_SetString(PyExc_MemoryError, "out of memory");
+    Py_DECREF(name);
+    Py_DECREF(name_repr);
+    return NULL;
+  }
+
+  sprintf(error_str, "Cannot pickle %s objects.", name_c);
+
+  Py_DECREF(name);
+  Py_DECREF(name_repr);
+
+  PyErr_SetString(PicklingError, error_str);
+
+  free(error_str);
+  
+  return NULL;
+}
+
+
+static PyObject *
+Pickler_dump(ARG(Picklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *junk;
+  static char stop = STOP;
+
+  UNLESS(PyArg_Parse(args, "O", &args))  return NULL;
+
+  UNLESS(junk = save(self, args))  return NULL;
+  Py_DECREF(junk);
+
+  if ((*self->write_func)(self, &stop, 1) == -1)
+    return NULL;
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *
+write(ARG(Picklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  char *ptr;
+  int size;
+
+  UNLESS(ptr = PyString_AsString(args))
+    return NULL;
+
+  if ((size = PyString_Size(args)) == -1)
+    return NULL;
+
+  if ((*self->write_func)(self, ptr, size) == -1)
+    return NULL;
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static struct PyMethodDef Pickler_methods[] = {
+  {"save",          (PyCFunction)save,          0, ""},
+  {"dump",          (PyCFunction)Pickler_dump,  0, ""},
+  {"save_none",     (PyCFunction)save_none,     0, ""},
+  {"save_int",      (PyCFunction)save_int,      0, ""},
+  {"save_long",     (PyCFunction)save_long,     0, ""},
+  {"save_float",    (PyCFunction)save_float,    0, ""},
+  {"save_string",   (PyCFunction)save_string,   0, ""},
+  {"save_tuple",    (PyCFunction)save_tuple,    0, ""},
+  {"save_list",     (PyCFunction)save_list,     0, ""},
+  {"save_dict",     (PyCFunction)save_dict,     0, ""},
+  {"save_inst",     (PyCFunction)save_inst,     0, ""},
+  {"save_class",    (PyCFunction)save_class,    0, ""},
+  {"write",         (PyCFunction)write,         0, ""},
+  {NULL,		NULL}		/* sentinel */
+};
+
+
+static Picklerobject *
+newPicklerobject(ARG(PyObject *, file), ARG(int, bin))
+    ARGDECL(PyObject *, file)
+    ARGDECL(int, bin)
+{
+  Picklerobject *self;
+  PyObject *memo = 0;
+
+  UNLESS(memo = PyDict_New())  goto err;
+
+  UNLESS(self = PyObject_NEW(Picklerobject, &Picklertype))  
+    goto err;
+
+  if (PyFile_Check(file))
+  {
+    self->fp = PyFile_AsFile(file);
+    self->write_func = write_file;
+    self->write = NULL;
+  }
+  else if (PycStringIO_OutputCheck(file))
+  {
+    self->fp = NULL;
+    self->write_func = write_cStringIO;
+    self->write = NULL;
+  }
+  else
+  {
+    PyObject *write; 
+
+    self->fp = NULL;
+    self->write_func = write_other;
+
+    UNLESS(write = PyObject_GetAttrString(file, "write"))
+      goto err;
+
+    self->write = write;
+  }
+
+  Py_INCREF(file);
+
+  self->file  = file;
+  self->bin   = bin;
+  self->memo  = memo;
+  self->arg   = NULL;
+  self->pers_func = NULL;
+
+  return self;
+
+err:
+  Py_XDECREF((PyObject *)self);
+  Py_XDECREF(memo);
+  return NULL;
+}
+
+
+static PyObject *
+get_Pickler(ARG(PyObject *, self), ARG(PyObject *, args))
+    ARGDECL(PyObject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *file;
+  int bin = 0;
+
+  UNLESS(PyArg_ParseTuple(args, "O|i", &file, &bin))  return NULL;
+  return (PyObject *)newPicklerobject(file, bin);
+}
+
+
+static void
+Pickler_dealloc(ARG(Picklerobject *, self))
+    ARGDECL(Picklerobject *, self)
+{
+  Py_XDECREF(self->write);
+  Py_XDECREF(self->memo);
+  Py_XDECREF(self->arg);
+  Py_XDECREF(self->file);
+  Py_XDECREF(self->pers_func);
+  PyMem_DEL(self);
+}
+
+
+static PyObject *
+Pickler_getattr(ARG(Picklerobject *, self), ARG(char *, name))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(char *, name)
+{
+  if (!strcmp(name, "persistent_id"))
+  {
+    if (!self->pers_func)
+    {
+      PyErr_SetString(PyExc_NameError, name);
+      return NULL;
+    }
+
+    Py_INCREF(self->pers_func);
+    return self->pers_func;
+  }
+
+  if (!strcmp(name, "memo"))
+  {
+    if (!self->memo)
+    {
+      PyErr_SetString(PyExc_NameError, name);
+      return NULL;
+    }
+
+    Py_INCREF(self->memo);
+    return self->memo;
+  }
+
+  if (!strcmp(name, "PicklingError"))
+  {
+    Py_INCREF(PicklingError);
+    return PicklingError;
+  }
+  
+  return Py_FindMethod(Pickler_methods, (PyObject *)self, name);
+}
+
+
+int 
+Pickler_setattr(ARG(Picklerobject *, self), ARG(char *, name), ARG(PyObject *, value))
+    ARGDECL(Picklerobject *, self)
+    ARGDECL(char *, name)
+    ARGDECL(PyObject *, value)
+{
+  if (!strcmp(name, "persistent_id"))
+  {
+    Py_XDECREF(self->pers_func);
+    self->pers_func = value;
+    Py_INCREF(value);
+    return 0;
+  }
+
+  return -1;
+}
+
+
+static char Picklertype__doc__[] = "";
+
+static PyTypeObject Picklertype = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,				/*ob_size*/
+	"Pickler",			/*tp_name*/
+	sizeof(Picklerobject),		/*tp_basicsize*/
+	0,				/*tp_itemsize*/
+	/* methods */
+	(destructor)Pickler_dealloc,	/*tp_dealloc*/
+	(printfunc)0,		/*tp_print*/
+	(getattrfunc)Pickler_getattr,	/*tp_getattr*/
+	(setattrfunc)Pickler_setattr,	/*tp_setattr*/
+	(cmpfunc)0,		/*tp_compare*/
+	(reprfunc)0,		/*tp_repr*/
+	0,			/*tp_as_number*/
+	0,		/*tp_as_sequence*/
+	0,		/*tp_as_mapping*/
+	(hashfunc)0,		/*tp_hash*/
+	(ternaryfunc)0,		/*tp_call*/
+	(reprfunc)0,		/*tp_str*/
+
+	/* Space for future expansion */
+	0L,0L,0L,0L,
+	Picklertype__doc__ /* Documentation string */
+};
+
+
+static PyObject *
+find_class(ARG(char *, module_name), ARG(char *, class_name))
+    ARGDECL(char *, module_name)
+    ARGDECL(char *, class_name)
+{
+  PyObject *import = 0, *class = 0, *py_module_name = 0, *py_class_name = 0,
+           *t = 0;
+  char *error_str;
+  int has_key;
+
+  UNLESS(py_module_name = PyString_FromString(module_name))
+    return NULL;
+
+  UNLESS(py_class_name = PyString_FromString(class_name))
+    goto err;
+
+  UNLESS(t = PyTuple_New(2))
+    goto err;
+
+  UNLESS(PyTuple_SET_ITEM((PyTupleObject *)t, 0, py_module_name))
+    goto err;
+  Py_INCREF(py_module_name);
+  
+  UNLESS(PyTuple_SET_ITEM((PyTupleObject *)t, 1, py_class_name))
+    goto err;
+  Py_INCREF(py_module_name);
+
+  if ((has_key = PyMapping_HasKey(class_map, t)) == -1)
+    goto err;
+
+  if (has_key)
+  {    
+    UNLESS(class = PyDict_GetItem(class_map, t))
+      goto err;
+
+    Py_INCREF(class);
+  
+    Py_DECREF(py_module_name);
+    Py_DECREF(py_class_name);
+    Py_DECREF(t);
+
+    return class;
+  }
+
+  if (!(import = PyImport_ImportModule(module_name)) ||
+      !(class = PyObject_GetAttrString(import, class_name)))
+  {
+    UNLESS(error_str = (char *)malloc((strlen(module_name) + 
+        strlen(class_name)  + 40) * sizeof(char)))
+    {
+      PyErr_SetString(PyExc_MemoryError, "out of memory");
+      goto err;
+    }
+
+    sprintf(error_str, "Failed to import class %s from module %s",
+        class_name, module_name);
+
+    PyErr_SetString(PyExc_SystemError, error_str);
+   
+    free(error_str);
+    goto err;
+  }
+
+  if (class->ob_type == BuiltinFunctionType)
+  {
+    UNLESS(error_str = (char *)malloc((strlen(module_name) + 
+        strlen(class_name)  + 45) * sizeof(char)))
+    {
+      PyErr_SetString(PyExc_MemoryError, "out of memory");
+      goto err;
+    }
+
+    sprintf(error_str, "Imported object %s from module %s is not a class",
+        class_name, module_name);
+
+    PyErr_SetString(PyExc_SystemError, error_str);
+   
+    free(error_str);
+    goto err;
+  }
+
+  if (PyDict_SetItem(class_map, t, class) == -1)
+    goto err;
+
+  Py_DECREF(t);
+  Py_DECREF(py_module_name);
+  Py_DECREF(py_class_name);
+  Py_DECREF(import);
+
+  return class;
+
+err:
+  Py_XDECREF(import);
+  Py_XDECREF(class);
+  Py_XDECREF(t);
+  Py_XDECREF(py_module_name);
+  Py_XDECREF(py_class_name);
+ 
+  return NULL;
+}
+
+
+int
+marker(ARG(Unpicklerobject *, self))
+    ARGDECL(Unpicklerobject *, self)
+{
+  if (!self->num_marks)
+    return -1;
+
+  return self->marks[--self->num_marks];
+}
+
+    
+static PyObject *
+load_none(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  if (PyList_Append(self->stack, Py_None) == -1)
+    return NULL;
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *
+load_int(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *py_int = 0;
+  char *s, *endptr;
+  int len;
+  long l;
+
+  if ((len = (*self->readline_func)(self, &s)) == -1)
+    return NULL;
+
+  errno = 0;
+  l = strtol(s, &endptr, 0);
+
+  free(s);
+  
+  if (errno || strlen(endptr))
+  {
+    PyErr_SetString(PyExc_ValueError, "could not convert string to int");
+    goto err;
+  }
+
+  UNLESS(py_int = PyInt_FromLong(l))
+    goto err;
+
+  if (PyList_Append(self->stack, py_int) == -1)
+    goto err;
+
+  Py_DECREF(py_int);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(py_int);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_binint(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *py_int = 0;
+  char *s;
+  unsigned char c;
+  long l;
+
+  UNLESS(s = (char *)malloc(4 * sizeof(char)))
+  {
+   PyErr_SetString(PyExc_MemoryError, "out of memory");
+    return NULL;
+  }
+
+  if ((*self->read_func)(self, &s, 4) == -1)
+  {
+    free(s);
+    return NULL;
+  }
+
+  c = (unsigned char)s[0];
+  l  = (long)c;
+  c = (unsigned char)s[1];
+  l |= (long)c << 8;
+  c = (unsigned char)s[2];
+  l |= (long)c << 16;
+  c = (unsigned char)s[3];
+  l |= (long)c << 24;
+
+  free(s);
+
+  UNLESS(py_int = PyInt_FromLong(l))
+    return NULL;
+
+  if (PyList_Append(self->stack, py_int) == -1)
+  {
+    Py_DECREF(py_int);
+    return NULL;
+  }
+
+  Py_DECREF(py_int);
+    
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *
+load_binint1(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *py_int = 0;
+  char *s;
+  unsigned char c;
+  long l;
+
+  UNLESS(s = (char *)malloc(3 * sizeof(char)))
+  {
+    PyErr_SetString(PyExc_MemoryError, "out of memory");
+    return NULL;
+  }
+
+  if ((*self->read_func)(self, &s, 3) == -1)
+  {
+    free(s);
+    return NULL;
+  }
+
+  c = (unsigned char)s[0];
+  l  = (long)c;
+  c = (unsigned char)s[1];
+  l |= (long)c << 8;
+  c = (unsigned char)s[2];
+  l |= (long)c << 16;
+
+  free(s);
+
+  UNLESS(py_int = PyInt_FromLong(l))
+    return NULL;
+
+  if (PyList_Append(self->stack, py_int) == -1)
+  {
+    Py_DECREF(py_int);
+    return NULL;
+  }
+
+  Py_DECREF(py_int);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *
+load_binint2(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *py_int = 0;
+  char *s;
+  unsigned char c;
+  long l;
+
+  UNLESS(s = (char *)malloc(2 * sizeof(char)))
+  {
+    PyErr_SetString(PyExc_MemoryError, "out of memory");
+    return NULL;
+  }
+
+  if ((*self->read_func)(self, &s, 2) == -1)
+    return NULL;
+
+  c = (unsigned char)s[0];
+  l  = (long)c;
+  c = (unsigned char)s[1];
+  l |= (long)c << 8;
+
+  free(s);
+
+  UNLESS(py_int = PyInt_FromLong(l))
+    return NULL;
+
+  if (PyList_Append(self->stack, py_int) == -1)
+  {
+    Py_DECREF(py_int);
+    return NULL;
+  }
+
+  Py_DECREF(py_int);
+    
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *
+load_binint3(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *py_int = 0;
+  char *s;
+  unsigned char c;
+  long l;
+
+  UNLESS(s = (char *)malloc(sizeof(char)))
+  {
+    PyErr_SetString(PyExc_MemoryError, "out of memory");
+    return NULL;
+  }
+
+  if ((*self->read_func)(self, &s, 1) == -1)
+  {
+    free(s);
+    return NULL;
+  }
+
+  c = (unsigned char)s[0];
+  l  = (long)c;
+
+  free(s);
+
+  UNLESS(py_int = PyInt_FromLong(l))
+    return NULL;
+
+  if (PyList_Append(self->stack, py_int) == -1)
+  {
+    Py_DECREF(py_int);
+    return NULL;
+  }
+
+  Py_DECREF(py_int);
+    
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *
+load_long(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *py_str = 0, *l = 0;
+  char *s;
+  int len;
+
+  static PyObject *arg;
+
+  if ((len = (*self->readline_func)(self, &s)) == -1)
+    return NULL;
+
+  UNLESS(py_str = PyString_FromStringAndSize(s, len))
+  {
+    free(s);
+    return NULL;
+  }
+
+  free(s);
+
+  UNLESS(arg)
+  {
+    UNLESS(arg = Py_BuildValue("(Oi)", py_str, 0))
+      return NULL;
+  }
+  else
+  {
+    if (PyTuple_SetItem(arg, 0, py_str) == -1)
+      goto err;
+    Py_INCREF(py_str);
+  }
+
+  UNLESS(l = PyObject_CallObject(atol_func, arg))
+    goto err;
+  
+  if (PyList_Append(self->stack, l) == -1)
+    goto err;
+
+  Py_DECREF(py_str);
+  Py_DECREF(l);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(l);
+  Py_XDECREF(py_str);
+
+  return NULL;
+}
+
+ 
+static PyObject *
+load_float(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *py_float = 0;
+  char *s, *endptr;
+  int len;
+  double d;
+
+  if ((len = (*self->readline_func)(self, &s)) == -1)
+    return NULL;
+
+  errno = 0;
+  d = strtod(s, &endptr);
+
+  free(s);
+  
+  if (errno || strlen(endptr))
+  {
+    PyErr_SetString(PyExc_ValueError, "could not convert string to long");
+    goto err;
+  }
+
+  UNLESS(py_float = PyFloat_FromDouble(d))
+    goto err;
+
+  if (PyList_Append(self->stack, py_float) == -1)
+    goto err;
+
+  Py_DECREF(py_float);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(py_float);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_string(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *str = 0;
+  char *s;
+  int len;
+  static PyObject *eval_dict = 0;
+
+  UNLESS(eval_dict)
+    UNLESS(eval_dict = Py_BuildValue("{s{}}", "__builtins__"))
+      return NULL;
+
+  if ((len = (*self->readline_func)(self, &s)) == -1)
+    return NULL;
+
+  UNLESS(str = PyRun_String(s, eval_input, eval_dict, eval_dict))
+  {
+    free(s);
+    goto err;
+  }
+
+  free(s);
+
+  if (PyList_Append(self->stack, str) == -1)
+    goto err;
+
+  Py_DECREF(str);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(str);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_binstring(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *py_string = 0;
+  char *s, *endptr;
+  int len, i;
+
+  if ((len = (*self->readline_func)(self, &s)) == -1)
+    return NULL;
+
+  i = atoi(s);
+
+  if (i > len)
+  {
+    free(s);
+
+    UNLESS(s = (char *)malloc(i * sizeof(char)))
+    {
+      PyErr_SetString(PyExc_MemoryError, "out of memory");
+      return NULL;
+    }
+  }
+
+  if ((*self->read_func)(self, &s, i) == -1)
+  {
+    free(s);
+    return NULL;
+  }
+
+  UNLESS(py_string = PyString_FromStringAndSize(s, i))
+  {
+    free(s);
+    return NULL;
+  }
+
+  free(s);
+
+  if (PyList_Append(self->stack, py_string) == -1)
+    goto err;
+
+  Py_DECREF(py_string);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(py_string);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_short_binstring(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *py_string = 0;
+  char *s;
+  unsigned char l;  
+
+
+  UNLESS(s = (char *)malloc(sizeof(char)))
+  {
+    PyErr_SetString(PyExc_MemoryError, "out of memory");
+    return NULL;
+  }
+
+  if ((*self->read_func)(self, &s, 1) == -1)
+  {
+    free(s);
+    return NULL;
+  }
+
+  l = (unsigned char)s[0];
+
+  if (l > 1)
+  {
+    free(s);
+
+    UNLESS(s = (char *)malloc(l * sizeof(char)))
+    {  
+      PyErr_SetString(PyExc_MemoryError, "out of memory");
+      return NULL;
+    }
+  }
+
+  if ((*self->read_func)(self, &s, l) == -1)
+  {
+    free(s);
+    return NULL;
+  }
+
+  UNLESS(py_string = PyString_FromStringAndSize(s, l))
+  {
+    free(s);
+    return NULL;
+  }
+
+  free(s);
+
+  if (PyList_Append(self->stack, py_string) == -1)
+  {
+    Py_DECREF(py_string);
+    return NULL;
+  }
+
+  Py_DECREF(py_string);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(py_string);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_tuple(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *tup = 0, *slice = 0, *list = 0;
+  int i, j;
+
+  if ((i = marker(self)) == -1)
+    return NULL;
+
+  if ((j = PyList_Size(self->stack)) == -1)  
+    goto err;
+
+  UNLESS(slice = PyList_GetSlice(self->stack, i, j))
+    goto err;
+  
+  UNLESS(tup = PySequence_Tuple(slice))
+    goto err;
+
+  UNLESS(list = PyList_New(1))
+    goto err;
+
+  if (PyList_SetItem(list, 0, tup) == -1)
+    goto err;
+
+  Py_INCREF(tup);
+
+  if (PyList_SetSlice(self->stack, i, j, list) == -1)
+    goto err;
+
+  Py_DECREF(tup);
+  Py_DECREF(list);
+  Py_DECREF(slice);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(tup);
+  Py_XDECREF(list);
+  Py_XDECREF(slice);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_list(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *list = 0, *slice = 0;
+  int i, j;
+
+  if ((i = marker(self)) == -1)
+    return NULL;
+
+  if ((j = PyList_Size(self->stack)) == -1)
+    goto err;
+
+  UNLESS(slice = PyList_GetSlice(self->stack, i, j))
+    goto err;
+
+  UNLESS(list = PyList_New(1))
+    goto err;
+
+  if (PyList_SetItem(list, 0, slice) == -1)
+    goto err;
+  Py_INCREF(slice);
+
+  if (PyList_SetSlice(self->stack, i, j, list) == -1)
+    goto err;
+
+  Py_DECREF(list);
+  Py_DECREF(slice);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(list);
+  Py_XDECREF(slice);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_dict(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *list = 0, *dict = 0, *key = 0, *value = 0;
+  int i, j, k;
+
+  if ((i = marker(self)) == -1)
+    return NULL;
+
+  if ((j = PyList_Size(self->stack)) == -1)
+    goto err;
+
+  UNLESS(dict = PyDict_New())
+    goto err;
+
+  for (k = i; k < j; k += 2)
+  {
+    UNLESS(key = PyList_GET_ITEM((PyListObject *)self->stack, k))
+      goto err;
+
+    UNLESS(value = PyList_GET_ITEM((PyListObject *)self->stack, k + 1))
+      goto err;
+
+    if (PyDict_SetItem(dict, key, value) == -1)
+      goto err;
+  }
+
+  UNLESS(list = PyList_New(1))
+    goto err;
+
+  if (PyList_SetItem(list, 0, dict) == -1)
+    goto err;
+  Py_INCREF(dict);
+
+  if (PyList_SetSlice(self->stack, i, j, list) == -1)
+    goto err;
+
+  Py_DECREF(list);
+  Py_DECREF(dict);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(dict);
+  Py_XDECREF(list);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_obj(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *class = 0, *slice = 0, *tup = 0, *obj = 0;
+  long i;
+  int len;
+
+  if ((i = marker(self)) == -1)
+    return NULL;
+
+  class = PyList_GET_ITEM((PyListObject *)self->stack, i);
+  Py_INCREF(class);
+
+  if ((len = PyList_Size(self->stack)) == -1)
+    goto err;
+
+  UNLESS(slice = PyList_GetSlice(self->stack, i + 1, len))
+    goto err;
+
+  UNLESS(tup = PySequence_Tuple(slice))
+    goto err;
+
+  if (DEL_LIST_SLICE(self->stack, i, len) == -1)
+    goto err;
+
+  UNLESS(obj = PyInstance_New(class, tup, NULL))
+    goto err;
+
+  if (PyList_Append(self->stack, obj) == -1)
+    goto err;
+
+  Py_DECREF(class);
+  Py_DECREF(slice);
+  Py_DECREF(tup);
+  Py_DECREF(obj);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(class);
+  Py_XDECREF(slice);
+  Py_XDECREF(tup);
+  Py_XDECREF(obj);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_inst(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *arg_tup = 0, *arg_slice = 0, *class = 0, *obj = 0;
+  int i, j, len;
+  char *s, *module_name, *class_name;
+
+  if ((i = marker(self)) == -1)
+    return NULL;
+
+  if ((j = PyList_Size(self->stack)) == -1)
+    goto err;
+
+  UNLESS(arg_slice = PyList_GetSlice(self->stack, i, j))
+    goto err;
+
+  UNLESS(arg_tup = PySequence_Tuple(arg_slice))
+    goto err;
+
+  if (DEL_LIST_SLICE(self->stack, i, j) == -1)
+    goto err;
+
+  if ((*self->readline_func)(self, &s) == -1)
+    goto err;
+
+  module_name = s;
+
+  if ((*self->readline_func)(self, &s) == -1)
+  {
+    free(module_name);
+    goto err;
+  }
+
+  class_name = s;
+
+  UNLESS(class = find_class(module_name, class_name))
+  {
+    free(module_name);
+    free(class_name);
+    goto err;
+  }
+
+  free(module_name);
+  free(class_name);
+
+  UNLESS(obj = PyInstance_New(class, arg_tup, NULL))
+    goto err;
+
+  if (PyList_Append(self->stack, obj) == -1)
+    goto err;
+
+  Py_DECREF(arg_slice);
+  Py_DECREF(arg_tup);
+  Py_DECREF(class);
+  Py_DECREF(obj);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(arg_slice);
+  Py_XDECREF(arg_tup);
+  Py_XDECREF(class);
+  Py_XDECREF(obj);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_class(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *class = 0;
+  char *s, *module_name, *class_name;
+
+  if ((*self->readline_func)(self, &s) == -1)
+    return NULL;
+
+  module_name = s;
+
+  if ((*self->readline_func)(self, &s) == -1)
+  {
+    free(module_name);
+    return NULL;
+  }
+
+  class_name = s;
+
+  UNLESS(class = find_class(module_name, class_name))
+  {
+    free(module_name);
+    free(class_name);
+    return NULL;
+  }
+
+  free(module_name);
+  free(class_name);
+
+  if (PyList_Append(self->stack, class) == -1)
+    goto err;
+
+  Py_DECREF(class);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(class);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_persid(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *pid = 0, *pers_load_val = 0;
+  char *s;
+  int len;
+
+  if (self->pers_func)
+  {
+    if ((len = (*self->readline_func)(self, &s)) == -1)
+      return NULL;
+  
+    UNLESS(pid = PyString_FromStringAndSize(s, len))
+    { 
+      free(s);
+      return NULL;
+    }
+
+    free(s);
+
+    UNLESS(self->arg)
+      UNLESS(self->arg = PyTuple_New(1))
+        goto err;
+
+    if (PyTuple_SetItem(self->arg, 0, pid) == -1)
+      goto err;
+    Py_INCREF(pid);
+      
+    UNLESS(pers_load_val = PyObject_CallObject(self->pers_func, self->arg))
+      goto err;
+
+    if (PyList_Append(self->stack, pers_load_val) == -1)
+      goto err;
+
+    Py_DECREF(pid);
+    Py_DECREF(pers_load_val);
+  
+    Py_INCREF(Py_None);
+    return Py_None;
+  }
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(pid);
+  Py_XDECREF(pers_load_val);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_pop(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  int len;
+
+  if ((len = PyList_Size(self->stack)) == -1)  
+    return NULL;
+
+  if (DEL_LIST_SLICE(self->stack, len - 1, len) == -1)  
+    return NULL;
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *
+load_dup(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *last;
+  int len;
+
+  if ((len = PyList_Size(self->stack)) == -1)
+    return NULL;
+  
+  UNLESS(last = PyList_GetItem(self->stack, len - 1))  
+    return NULL;
+
+  if (PyList_Append(self->stack, last) == -1)
+    return NULL;
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *
+load_get(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *py_str = 0, *value = 0;
+  char *s;
+  int len;
+
+  if ((len = (*self->readline_func)(self, &s)) == -1)
+    return NULL;
+
+  UNLESS(py_str = PyString_FromStringAndSize(s, len))
+  {
+    free(s);
+    return NULL;
+  }
+
+  free(s);
+  
+  UNLESS(value = PyDict_GetItem(self->memo, py_str))  
+    goto err;
+
+  if (PyList_Append(self->stack, value) == -1)
+    goto err;
+
+  Py_DECREF(py_str);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(py_str);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_binget(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *py_key = 0, *value = 0;
+  char *s;
+  unsigned char key;
+
+  UNLESS(s = (char *)malloc(sizeof(char)))
+  {
+    PyErr_SetString(PyExc_MemoryError, "out of memory");
+    return NULL;
+  }
+
+  if ((*self->read_func)(self, &s, 1) == -1)
+  {
+    free(s);
+    return NULL;
+  }
+
+  key = (unsigned char)s[0];
+  free(s);
+
+  UNLESS(py_key = PyInt_FromLong((long)key))
+    return NULL;
+
+  UNLESS(value = PyDict_GetItem(self->memo, py_key))  
+    goto err;
+
+  if (PyList_Append(self->stack, value) == -1)
+    return NULL;
+
+  Py_DECREF(py_key);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(py_key);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_put(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *py_str = 0, *value = 0;
+  int len;
+  char *s;
+
+  if ((len = (*self->readline_func)(self, &s)) == -1)
+    return NULL;
+
+  UNLESS(py_str = PyString_FromStringAndSize(s, len))
+  {
+    free(s);
+    return NULL;
+  }
+
+  free(s);
+
+  if ((len = PyList_Size(self->stack)) == -1)
+    goto err;
+
+  UNLESS(value = PyList_GetItem(self->stack, len - 1))  
+    goto err;
+
+  if (PyDict_SetItem(self->memo, py_str, value) == -1)  
+    goto err;
+
+  Py_DECREF(py_str);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(py_str);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_binput(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *py_key = 0, *value = 0;
+  char *s;
+  unsigned char key;
+  int len;
+
+  UNLESS(s = (char *)malloc(sizeof(char)))
+  {
+    PyErr_SetString(PyExc_MemoryError, "out of memory");
+    return NULL;
+  }
+
+  if ((*self->read_func)(self, &s, 1) == -1)
+    return NULL;
+
+  key = (unsigned char)s[0];
+
+  free(s);
+
+  UNLESS(py_key = PyInt_FromLong((long)key))
+    return NULL;
+
+  if ((len = PyList_Size(self->stack)) == -1)
+    goto err;
+
+  UNLESS(value = PyList_GetItem(self->stack, len - 1))  
+    goto err;
+
+  if (PyDict_SetItem(self->memo, py_key, value) == -1)  
+    goto err;
+
+  Py_DECREF(py_key);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(py_key);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_append(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *value = 0, *list = 0;
+  int len;
+  static PyObject *append_str = 0;
+
+  UNLESS(append_str)
+    UNLESS(append_str = PyString_FromString("append"))
+      return NULL;
+
+  if ((len = PyList_Size(self->stack)) == -1)  
+    return NULL;
+
+  UNLESS(value = PyList_GetItem(self->stack, len - 1))  
+    return NULL;
+  Py_INCREF(value);
+
+  if (DEL_LIST_SLICE(self->stack, len - 1, len) == -1)  
+    goto err;
+
+  UNLESS(list = PyList_GetItem(self->stack, len - 2))  
+    goto err;
+
+  if (PyList_Check(list))
+  {
+    if (PyList_Append(list, value) == -1)
+      goto err;
+  }
+  else
+  {
+    PyObject *append_method, *junk;
+
+    UNLESS(append_method = PyObject_GetAttr(list, append_str))
+      return NULL;
+
+    UNLESS(self->arg)
+      UNLESS(self->arg = PyTuple_New(1))
+      {
+        Py_DECREF(append_method);
+        goto err;
+      }
+
+    if (PyTuple_SetItem(self->arg, 0, value) == -1)
+    {
+      Py_DECREF(append_method);
+      goto err;
+    }
+    Py_INCREF(value);
+
+    UNLESS(junk = PyObject_CallObject(append_method, self->arg))
+    {
+      Py_DECREF(append_method);
+      goto err;
+    }
+    Py_DECREF(junk);
+
+    Py_DECREF(append_method);
+  }
+
+  Py_DECREF(value);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(value);
+ 
+  return NULL;
+}
+
+
+static PyObject *
+load_setitem(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *value = 0, *key = 0, *dict = 0;
+  int len;
+
+  if ((len = PyList_Size(self->stack)) == -1)  
+    return NULL;
+
+  UNLESS(value = PyList_GetItem(self->stack, len - 1))
+    return NULL;
+  Py_INCREF(value);
+
+  UNLESS(key = PyList_GetItem(self->stack, len - 2))  
+    goto err;
+  Py_INCREF(key);
+
+  if (DEL_LIST_SLICE(self->stack, len - 2, len) == -1)  
+    goto err;
+
+  UNLESS(dict = PyList_GetItem(self->stack, len - 3))  
+    goto err;
+
+  if (PyObject_SetItem(dict, key, value) == -1)  
+    goto err;
+
+  Py_DECREF(value);
+  Py_DECREF(key);
+  
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(value);
+  Py_XDECREF(key);
+
+  return NULL;
+}
+
+
+static PyObject *
+load_build(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *value = 0, *inst = 0, *instdict = 0, *d_key = 0, *d_value = 0, 
+           *junk = 0;
+  static PyObject *py_string__dict__;
+  int len, i;
+
+  UNLESS(py_string__dict__)
+    UNLESS(py_string__dict__ = PyString_FromString("__dict__"))
+      return NULL;
+
+  if ((len = PyList_Size(self->stack)) == -1)
+    goto err;
+
+  UNLESS(value = PyList_GetItem(self->stack, len - 1))
+    goto err; 
+  Py_INCREF(value);
+
+  if (DEL_LIST_SLICE(self->stack, len - 1, len) == -1)
+    goto err;
+
+  UNLESS(inst = PyList_GetItem(self->stack, len - 2))
+    goto err;
+
+  UNLESS(PyObject_HasAttrString(inst, "__setstate__"))
+  {
+    UNLESS(instdict = PyObject_GetAttr(inst, py_string__dict__))
+      goto err;
+
+    i = 0;
+    while (PyDict_Next(value, &i, &d_key, &d_value))
+    {
+      if (PyObject_SetItem(instdict, d_key, d_value) == -1)
+        goto err;
+    }
+  }
+  else
+  {
+    UNLESS(junk = PyObject_CallMethod(inst, "__setstate__", "O", value))
+      goto err;
+    Py_DECREF(junk);
+  }
+
+  Py_DECREF(value);
+  Py_XDECREF(instdict);
+
+  Py_INCREF(Py_None);
+  return Py_None;
+
+err:
+  Py_XDECREF(value);
+  Py_XDECREF(instdict);
+  
+  return NULL;
+}
+
+
+static PyObject *
+load_mark(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  int len;
+  
+  if ((len = PyList_Size(self->stack)) == -1)
+    return NULL;
+
+  if (!self->num_marks)
+  {
+    UNLESS(self->marks = (int *)malloc(20 * sizeof(int)))
+    {
+      PyErr_SetString(PyExc_MemoryError, "out of memory");
+      return NULL;
+    }
+ 
+    self->marks_size = 20;
+  }
+  else if ((self->num_marks + 1) > self->marks_size)
+  {
+    UNLESS(self->marks = (int *)realloc(self->marks, (self->marks_size + 20) * sizeof(int)))
+    {
+      PyErr_SetString(PyExc_MemoryError, "out of memory");
+      return NULL;
+    }
+
+    self->marks_size += 20;
+  }
+
+  self->marks[self->num_marks++] = len;
+
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+
+static PyObject *  
+load_eof(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyErr_SetNone(PyExc_EOFError);
+  return NULL;
+}
+
+
+static PyObject *
+Unpickler_load(ARG(Unpicklerobject *, self), ARG(PyObject *, args))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *stack = 0, *key = 0, *junk = 0, *err = 0,
+           *exc = 0, *val = 0, *tb = 0, *str = 0,
+           *key_repr = 0;
+  char c;
+  char *c_str;
+  int len;
+
+  c_str=&c;
+
+  UNLESS(stack = PyList_New(0))
+    goto err;
+
+  self->stack = stack;
+  self->num_marks = 0;
+
+  while (1)
+  {
+    if ((*self->read_func)(self, &c_str, 1) == -1)
+      break;
+
+    switch (c_str[0])
+    {
+      case NONE:
+        UNLESS(junk = load_none(self, NULL))
+          break;
+        continue;
+
+      case BININT:
+        UNLESS(junk = load_binint(self, NULL))
+          break;
+        continue;
+
+      case BININT1:
+        UNLESS(junk = load_binint1(self, NULL))
+          break;
+        continue;
+
+      case BININT2:
+        UNLESS(junk = load_binint2(self, NULL))
+          break;
+        continue;
+
+      case BININT3:
+        UNLESS(junk = load_binint3(self, NULL))
+          break;
+        continue;
+ 
+      case INT:
+        UNLESS(junk = load_int(self, NULL))
+          break;
+        continue;
+      
+      case LONG:
+        UNLESS(junk = load_long(self, NULL))
+          break;
+        continue;
+
+      case FLOAT:
+        UNLESS(junk = load_float(self, NULL))
+          break;
+        continue;
+
+      case BINSTRING:
+        UNLESS(junk = load_binstring(self, NULL))
+          break;
+        continue;
+
+      case SHORT_BINSTRING:
+        UNLESS(junk = load_short_binstring(self, NULL))
+          break;
+        continue;
+
+      case STRING:
+        UNLESS(junk = load_string(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case TUPLE:
+        UNLESS(junk = load_tuple(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case LIST:
+        UNLESS(junk = load_list(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case DICT:
+        UNLESS(junk = load_dict(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case OBJ:
+        UNLESS(junk = load_obj(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case INST:
+        UNLESS(junk = load_inst(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case CLASS:
+        UNLESS(junk = load_class(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case APPEND:
+        UNLESS(junk = load_append(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case BUILD:
+        UNLESS(junk = load_build(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+  
+      case DUP:
+        UNLESS(junk = load_dup(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case BINGET:
+        UNLESS(junk = load_binget(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case GET:
+        UNLESS(junk = load_get(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case MARK:
+        UNLESS(junk = load_mark(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case BINPUT:
+        UNLESS(junk = load_binput(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case PUT:
+        UNLESS(junk = load_put(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case POP:
+        UNLESS(junk = load_pop(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case SETITEM:
+        UNLESS(junk = load_setitem(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      case STOP:
+        break;
+
+      case PERSID:
+        UNLESS(junk = load_persid(self, NULL))
+          break;
+        Py_DECREF(junk);
+        continue;
+
+      default: 
+        UNLESS(key = PyString_FromStringAndSize(c_str, 1))
+          return NULL;
+  
+        UNLESS(key_repr = PyObject_Repr(key))
+          return NULL;
+        
+        UNLESS(str = PyString_FromStringAndSize(NULL, 19 + PyString_Size(key_repr)))
+          return NULL;
+
+        sprintf(PyString_AS_STRING((PyStringObject *)str), 
+            "invalid load key, \%s\.", PyString_AS_STRING((PyStringObject *)key_repr));
+
+        PyErr_SetObject(UnpicklingError, str);
+
+        Py_DECREF(str);
+        Py_DECREF(key);
+        Py_DECREF(key_repr);
+
+        return NULL;
+    }
+
+    break;
+  }
+
+  if ((err = PyErr_Occurred()) == PyExc_EOFError)
+  {
+    return load_eof(self, NULL);
+  }    
+
+  if (err)    
+    return NULL;
+
+  if ((len = PyList_Size(self->stack)) == -1)  
+    return NULL;
+
+  UNLESS(val = PyList_GetItem(self->stack, len - 1))  
+    return NULL;
+  Py_INCREF(val);
+
+  if (DEL_LIST_SLICE(self->stack, len - 1, len) == -1)
+  {
+    Py_DECREF(val);
+    return NULL;
+  }
+
+  return val;
+
+err:
+  Py_XDECREF(stack);
+
+  return NULL;
+}
+
+
+static struct PyMethodDef Unpickler_methods[] = 
+{
+  {"load",         (PyCFunction)Unpickler_load,   0, ""},
+  {"load_none",    (PyCFunction)load_none,        0, ""},
+  {"load_int",     (PyCFunction)load_int,         0, ""},
+  {"load_long",    (PyCFunction)load_long,        0, ""},
+  {"load_float",   (PyCFunction)load_float,       0, ""},
+  {"load_string",  (PyCFunction)load_string,      0, ""},
+  {"load_tuple",   (PyCFunction)load_tuple,       0, ""},
+  {"load_list",    (PyCFunction)load_list,        0, ""},
+  {"load_dict",    (PyCFunction)load_dict,        0, ""},
+  {"load_inst",    (PyCFunction)load_inst,        0, ""},
+  {"load_class",   (PyCFunction)load_class,       0, ""},
+  {"load_persid",  (PyCFunction)load_persid,      0, ""},
+  {"load_pop",     (PyCFunction)load_pop,         0, ""},
+  {"load_dup",     (PyCFunction)load_dup,         0, ""},
+  {"load_get",     (PyCFunction)load_get,         0, ""},
+  {"load_put",     (PyCFunction)load_put,         0, ""},
+  {"load_append",  (PyCFunction)load_append,      0, ""},
+  {"load_setitem", (PyCFunction)load_setitem,     0, ""},
+  {"load_build",   (PyCFunction)load_build,       0, ""},
+  {"load_mark",    (PyCFunction)load_mark,        0, ""},
+  {"load_eof",     (PyCFunction)load_eof,         0, ""},
+  {NULL,		NULL}		/* sentinel */
+};
+
+
+static Unpicklerobject *
+newUnpicklerobject(ARG(PyObject *, f))
+    ARGDECL(PyObject *, f)
+{
+  Unpicklerobject *self;
+  PyObject *memo = 0;
+	
+  UNLESS(memo = PyDict_New())
+    goto err;
+
+  UNLESS(self = PyObject_NEW(Unpicklerobject, &Unpicklertype))  goto err;
+
+  if (PyFile_Check(f))
+  {
+    self->fp = PyFile_AsFile(f);
+    self->read_func = read_file;
+    self->readline_func = readline_file;
+    self->read = NULL;
+    self->readline = NULL;
+  }
+  else if (PycStringIO_InputCheck(f))
+  {
+    self->fp = NULL;
+    self->read_func = read_cStringIO;
+    self->readline_func = readline_cStringIO;
+    self->read = NULL;
+    self->readline = NULL;
+  }
+  else
+  {
+    PyObject *readline, *read;
+
+    self->fp = NULL;
+    self->read_func = read_other;
+    self->readline_func = readline_other;
+
+    UNLESS(readline = PyObject_GetAttrString(f, "readline"))
+      goto err;
+
+    UNLESS(read = PyObject_GetAttrString(f, "read"))
+    {
+      Py_DECREF(readline);
+      goto err;
+    }
+  
+    self->read = read; 
+    self->readline = readline;
+  }
+
+  Py_INCREF(f);
+  
+  self->file = f;
+  self->memo   = memo;
+  self->arg    = NULL;
+  self->stack  = NULL;
+  self->pers_func = NULL;
+  self->marks = NULL;
+  self->num_marks = 0;
+  self->marks_size = 0;
+
+  return self;
+
+err:
+  Py_XDECREF(memo);
+  Py_XDECREF((PyObject *)self);
+
+  return NULL;
+}
+
+
+static PyObject *
+get_Unpickler(ARG(PyObject *, self), ARG(PyObject *, args))
+    ARGDECL(PyObject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *file;
+
+  UNLESS(PyArg_Parse(args, "O", &file))  return NULL;
+  return (PyObject *)newUnpicklerobject(file);
+}
+
+
+static void
+Unpickler_dealloc(ARG(Unpicklerobject *, self))
+    ARGDECL(Unpicklerobject *, self)
+{
+  Py_XDECREF(self->readline);
+  Py_XDECREF(self->read);
+  Py_XDECREF(self->file);
+  Py_XDECREF(self->memo);
+  Py_XDECREF(self->stack);
+  Py_XDECREF(self->pers_func);
+  Py_XDECREF(self->arg);
+  free(self->marks);
+  PyMem_DEL(self);
+}
+
+
+static PyObject *
+Unpickler_getattr(ARG(Unpicklerobject *, self), ARG(char *, name))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(char *, name)
+{
+  if (!strcmp(name, "persistent_load"))
+  {
+    if (!self->pers_func)
+    {
+      PyErr_SetString(PyExc_NameError, name);
+      return NULL;
+    }
+
+    Py_INCREF(self->pers_func);
+    return self->pers_func;
+  }
+
+  if (!strcmp(name, "memo"))
+  {
+    if (!self->memo)
+    {
+      PyErr_SetString(PyExc_NameError, name);
+      return NULL;
+    }
+
+    Py_INCREF(self->memo);
+    return self->memo;
+  }
+
+  if (!strcmp(name, "UnpicklingError"))
+  {
+    Py_INCREF(UnpicklingError);
+    return UnpicklingError;
+  }
+
+  return Py_FindMethod(Unpickler_methods, (PyObject *)self, name);
+}
+
+
+static int
+Unpickler_setattr(ARG(Unpicklerobject *, self), ARG(char *, name), ARG(PyObject *, value))
+    ARGDECL(Unpicklerobject *, self)
+    ARGDECL(char *, name)
+    ARGDECL(PyObject *, value)
+{
+  if (!strcmp(name, "persistent_load"))
+  {
+    Py_XDECREF(self->pers_func);
+    self->pers_func = value;
+    Py_INCREF(value);
+    return 0;
+  }
+
+  return -1;
+}
+
+
+static PyObject *
+dump(ARG(PyObject *, self), ARG(PyObject *, args))
+    ARGDECL(PyObject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *ob, *file, *ret_val;
+  Picklerobject *pickler;
+  int bin = 0;
+
+  UNLESS(PyArg_ParseTuple(args, "OO|i", &ob, &file, &bin))
+    return NULL;
+
+  UNLESS(pickler = newPicklerobject(file, bin))
+    return NULL;
+
+  UNLESS(ret_val = Pickler_dump(pickler, ob))
+  {
+    Pickler_dealloc(pickler);
+    return NULL;
+  }
+
+  Pickler_dealloc(pickler);
+
+  return ret_val;
+}
+
+
+static PyObject *
+dumps(ARG(PyObject *, self), ARG(PyObject *, args))
+    ARGDECL(PyObject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *ob, *file, *pickle_str;
+  Picklerobject *pickler;
+  int bin = 0;
+
+  UNLESS(PyArg_ParseTuple(args, "O|i", &ob, &bin))
+    return NULL;
+
+  UNLESS(file = (*PycStringIO_NewOutput)(128))
+    return NULL;
+
+  UNLESS(pickler = newPicklerobject(file, bin))
+  {
+    Py_DECREF(file);
+    return NULL;
+  }
+
+  UNLESS(Pickler_dump(pickler, ob))
+  {
+    Pickler_dealloc(pickler);
+    Py_DECREF(file);
+    return NULL;
+  }
+
+  Pickler_dealloc(pickler);
+
+  UNLESS(pickle_str = (*PycStringIO_cgetvalue)((PyObject *)file))
+  {
+    Py_DECREF(file);
+    return NULL;
+  }
+
+  Py_DECREF(file);
+
+  return pickle_str;
+}  
+  
+
+static PyObject *
+cpm_load(ARG(PyObject *, self), ARG(PyObject *, args))
+    ARGDECL(PyObject *, self)
+    ARGDECL(PyObject *, args)
+{
+  Unpicklerobject *unpickler;
+  PyObject *load_result;
+
+  UNLESS(PyArg_Parse(args, "O", &args))
+    return NULL;
+
+  UNLESS(unpickler = newUnpicklerobject(args))
+    return NULL;
+
+  UNLESS(load_result = Unpickler_load(unpickler, NULL))
+  {
+    Unpickler_dealloc(unpickler);
+    return NULL;
+  }
+
+  Py_DECREF(unpickler);
+
+  return load_result;
+}
+
+
+static PyObject *
+loads(ARG(PyObject *, self), ARG(PyObject *, args))
+    ARGDECL(PyObject *, self)
+    ARGDECL(PyObject *, args)
+{
+  PyObject *file, *load_result;
+  Unpicklerobject *unpickler;
+
+  UNLESS(PyArg_Parse(args, "O", &args))
+    return NULL;
+
+  UNLESS(file = (*PycStringIO_NewInput)(args))
+    return NULL;
+  
+  UNLESS(unpickler = newUnpicklerobject(file))
+  {
+    Py_DECREF(file);
+    return NULL;
+  }
+
+  UNLESS(load_result = Unpickler_load(unpickler, NULL))
+  {
+    Unpickler_dealloc(unpickler);
+    Py_DECREF(file);
+    return NULL;
+  }
+
+  Py_DECREF(file);
+  Unpickler_dealloc(unpickler);
+
+  return load_result;
+}
+
+
+static char Unpicklertype__doc__[] = "";
+
+static PyTypeObject Unpicklertype = 
+{
+  PyObject_HEAD_INIT(&PyType_Type)
+  0,				/*ob_size*/
+  "Unpickler",			/*tp_name*/
+  sizeof(Unpicklerobject),		/*tp_basicsize*/
+  0,				/*tp_itemsize*/
+  /* methods */
+  (destructor)Unpickler_dealloc,	/*tp_dealloc*/
+  (printfunc)0,		/*tp_print*/
+  (getattrfunc)Unpickler_getattr,	/*tp_getattr*/
+  (setattrfunc)Unpickler_setattr,	/*tp_setattr*/
+  (cmpfunc)0,		/*tp_compare*/
+  (reprfunc)0,		/*tp_repr*/
+  0,			/*tp_as_number*/
+  0,		/*tp_as_sequence*/
+  0,		/*tp_as_mapping*/
+  (hashfunc)0,		/*tp_hash*/
+  (ternaryfunc)0,		/*tp_call*/
+  (reprfunc)0,		/*tp_str*/
+
+  /* Space for future expansion */
+  0L,0L,0L,0L,
+  Unpicklertype__doc__ /* Documentation string */
+};
+
+
+static struct PyMethodDef cPickle_methods[] =
+{
+  {"dump",         (PyCFunction)dump,             1, ""},
+  {"dumps",        (PyCFunction)dumps,            1, ""},
+  {"load",         (PyCFunction)cpm_load,         0, ""},
+  {"loads",        (PyCFunction)loads,            0, ""},
+  {"Pickler",      (PyCFunction)get_Pickler,      1, ""},
+  {"Unpickler",    (PyCFunction)get_Unpickler,    0, ""},
+  { NULL, NULL }
+};
+
+
+static int
+init_stuff()
+{
+  PyObject *builtins, *apply_func, *string;
+
+  UNLESS(builtins = PyImport_ImportModule("__builtin__"))
+    return NULL;
+
+  UNLESS(apply_func = PyObject_GetAttrString(builtins, "apply"))
+    return NULL;
+
+  BuiltinFunctionType = apply_func->ob_type;
+
+  Py_DECREF(apply_func);
+
+  Py_DECREF(builtins);
+
+  UNLESS(string = PyImport_ImportModule("string"))
+    return NULL;
+
+  UNLESS(atol_func = PyObject_GetAttrString(string, "atol"))
+    return NULL;
+
+  Py_DECREF(string);
+
+  UNLESS(empty_list = PyList_New(0))
+    return NULL;
+
+  UNLESS(empty_tuple = PyTuple_New(0))
+    return NULL;
+
+  UNLESS(class_map = PyDict_New())
+    return NULL;
+
+  UNLESS(PicklingError = PyString_FromString("cPickle.PicklingError"))
+    return NULL;
+
+  UNLESS(UnpicklingError = PyString_FromString("cPickle.UnpicklingError"))
+    return NULL;
+
+  PycString_IMPORT;
+}
+
+
+#define CHECK_FOR_ERRORS(MESS) \
+if(PyErr_Occurred()) { \
+  PyObject *__sys_exc_type, *__sys_exc_value, *__sys_exc_traceback; \
+  PyErr_Fetch( &__sys_exc_type, &__sys_exc_value, &__sys_exc_traceback); \
+  fprintf(stderr, # MESS ":\n\t"); \
+  PyObject_Print(__sys_exc_type, stderr,0); \
+  fprintf(stderr,", "); \
+  PyObject_Print(__sys_exc_value, stderr,0); \
+  fprintf(stderr,"\n"); \
+  fflush(stderr); \
+  Py_FatalError(# MESS); \
+}
+
+
+/* Initialization function for the module (*must* be called initcPickle) */
+void
+initcPickle()
+{
+  PyObject *m, *d;
+
+  /* Create the module and add the functions */
+  m = Py_InitModule4("cPickle", cPickle_methods,
+      cPickle_module_documentation,
+      (PyObject*)NULL,PYTHON_API_VERSION);
+
+  /* Add some symbolic constants to the module */
+  d = PyModule_GetDict(m);
+  ErrorObject = PyString_FromString("cPickle.error");
+  PyDict_SetItemString(d, "error", ErrorObject);
+
+  /* XXXX Add constants here */
+
+  init_stuff();
+  CHECK_FOR_ERRORS("can't initialize module cPickle");
+
+  PyDict_SetItemString(d, "PicklingError", PicklingError);
+  CHECK_FOR_ERRORS("can't initialize module cPickle:  error creating PicklingError");
+
+  PyDict_SetItemString(d, "UnpicklingError", UnpicklingError);
+  CHECK_FOR_ERRORS("can't initialize module cPickle:  error creating UnpicklingError");  
+}