--- /dev/null
+#include "Python.h"\r
+#include "cStringIO.h"\r
+#include "structmember.h"\r
+\r
+PyDoc_STRVAR(cPickle_module_documentation,\r
+"C implementation and optimization of the Python pickle module.");\r
+\r
+#ifndef Py_eval_input\r
+#include <graminit.h>\r
+#define Py_eval_input eval_input\r
+#endif /* Py_eval_input */\r
+\r
+#define DEL_LIST_SLICE(list, from, to) (PyList_SetSlice(list, from, to, NULL))\r
+\r
+#define WRITE_BUF_SIZE 256\r
+\r
+/* Bump this when new opcodes are added to the pickle protocol. */\r
+#define HIGHEST_PROTOCOL 2\r
+\r
+/*\r
+ * Note: The UNICODE macro controls the TCHAR meaning of the win32 API. Since\r
+ * all headers have already been included here, we can safely redefine it.\r
+ */\r
+#ifdef UNICODE\r
+# undef UNICODE\r
+#endif\r
+\r
+/*\r
+ * Pickle opcodes. These must be kept in synch with pickle.py. Extensive\r
+ * docs are in pickletools.py.\r
+ */\r
+#define MARK '('\r
+#define STOP '.'\r
+#define POP '0'\r
+#define POP_MARK '1'\r
+#define DUP '2'\r
+#define FLOAT 'F'\r
+#define BINFLOAT 'G'\r
+#define INT 'I'\r
+#define BININT 'J'\r
+#define BININT1 'K'\r
+#define LONG 'L'\r
+#define BININT2 'M'\r
+#define NONE 'N'\r
+#define PERSID 'P'\r
+#define BINPERSID 'Q'\r
+#define REDUCE 'R'\r
+#define STRING 'S'\r
+#define BINSTRING 'T'\r
+#define SHORT_BINSTRING 'U'\r
+#define UNICODE 'V'\r
+#define BINUNICODE 'X'\r
+#define APPEND 'a'\r
+#define BUILD 'b'\r
+#define GLOBAL 'c'\r
+#define DICT 'd'\r
+#define EMPTY_DICT '}'\r
+#define APPENDS 'e'\r
+#define GET 'g'\r
+#define BINGET 'h'\r
+#define INST 'i'\r
+#define LONG_BINGET 'j'\r
+#define LIST 'l'\r
+#define EMPTY_LIST ']'\r
+#define OBJ 'o'\r
+#define PUT 'p'\r
+#define BINPUT 'q'\r
+#define LONG_BINPUT 'r'\r
+#define SETITEM 's'\r
+#define TUPLE 't'\r
+#define EMPTY_TUPLE ')'\r
+#define SETITEMS 'u'\r
+\r
+/* Protocol 2. */\r
+#define PROTO '\x80' /* identify pickle protocol */\r
+#define NEWOBJ '\x81' /* build object by applying cls.__new__ to argtuple */\r
+#define EXT1 '\x82' /* push object from extension registry; 1-byte index */\r
+#define EXT2 '\x83' /* ditto, but 2-byte index */\r
+#define EXT4 '\x84' /* ditto, but 4-byte index */\r
+#define TUPLE1 '\x85' /* build 1-tuple from stack top */\r
+#define TUPLE2 '\x86' /* build 2-tuple from two topmost stack items */\r
+#define TUPLE3 '\x87' /* build 3-tuple from three topmost stack items */\r
+#define NEWTRUE '\x88' /* push True */\r
+#define NEWFALSE '\x89' /* push False */\r
+#define LONG1 '\x8a' /* push long from < 256 bytes */\r
+#define LONG4 '\x8b' /* push really big long */\r
+\r
+/* There aren't opcodes -- they're ways to pickle bools before protocol 2,\r
+ * so that unpicklers written before bools were introduced unpickle them\r
+ * as ints, but unpicklers after can recognize that bools were intended.\r
+ * Note that protocol 2 added direct ways to pickle bools.\r
+ */\r
+#undef TRUE\r
+#define TRUE "I01\n"\r
+#undef FALSE\r
+#define FALSE "I00\n"\r
+\r
+/* Keep in synch with pickle.Pickler._BATCHSIZE. This is how many elements\r
+ * batch_list/dict() pumps out before doing APPENDS/SETITEMS. Nothing will\r
+ * break if this gets out of synch with pickle.py, but it's unclear that\r
+ * would help anything either.\r
+ */\r
+#define BATCHSIZE 1000\r
+\r
+static char MARKv = MARK;\r
+\r
+static PyObject *PickleError;\r
+static PyObject *PicklingError;\r
+static PyObject *UnpickleableError;\r
+static PyObject *UnpicklingError;\r
+static PyObject *BadPickleGet;\r
+\r
+/* As the name says, an empty tuple. */\r
+static PyObject *empty_tuple;\r
+\r
+/* copy_reg.dispatch_table, {type_object: pickling_function} */\r
+static PyObject *dispatch_table;\r
+\r
+/* For EXT[124] opcodes. */\r
+/* copy_reg._extension_registry, {(module_name, function_name): code} */\r
+static PyObject *extension_registry;\r
+/* copy_reg._inverted_registry, {code: (module_name, function_name)} */\r
+static PyObject *inverted_registry;\r
+/* copy_reg._extension_cache, {code: object} */\r
+static PyObject *extension_cache;\r
+\r
+/* For looking up name pairs in copy_reg._extension_registry. */\r
+static PyObject *two_tuple;\r
+\r
+static PyObject *__class___str, *__getinitargs___str, *__dict___str,\r
+ *__getstate___str, *__setstate___str, *__name___str, *__reduce___str,\r
+ *__reduce_ex___str,\r
+ *write_str, *append_str,\r
+ *read_str, *readline_str, *__main___str,\r
+ *dispatch_table_str;\r
+\r
+/*************************************************************************\r
+ Internal Data type for pickle data. */\r
+\r
+typedef struct {\r
+ PyObject_HEAD\r
+ Py_ssize_t length; /* number of initial slots in data currently used */\r
+ Py_ssize_t size; /* number of slots in data allocated */\r
+ PyObject **data;\r
+} Pdata;\r
+\r
+static void\r
+Pdata_dealloc(Pdata *self)\r
+{\r
+ Py_ssize_t i;\r
+ PyObject **p;\r
+\r
+ for (i = self->length, p = self->data; --i >= 0; p++) {\r
+ Py_DECREF(*p);\r
+ }\r
+ if (self->data)\r
+ free(self->data);\r
+ PyObject_Del(self);\r
+}\r
+\r
+static PyTypeObject PdataType = {\r
+ PyVarObject_HEAD_INIT(NULL, 0) "cPickle.Pdata", sizeof(Pdata), 0,\r
+ (destructor)Pdata_dealloc,\r
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0L,0L,0L,0L, ""\r
+};\r
+\r
+#define Pdata_Check(O) (Py_TYPE(O) == &PdataType)\r
+\r
+static PyObject *\r
+Pdata_New(void)\r
+{\r
+ Pdata *self;\r
+\r
+ if (!(self = PyObject_New(Pdata, &PdataType)))\r
+ return NULL;\r
+ self->size = 8;\r
+ self->length = 0;\r
+ self->data = malloc(self->size * sizeof(PyObject*));\r
+ if (self->data)\r
+ return (PyObject*)self;\r
+ Py_DECREF(self);\r
+ return PyErr_NoMemory();\r
+}\r
+\r
+static int\r
+stackUnderflow(void)\r
+{\r
+ PyErr_SetString(UnpicklingError, "unpickling stack underflow");\r
+ return -1;\r
+}\r
+\r
+/* Retain only the initial clearto items. If clearto >= the current\r
+ * number of items, this is a (non-erroneous) NOP.\r
+ */\r
+static int\r
+Pdata_clear(Pdata *self, Py_ssize_t clearto)\r
+{\r
+ Py_ssize_t i;\r
+ PyObject **p;\r
+\r
+ if (clearto < 0) return stackUnderflow();\r
+ if (clearto >= self->length) return 0;\r
+\r
+ for (i = self->length, p = self->data + clearto;\r
+ --i >= clearto;\r
+ p++) {\r
+ Py_CLEAR(*p);\r
+ }\r
+ self->length = clearto;\r
+\r
+ return 0;\r
+}\r
+\r
+static int\r
+Pdata_grow(Pdata *self)\r
+{\r
+ Py_ssize_t bigger;\r
+ Py_ssize_t nbytes;\r
+\r
+ PyObject **tmp;\r
+\r
+ if (self->size > (PY_SSIZE_T_MAX >> 1))\r
+ goto nomemory;\r
+ bigger = self->size << 1;\r
+ if (bigger > (PY_SSIZE_T_MAX / sizeof(PyObject *)))\r
+ goto nomemory;\r
+ nbytes = bigger * sizeof(PyObject *);\r
+ tmp = realloc(self->data, nbytes);\r
+ if (tmp == NULL)\r
+ goto nomemory;\r
+ self->data = tmp;\r
+ self->size = bigger;\r
+ return 0;\r
+\r
+ nomemory:\r
+ PyErr_NoMemory();\r
+ return -1;\r
+}\r
+\r
+/* D is a Pdata*. Pop the topmost element and store it into V, which\r
+ * must be an lvalue holding PyObject*. On stack underflow, UnpicklingError\r
+ * is raised and V is set to NULL. D and V may be evaluated several times.\r
+ */\r
+#define PDATA_POP(D, V) { \\r
+ if ((D)->length) \\r
+ (V) = (D)->data[--((D)->length)]; \\r
+ else { \\r
+ PyErr_SetString(UnpicklingError, "bad pickle data"); \\r
+ (V) = NULL; \\r
+ } \\r
+}\r
+\r
+/* PDATA_PUSH and PDATA_APPEND both push rvalue PyObject* O on to Pdata*\r
+ * D. If the Pdata stack can't be grown to hold the new value, both\r
+ * raise MemoryError and execute "return ER". The difference is in ownership\r
+ * of O after: _PUSH transfers ownership of O from the caller to the stack\r
+ * (no incref of O is done, and in case of error O is decrefed), while\r
+ * _APPEND pushes a new reference.\r
+ */\r
+\r
+/* Push O on stack D, giving ownership of O to the stack. */\r
+#define PDATA_PUSH(D, O, ER) { \\r
+ if (((Pdata*)(D))->length == ((Pdata*)(D))->size && \\r
+ Pdata_grow((Pdata*)(D)) < 0) { \\r
+ Py_DECREF(O); \\r
+ return ER; \\r
+ } \\r
+ ((Pdata*)(D))->data[((Pdata*)(D))->length++] = (O); \\r
+}\r
+\r
+/* Push O on stack D, pushing a new reference. */\r
+#define PDATA_APPEND(D, O, ER) { \\r
+ if (((Pdata*)(D))->length == ((Pdata*)(D))->size && \\r
+ Pdata_grow((Pdata*)(D)) < 0) \\r
+ return ER; \\r
+ Py_INCREF(O); \\r
+ ((Pdata*)(D))->data[((Pdata*)(D))->length++] = (O); \\r
+}\r
+\r
+\r
+static PyObject *\r
+Pdata_popTuple(Pdata *self, Py_ssize_t start)\r
+{\r
+ PyObject *r;\r
+ Py_ssize_t i, j, l;\r
+\r
+ l = self->length-start;\r
+ r = PyTuple_New(l);\r
+ if (r == NULL)\r
+ return NULL;\r
+ for (i = start, j = 0 ; j < l; i++, j++)\r
+ PyTuple_SET_ITEM(r, j, self->data[i]);\r
+\r
+ self->length = start;\r
+ return r;\r
+}\r
+\r
+static PyObject *\r
+Pdata_popList(Pdata *self, Py_ssize_t start)\r
+{\r
+ PyObject *r;\r
+ Py_ssize_t i, j, l;\r
+\r
+ l=self->length-start;\r
+ if (!( r=PyList_New(l))) return NULL;\r
+ for (i=start, j=0 ; j < l; i++, j++)\r
+ PyList_SET_ITEM(r, j, self->data[i]);\r
+\r
+ self->length=start;\r
+ return r;\r
+}\r
+\r
+/*************************************************************************/\r
+\r
+#define ARG_TUP(self, o) { \\r
+ if (self->arg || (self->arg=PyTuple_New(1))) { \\r
+ Py_XDECREF(PyTuple_GET_ITEM(self->arg,0)); \\r
+ PyTuple_SET_ITEM(self->arg,0,o); \\r
+ } \\r
+ else { \\r
+ Py_DECREF(o); \\r
+ } \\r
+}\r
+\r
+#define FREE_ARG_TUP(self) { \\r
+ if (Py_REFCNT(self->arg) > 1) { \\r
+ Py_CLEAR(self->arg); \\r
+ } \\r
+ }\r
+\r
+typedef struct Picklerobject {\r
+ PyObject_HEAD\r
+ FILE *fp;\r
+ PyObject *write;\r
+ PyObject *file;\r
+ PyObject *memo;\r
+ PyObject *arg;\r
+ PyObject *pers_func;\r
+ PyObject *inst_pers_func;\r
+\r
+ /* pickle protocol number, >= 0 */\r
+ int proto;\r
+\r
+ /* bool, true if proto > 0 */\r
+ int bin;\r
+\r
+ int fast; /* Fast mode doesn't save in memo, don't use if circ ref */\r
+ Py_ssize_t (*write_func)(struct Picklerobject *, const char *, Py_ssize_t);\r
+ char *write_buf;\r
+ Py_ssize_t buf_size;\r
+ PyObject *dispatch_table;\r
+ int fast_container; /* count nested container dumps */\r
+ PyObject *fast_memo;\r
+} Picklerobject;\r
+\r
+#ifndef PY_CPICKLE_FAST_LIMIT\r
+#define PY_CPICKLE_FAST_LIMIT 50\r
+#endif\r
+\r
+static PyTypeObject Picklertype;\r
+\r
+typedef struct Unpicklerobject {\r
+ PyObject_HEAD\r
+ FILE *fp;\r
+ PyObject *file;\r
+ PyObject *readline;\r
+ PyObject *read;\r
+ PyObject *memo;\r
+ PyObject *arg;\r
+ Pdata *stack;\r
+ PyObject *mark;\r
+ PyObject *pers_func;\r
+ PyObject *last_string;\r
+ Py_ssize_t *marks;\r
+ Py_ssize_t num_marks;\r
+ Py_ssize_t marks_size;\r
+ Py_ssize_t (*read_func)(struct Unpicklerobject *, char **, Py_ssize_t);\r
+ Py_ssize_t (*readline_func)(struct Unpicklerobject *, char **);\r
+ Py_ssize_t buf_size;\r
+ char *buf;\r
+ PyObject *find_class;\r
+} Unpicklerobject;\r
+\r
+static PyTypeObject Unpicklertype;\r
+\r
+/* Forward decls that need the above structs */\r
+static int save(Picklerobject *, PyObject *, int);\r
+static int put2(Picklerobject *, PyObject *);\r
+\r
+static\r
+PyObject *\r
+cPickle_ErrFormat(PyObject *ErrType, char *stringformat, char *format, ...)\r
+{\r
+ va_list va;\r
+ PyObject *args=0, *retval=0;\r
+ va_start(va, format);\r
+\r
+ if (format) args = Py_VaBuildValue(format, va);\r
+ va_end(va);\r
+ if (format && ! args) return NULL;\r
+ if (stringformat && !(retval=PyString_FromString(stringformat)))\r
+ return NULL;\r
+\r
+ if (retval) {\r
+ if (args) {\r
+ PyObject *v;\r
+ v=PyString_Format(retval, args);\r
+ Py_DECREF(retval);\r
+ Py_DECREF(args);\r
+ if (! v) return NULL;\r
+ retval=v;\r
+ }\r
+ }\r
+ else\r
+ if (args) retval=args;\r
+ else {\r
+ PyErr_SetObject(ErrType,Py_None);\r
+ return NULL;\r
+ }\r
+ PyErr_SetObject(ErrType,retval);\r
+ Py_DECREF(retval);\r
+ return NULL;\r
+}\r
+\r
+static Py_ssize_t\r
+write_file(Picklerobject *self, const char *s, Py_ssize_t n)\r
+{\r
+ size_t nbyteswritten;\r
+\r
+ if (s == NULL) {\r
+ return 0;\r
+ }\r
+\r
+ PyFile_IncUseCount((PyFileObject *)self->file);\r
+ Py_BEGIN_ALLOW_THREADS\r
+ nbyteswritten = fwrite(s, sizeof(char), n, self->fp);\r
+ Py_END_ALLOW_THREADS\r
+ PyFile_DecUseCount((PyFileObject *)self->file);\r
+ if (nbyteswritten != (size_t)n) {\r
+ PyErr_SetFromErrno(PyExc_IOError);\r
+ return -1;\r
+ }\r
+\r
+ return n;\r
+}\r
+\r
+static Py_ssize_t\r
+write_cStringIO(Picklerobject *self, const char *s, Py_ssize_t n)\r
+{\r
+ Py_ssize_t len = n;\r
+\r
+ if (s == NULL) {\r
+ return 0;\r
+ }\r
+\r
+ while (n > INT_MAX) {\r
+ if (PycStringIO->cwrite((PyObject *)self->file, s, INT_MAX) != INT_MAX) {\r
+ return -1;\r
+ }\r
+ n -= INT_MAX;\r
+ }\r
+\r
+ if (PycStringIO->cwrite((PyObject *)self->file, s, n) != n) {\r
+ return -1;\r
+ }\r
+\r
+ return len;\r
+}\r
+\r
+static Py_ssize_t\r
+write_none(Picklerobject *self, const char *s, Py_ssize_t n)\r
+{\r
+ if (s == NULL) return 0;\r
+ return n;\r
+}\r
+\r
+static Py_ssize_t\r
+write_other(Picklerobject *self, const char *s, Py_ssize_t n)\r
+{\r
+ PyObject *py_str = 0, *junk = 0;\r
+\r
+ if (s == NULL) {\r
+ if (!( self->buf_size )) return 0;\r
+ py_str = PyString_FromStringAndSize(self->write_buf,\r
+ self->buf_size);\r
+ if (!py_str)\r
+ return -1;\r
+ }\r
+ else {\r
+ if (self->buf_size && n > WRITE_BUF_SIZE - self->buf_size) {\r
+ if (write_other(self, NULL, 0) < 0)\r
+ return -1;\r
+ }\r
+\r
+ if (n > WRITE_BUF_SIZE) {\r
+ if (!( py_str =\r
+ PyString_FromStringAndSize(s, n)))\r
+ return -1;\r
+ }\r
+ else {\r
+ memcpy(self->write_buf + self->buf_size, s, n);\r
+ self->buf_size += n;\r
+ return n;\r
+ }\r
+ }\r
+\r
+ if (self->write) {\r
+ /* object with write method */\r
+ ARG_TUP(self, py_str);\r
+ if (self->arg) {\r
+ junk = PyObject_Call(self->write, self->arg, NULL);\r
+ FREE_ARG_TUP(self);\r
+ }\r
+ if (junk) Py_DECREF(junk);\r
+ else return -1;\r
+ }\r
+ else\r
+ PDATA_PUSH(self->file, py_str, -1);\r
+\r
+ self->buf_size = 0;\r
+ return n;\r
+}\r
+\r
+\r
+static Py_ssize_t\r
+read_file(Unpicklerobject *self, char **s, Py_ssize_t n)\r
+{\r
+ size_t nbytesread;\r
+\r
+ if (self->buf_size == 0) {\r
+ Py_ssize_t size;\r
+\r
+ size = ((n < 32) ? 32 : n);\r
+ if (!( self->buf = (char *)malloc(size))) {\r
+ PyErr_NoMemory();\r
+ return -1;\r
+ }\r
+\r
+ self->buf_size = size;\r
+ }\r
+ else if (n > self->buf_size) {\r
+ char *newbuf = (char *)realloc(self->buf, n);\r
+ if (!newbuf) {\r
+ PyErr_NoMemory();\r
+ return -1;\r
+ }\r
+ self->buf = newbuf;\r
+ self->buf_size = n;\r
+ }\r
+\r
+ PyFile_IncUseCount((PyFileObject *)self->file);\r
+ Py_BEGIN_ALLOW_THREADS\r
+ nbytesread = fread(self->buf, sizeof(char), n, self->fp);\r
+ Py_END_ALLOW_THREADS\r
+ PyFile_DecUseCount((PyFileObject *)self->file);\r
+ if (nbytesread != (size_t)n) {\r
+ if (feof(self->fp)) {\r
+ PyErr_SetNone(PyExc_EOFError);\r
+ return -1;\r
+ }\r
+\r
+ PyErr_SetFromErrno(PyExc_IOError);\r
+ return -1;\r
+ }\r
+\r
+ *s = self->buf;\r
+\r
+ return n;\r
+}\r
+\r
+\r
+static Py_ssize_t\r
+readline_file(Unpicklerobject *self, char **s)\r
+{\r
+ Py_ssize_t i;\r
+\r
+ if (self->buf_size == 0) {\r
+ if (!( self->buf = (char *)malloc(40))) {\r
+ PyErr_NoMemory();\r
+ return -1;\r
+ }\r
+ self->buf_size = 40;\r
+ }\r
+\r
+ i = 0;\r
+ while (1) {\r
+ Py_ssize_t bigger;\r
+ char *newbuf;\r
+ for (; i < (self->buf_size - 1); i++) {\r
+ if (feof(self->fp) ||\r
+ (self->buf[i] = getc(self->fp)) == '\n') {\r
+ self->buf[i + 1] = '\0';\r
+ *s = self->buf;\r
+ return i + 1;\r
+ }\r
+ }\r
+ if (self->buf_size > (PY_SSIZE_T_MAX >> 1)) {\r
+ PyErr_NoMemory();\r
+ return -1;\r
+ }\r
+ bigger = self->buf_size << 1;\r
+ newbuf = (char *)realloc(self->buf, bigger);\r
+ if (newbuf == NULL) {\r
+ PyErr_NoMemory();\r
+ return -1;\r
+ }\r
+ self->buf = newbuf;\r
+ self->buf_size = bigger;\r
+ }\r
+}\r
+\r
+\r
+static Py_ssize_t\r
+read_cStringIO(Unpicklerobject *self, char **s, Py_ssize_t n)\r
+{\r
+ Py_ssize_t len = n;\r
+ char *start, *end = NULL;\r
+\r
+ while (1) {\r
+ int k;\r
+ char *ptr;\r
+ if (n > INT_MAX)\r
+ k = INT_MAX;\r
+ else\r
+ k = (int)n;\r
+ if (PycStringIO->cread((PyObject *)self->file, &ptr, k) != k) {\r
+ PyErr_SetNone(PyExc_EOFError);\r
+ return -1;\r
+ }\r
+ if (end == NULL)\r
+ start = ptr;\r
+ else if (ptr != end) {\r
+ /* non-continuous area */\r
+ return -1;\r
+ }\r
+ if (n <= INT_MAX)\r
+ break;\r
+ end = ptr + INT_MAX;\r
+ n -= INT_MAX;\r
+ }\r
+\r
+ *s = start;\r
+\r
+ return len;\r
+}\r
+\r
+\r
+static Py_ssize_t\r
+readline_cStringIO(Unpicklerobject *self, char **s)\r
+{\r
+ Py_ssize_t n = 0;\r
+ char *start = NULL, *end = NULL;\r
+\r
+ while (1) {\r
+ int k;\r
+ char *ptr;\r
+ if ((k = PycStringIO->creadline((PyObject *)self->file, &ptr)) < 0) {\r
+ return -1;\r
+ }\r
+ n += k;\r
+ if (end == NULL)\r
+ start = ptr;\r
+ else if (ptr != end) {\r
+ /* non-continuous area */\r
+ return -1;\r
+ }\r
+ if (k == 0 || ptr[k - 1] == '\n')\r
+ break;\r
+ end = ptr + k;\r
+ }\r
+\r
+ *s = start;\r
+\r
+ return n;\r
+}\r
+\r
+\r
+static Py_ssize_t\r
+read_other(Unpicklerobject *self, char **s, Py_ssize_t n)\r
+{\r
+ PyObject *bytes, *str=0;\r
+\r
+ if (!( bytes = PyInt_FromSsize_t(n))) return -1;\r
+\r
+ ARG_TUP(self, bytes);\r
+ if (self->arg) {\r
+ str = PyObject_Call(self->read, self->arg, NULL);\r
+ FREE_ARG_TUP(self);\r
+ }\r
+ if (! str) return -1;\r
+\r
+ Py_XDECREF(self->last_string);\r
+ self->last_string = str;\r
+\r
+ if (! (*s = PyString_AsString(str))) return -1;\r
+\r
+ if (PyString_GET_SIZE(str) != n) {\r
+ PyErr_SetNone(PyExc_EOFError);\r
+ return -1;\r
+ }\r
+\r
+ return n;\r
+}\r
+\r
+\r
+static Py_ssize_t\r
+readline_other(Unpicklerobject *self, char **s)\r
+{\r
+ PyObject *str;\r
+ Py_ssize_t str_size;\r
+\r
+ if (!( str = PyObject_CallObject(self->readline, empty_tuple))) {\r
+ return -1;\r
+ }\r
+\r
+ if ((str_size = PyString_Size(str)) < 0)\r
+ return -1;\r
+\r
+ Py_XDECREF(self->last_string);\r
+ self->last_string = str;\r
+\r
+ if (! (*s = PyString_AsString(str)))\r
+ return -1;\r
+\r
+ return str_size;\r
+}\r
+\r
+/* Copy the first n bytes from s into newly malloc'ed memory, plus a\r
+ * trailing 0 byte. Return a pointer to that, or NULL if out of memory.\r
+ * The caller is responsible for free()'ing the return value.\r
+ */\r
+static char *\r
+pystrndup(const char *s, Py_ssize_t n)\r
+{\r
+ char *r = (char *)malloc(n+1);\r
+ if (r == NULL)\r
+ return (char*)PyErr_NoMemory();\r
+ memcpy(r, s, n);\r
+ r[n] = 0;\r
+ return r;\r
+}\r
+\r
+\r
+static int\r
+get(Picklerobject *self, PyObject *id)\r
+{\r
+ PyObject *value, *mv;\r
+ Py_ssize_t c_value;\r
+ char s[30];\r
+ size_t len;\r
+\r
+ if (!( mv = PyDict_GetItem(self->memo, id))) {\r
+ PyErr_SetObject(PyExc_KeyError, id);\r
+ return -1;\r
+ }\r
+\r
+ if (!( value = PyTuple_GetItem(mv, 0)))\r
+ return -1;\r
+\r
+ if (!( PyInt_Check(value))) {\r
+ PyErr_SetString(PicklingError, "no int where int expected in memo");\r
+ return -1;\r
+ }\r
+ c_value = PyInt_AS_LONG((PyIntObject*)value);\r
+\r
+ if (!self->bin) {\r
+ s[0] = GET;\r
+ PyOS_snprintf(s + 1, sizeof(s) - 1,\r
+ "%" PY_FORMAT_SIZE_T "d\n", c_value);\r
+ len = strlen(s);\r
+ }\r
+ else if (Pdata_Check(self->file)) {\r
+ if (write_other(self, NULL, 0) < 0) return -1;\r
+ PDATA_APPEND(self->file, mv, -1);\r
+ return 0;\r
+ }\r
+ else {\r
+ if (c_value < 256) {\r
+ s[0] = BINGET;\r
+ s[1] = (int)(c_value & 0xff);\r
+ len = 2;\r
+ }\r
+ else {\r
+ s[0] = LONG_BINGET;\r
+ s[1] = (int)(c_value & 0xff);\r
+ s[2] = (int)((c_value >> 8) & 0xff);\r
+ s[3] = (int)((c_value >> 16) & 0xff);\r
+ s[4] = (int)((c_value >> 24) & 0xff);\r
+ len = 5;\r
+ }\r
+ }\r
+\r
+ if (self->write_func(self, s, len) < 0)\r
+ return -1;\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+static int\r
+put(Picklerobject *self, PyObject *ob)\r
+{\r
+ if (Py_REFCNT(ob) < 2 || self->fast)\r
+ return 0;\r
+\r
+ return put2(self, ob);\r
+}\r
+\r
+\r
+static int\r
+put2(Picklerobject *self, PyObject *ob)\r
+{\r
+ char c_str[30];\r
+ Py_ssize_t len, p;\r
+ int res = -1;\r
+ PyObject *py_ob_id = 0, *memo_len = 0, *t = 0;\r
+\r
+ if (self->fast)\r
+ return 0;\r
+\r
+ if ((p = PyDict_Size(self->memo)) < 0)\r
+ goto finally;\r
+\r
+ /* Make sure memo keys are positive! */\r
+ /* XXX Why?\r
+ * XXX And does "positive" really mean non-negative?\r
+ * XXX pickle.py starts with PUT index 0, not 1. This makes for\r
+ * XXX gratuitous differences between the pickling modules.\r
+ */\r
+ p++;\r
+\r
+ if (!( py_ob_id = PyLong_FromVoidPtr(ob)))\r
+ goto finally;\r
+\r
+ if (!( memo_len = PyInt_FromLong(p)))\r
+ goto finally;\r
+\r
+ if (!( t = PyTuple_New(2)))\r
+ goto finally;\r
+\r
+ PyTuple_SET_ITEM(t, 0, memo_len);\r
+ Py_INCREF(memo_len);\r
+ PyTuple_SET_ITEM(t, 1, ob);\r
+ Py_INCREF(ob);\r
+\r
+ if (PyDict_SetItem(self->memo, py_ob_id, t) < 0)\r
+ goto finally;\r
+\r
+ if (!self->bin) {\r
+ c_str[0] = PUT;\r
+ PyOS_snprintf(c_str + 1, sizeof(c_str) - 1,\r
+ "%" PY_FORMAT_SIZE_T "d\n", p);\r
+ len = strlen(c_str);\r
+ }\r
+ else if (Pdata_Check(self->file)) {\r
+ if (write_other(self, NULL, 0) < 0) return -1;\r
+ PDATA_APPEND(self->file, memo_len, -1);\r
+ res=0; /* Job well done ;) */\r
+ goto finally;\r
+ }\r
+ else {\r
+ if (p >= 256) {\r
+ c_str[0] = LONG_BINPUT;\r
+ c_str[1] = (int)(p & 0xff);\r
+ c_str[2] = (int)((p >> 8) & 0xff);\r
+ c_str[3] = (int)((p >> 16) & 0xff);\r
+ c_str[4] = (int)((p >> 24) & 0xff);\r
+ len = 5;\r
+ }\r
+ else {\r
+ c_str[0] = BINPUT;\r
+ c_str[1] = p;\r
+ len = 2;\r
+ }\r
+ }\r
+\r
+ if (self->write_func(self, c_str, len) < 0)\r
+ goto finally;\r
+\r
+ res = 0;\r
+\r
+ finally:\r
+ Py_XDECREF(py_ob_id);\r
+ Py_XDECREF(memo_len);\r
+ Py_XDECREF(t);\r
+\r
+ return res;\r
+}\r
+\r
+static PyObject *\r
+whichmodule(PyObject *global, PyObject *global_name)\r
+{\r
+ Py_ssize_t i, j;\r
+ PyObject *module = 0, *modules_dict = 0,\r
+ *global_name_attr = 0, *name = 0;\r
+\r
+ module = PyObject_GetAttrString(global, "__module__");\r
+ if (module)\r
+ return module;\r
+ if (PyErr_ExceptionMatches(PyExc_AttributeError))\r
+ PyErr_Clear();\r
+ else\r
+ return NULL;\r
+\r
+ if (!( modules_dict = PySys_GetObject("modules")))\r
+ return NULL;\r
+\r
+ i = 0;\r
+ while ((j = PyDict_Next(modules_dict, &i, &name, &module))) {\r
+\r
+ if (PyObject_Compare(name, __main___str)==0) continue;\r
+\r
+ global_name_attr = PyObject_GetAttr(module, global_name);\r
+ if (!global_name_attr) {\r
+ if (PyErr_ExceptionMatches(PyExc_AttributeError))\r
+ PyErr_Clear();\r
+ else\r
+ return NULL;\r
+ continue;\r
+ }\r
+\r
+ if (global_name_attr != global) {\r
+ Py_DECREF(global_name_attr);\r
+ continue;\r
+ }\r
+\r
+ Py_DECREF(global_name_attr);\r
+\r
+ break;\r
+ }\r
+\r
+ /* The following implements the rule in pickle.py added in 1.5\r
+ that used __main__ if no module is found. I don't actually\r
+ like this rule. jlf\r
+ */\r
+ if (!j) {\r
+ name=__main___str;\r
+ }\r
+\r
+ Py_INCREF(name);\r
+ return name;\r
+}\r
+\r
+\r
+static int\r
+fast_save_enter(Picklerobject *self, PyObject *obj)\r
+{\r
+ /* if fast_container < 0, we're doing an error exit. */\r
+ if (++self->fast_container >= PY_CPICKLE_FAST_LIMIT) {\r
+ PyObject *key = NULL;\r
+ if (self->fast_memo == NULL) {\r
+ self->fast_memo = PyDict_New();\r
+ if (self->fast_memo == NULL) {\r
+ self->fast_container = -1;\r
+ return 0;\r
+ }\r
+ }\r
+ key = PyLong_FromVoidPtr(obj);\r
+ if (key == NULL)\r
+ return 0;\r
+ if (PyDict_GetItem(self->fast_memo, key)) {\r
+ Py_DECREF(key);\r
+ PyErr_Format(PyExc_ValueError,\r
+ "fast mode: can't pickle cyclic objects "\r
+ "including object type %s at %p",\r
+ Py_TYPE(obj)->tp_name, obj);\r
+ self->fast_container = -1;\r
+ return 0;\r
+ }\r
+ if (PyDict_SetItem(self->fast_memo, key, Py_None) < 0) {\r
+ Py_DECREF(key);\r
+ self->fast_container = -1;\r
+ return 0;\r
+ }\r
+ Py_DECREF(key);\r
+ }\r
+ return 1;\r
+}\r
+\r
+int\r
+fast_save_leave(Picklerobject *self, PyObject *obj)\r
+{\r
+ if (self->fast_container-- >= PY_CPICKLE_FAST_LIMIT) {\r
+ PyObject *key = PyLong_FromVoidPtr(obj);\r
+ if (key == NULL)\r
+ return 0;\r
+ if (PyDict_DelItem(self->fast_memo, key) < 0) {\r
+ Py_DECREF(key);\r
+ return 0;\r
+ }\r
+ Py_DECREF(key);\r
+ }\r
+ return 1;\r
+}\r
+\r
+static int\r
+save_none(Picklerobject *self, PyObject *args)\r
+{\r
+ static char none = NONE;\r
+ if (self->write_func(self, &none, 1) < 0)\r
+ return -1;\r
+\r
+ return 0;\r
+}\r
+\r
+static int\r
+save_bool(Picklerobject *self, PyObject *args)\r
+{\r
+ static const char *buf[2] = {FALSE, TRUE};\r
+ static char len[2] = {sizeof(FALSE)-1, sizeof(TRUE)-1};\r
+ long l = PyInt_AS_LONG((PyIntObject *)args);\r
+\r
+ if (self->proto >= 2) {\r
+ char opcode = l ? NEWTRUE : NEWFALSE;\r
+ if (self->write_func(self, &opcode, 1) < 0)\r
+ return -1;\r
+ }\r
+ else if (self->write_func(self, buf[l], len[l]) < 0)\r
+ return -1;\r
+ return 0;\r
+}\r
+\r
+static int\r
+save_int(Picklerobject *self, PyObject *args)\r
+{\r
+ char c_str[32];\r
+ long l = PyInt_AS_LONG((PyIntObject *)args);\r
+ Py_ssize_t len = 0;\r
+\r
+ if (!self->bin\r
+#if SIZEOF_LONG > 4\r
+ || l > 0x7fffffffL\r
+ || l < -0x80000000L\r
+#endif\r
+ ) {\r
+ /* Text-mode pickle, or long too big to fit in the 4-byte\r
+ * signed BININT format: store as a string.\r
+ */\r
+ c_str[0] = INT;\r
+ PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%ld\n", l);\r
+ if (self->write_func(self, c_str, strlen(c_str)) < 0)\r
+ return -1;\r
+ }\r
+ else {\r
+ /* Binary pickle and l fits in a signed 4-byte int. */\r
+ c_str[1] = (int)( l & 0xff);\r
+ c_str[2] = (int)((l >> 8) & 0xff);\r
+ c_str[3] = (int)((l >> 16) & 0xff);\r
+ c_str[4] = (int)((l >> 24) & 0xff);\r
+\r
+ if ((c_str[4] == 0) && (c_str[3] == 0)) {\r
+ if (c_str[2] == 0) {\r
+ c_str[0] = BININT1;\r
+ len = 2;\r
+ }\r
+ else {\r
+ c_str[0] = BININT2;\r
+ len = 3;\r
+ }\r
+ }\r
+ else {\r
+ c_str[0] = BININT;\r
+ len = 5;\r
+ }\r
+\r
+ if (self->write_func(self, c_str, len) < 0)\r
+ return -1;\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+static int\r
+save_long(Picklerobject *self, PyObject *args)\r
+{\r
+ Py_ssize_t size;\r
+ int res = -1;\r
+ PyObject *repr = NULL;\r
+\r
+ static char l = LONG;\r
+\r
+ if (self->proto >= 2) {\r
+ /* Linear-time pickling. */\r
+ size_t nbits;\r
+ size_t nbytes;\r
+ unsigned char *pdata;\r
+ char c_str[5];\r
+ int i;\r
+ int sign = _PyLong_Sign(args);\r
+\r
+ if (sign == 0) {\r
+ /* It's 0 -- an empty bytestring. */\r
+ c_str[0] = LONG1;\r
+ c_str[1] = 0;\r
+ i = self->write_func(self, c_str, 2);\r
+ if (i < 0) goto finally;\r
+ res = 0;\r
+ goto finally;\r
+ }\r
+ nbits = _PyLong_NumBits(args);\r
+ if (nbits == (size_t)-1 && PyErr_Occurred())\r
+ goto finally;\r
+ /* How many bytes do we need? There are nbits >> 3 full\r
+ * bytes of data, and nbits & 7 leftover bits. If there\r
+ * are any leftover bits, then we clearly need another\r
+ * byte. Wnat's not so obvious is that we *probably*\r
+ * need another byte even if there aren't any leftovers:\r
+ * the most-significant bit of the most-significant byte\r
+ * acts like a sign bit, and it's usually got a sense\r
+ * opposite of the one we need. The exception is longs\r
+ * of the form -(2**(8*j-1)) for j > 0. Such a long is\r
+ * its own 256's-complement, so has the right sign bit\r
+ * even without the extra byte. That's a pain to check\r
+ * for in advance, though, so we always grab an extra\r
+ * byte at the start, and cut it back later if possible.\r
+ */\r
+ nbytes = (nbits >> 3) + 1;\r
+ if (nbytes > INT_MAX) {\r
+ PyErr_SetString(PyExc_OverflowError, "long too large "\r
+ "to pickle");\r
+ goto finally;\r
+ }\r
+ repr = PyString_FromStringAndSize(NULL, (int)nbytes);\r
+ if (repr == NULL) goto finally;\r
+ pdata = (unsigned char *)PyString_AS_STRING(repr);\r
+ i = _PyLong_AsByteArray((PyLongObject *)args,\r
+ pdata, nbytes,\r
+ 1 /* little endian */, 1 /* signed */);\r
+ if (i < 0) goto finally;\r
+ /* If the long is negative, this may be a byte more than\r
+ * needed. This is so iff the MSB is all redundant sign\r
+ * bits.\r
+ */\r
+ if (sign < 0 && nbytes > 1 && pdata[nbytes - 1] == 0xff &&\r
+ (pdata[nbytes - 2] & 0x80) != 0)\r
+ --nbytes;\r
+\r
+ if (nbytes < 256) {\r
+ c_str[0] = LONG1;\r
+ c_str[1] = (char)nbytes;\r
+ size = 2;\r
+ }\r
+ else {\r
+ c_str[0] = LONG4;\r
+ size = (int)nbytes;\r
+ for (i = 1; i < 5; i++) {\r
+ c_str[i] = (char)(size & 0xff);\r
+ size >>= 8;\r
+ }\r
+ size = 5;\r
+ }\r
+ i = self->write_func(self, c_str, size);\r
+ if (i < 0) goto finally;\r
+ i = self->write_func(self, (char *)pdata, (int)nbytes);\r
+ if (i < 0) goto finally;\r
+ res = 0;\r
+ goto finally;\r
+ }\r
+\r
+ /* proto < 2: write the repr and newline. This is quadratic-time\r
+ * (in the number of digits), in both directions.\r
+ */\r
+ if (!( repr = PyObject_Repr(args)))\r
+ goto finally;\r
+\r
+ if ((size = PyString_Size(repr)) < 0)\r
+ goto finally;\r
+\r
+ if (self->write_func(self, &l, 1) < 0)\r
+ goto finally;\r
+\r
+ if (self->write_func(self,\r
+ PyString_AS_STRING((PyStringObject *)repr),\r
+ size) < 0)\r
+ goto finally;\r
+\r
+ if (self->write_func(self, "\n", 1) < 0)\r
+ goto finally;\r
+\r
+ res = 0;\r
+\r
+ finally:\r
+ Py_XDECREF(repr);\r
+ return res;\r
+}\r
+\r
+\r
+static int\r
+save_float(Picklerobject *self, PyObject *args)\r
+{\r
+ double x = PyFloat_AS_DOUBLE((PyFloatObject *)args);\r
+\r
+ if (self->bin) {\r
+ char str[9];\r
+ str[0] = BINFLOAT;\r
+ if (_PyFloat_Pack8(x, (unsigned char *)&str[1], 0) < 0)\r
+ return -1;\r
+ if (self->write_func(self, str, 9) < 0)\r
+ return -1;\r
+ }\r
+ else {\r
+ int result = -1;\r
+ char *buf = NULL;\r
+ char op = FLOAT;\r
+\r
+ if (self->write_func(self, &op, 1) < 0)\r
+ goto done;\r
+\r
+ buf = PyOS_double_to_string(x, 'g', 17, 0, NULL);\r
+ if (!buf) {\r
+ PyErr_NoMemory();\r
+ goto done;\r
+ }\r
+\r
+ if (self->write_func(self, buf, strlen(buf)) < 0)\r
+ goto done;\r
+\r
+ if (self->write_func(self, "\n", 1) < 0)\r
+ goto done;\r
+\r
+ result = 0;\r
+done:\r
+ PyMem_Free(buf);\r
+ return result;\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+static int\r
+save_string(Picklerobject *self, PyObject *args, int doput)\r
+{\r
+ Py_ssize_t size, len;\r
+ PyObject *repr=0;\r
+\r
+ if ((size = PyString_Size(args)) < 0)\r
+ return -1;\r
+\r
+ if (!self->bin) {\r
+ char *repr_str;\r
+\r
+ static char string = STRING;\r
+\r
+ if (!( repr = PyObject_Repr(args)))\r
+ return -1;\r
+\r
+ if ((len = PyString_Size(repr)) < 0)\r
+ goto err;\r
+ repr_str = PyString_AS_STRING((PyStringObject *)repr);\r
+\r
+ if (self->write_func(self, &string, 1) < 0)\r
+ goto err;\r
+\r
+ if (self->write_func(self, repr_str, len) < 0)\r
+ goto err;\r
+\r
+ if (self->write_func(self, "\n", 1) < 0)\r
+ goto err;\r
+\r
+ Py_XDECREF(repr);\r
+ }\r
+ else {\r
+ int i;\r
+ char c_str[5];\r
+\r
+ if (size < 256) {\r
+ c_str[0] = SHORT_BINSTRING;\r
+ c_str[1] = size;\r
+ len = 2;\r
+ }\r
+ else if (size <= INT_MAX) {\r
+ c_str[0] = BINSTRING;\r
+ for (i = 1; i < 5; i++)\r
+ c_str[i] = (int)(size >> ((i - 1) * 8));\r
+ len = 5;\r
+ }\r
+ else\r
+ return -1; /* string too large */\r
+\r
+ if (self->write_func(self, c_str, len) < 0)\r
+ return -1;\r
+\r
+ if (size > 128 && Pdata_Check(self->file)) {\r
+ if (write_other(self, NULL, 0) < 0) return -1;\r
+ PDATA_APPEND(self->file, args, -1);\r
+ }\r
+ else {\r
+ if (self->write_func(self,\r
+ PyString_AS_STRING(\r
+ (PyStringObject *)args),\r
+ size) < 0)\r
+ return -1;\r
+ }\r
+ }\r
+\r
+ if (doput)\r
+ if (put(self, args) < 0)\r
+ return -1;\r
+\r
+ return 0;\r
+\r
+ err:\r
+ Py_XDECREF(repr);\r
+ return -1;\r
+}\r
+\r
+\r
+#ifdef Py_USING_UNICODE\r
+/* A copy of PyUnicode_EncodeRawUnicodeEscape() that also translates\r
+ backslash and newline characters to \uXXXX escapes. */\r
+static PyObject *\r
+modified_EncodeRawUnicodeEscape(const Py_UNICODE *s, Py_ssize_t size)\r
+{\r
+ PyObject *repr;\r
+ char *p;\r
+ char *q;\r
+\r
+ static const char *hexdigit = "0123456789abcdef";\r
+#ifdef Py_UNICODE_WIDE\r
+ const Py_ssize_t expandsize = 10;\r
+#else\r
+ const Py_ssize_t expandsize = 6;\r
+#endif\r
+\r
+ if (size > PY_SSIZE_T_MAX / expandsize)\r
+ return PyErr_NoMemory();\r
+\r
+ repr = PyString_FromStringAndSize(NULL, expandsize * size);\r
+ if (repr == NULL)\r
+ return NULL;\r
+ if (size == 0)\r
+ return repr;\r
+\r
+ p = q = PyString_AS_STRING(repr);\r
+ while (size-- > 0) {\r
+ Py_UNICODE ch = *s++;\r
+#ifdef Py_UNICODE_WIDE\r
+ /* Map 32-bit characters to '\Uxxxxxxxx' */\r
+ if (ch >= 0x10000) {\r
+ *p++ = '\\';\r
+ *p++ = 'U';\r
+ *p++ = hexdigit[(ch >> 28) & 0xf];\r
+ *p++ = hexdigit[(ch >> 24) & 0xf];\r
+ *p++ = hexdigit[(ch >> 20) & 0xf];\r
+ *p++ = hexdigit[(ch >> 16) & 0xf];\r
+ *p++ = hexdigit[(ch >> 12) & 0xf];\r
+ *p++ = hexdigit[(ch >> 8) & 0xf];\r
+ *p++ = hexdigit[(ch >> 4) & 0xf];\r
+ *p++ = hexdigit[ch & 15];\r
+ }\r
+ else\r
+#else\r
+ /* Map UTF-16 surrogate pairs to '\U00xxxxxx' */\r
+ if (ch >= 0xD800 && ch < 0xDC00) {\r
+ Py_UNICODE ch2;\r
+ Py_UCS4 ucs;\r
+\r
+ ch2 = *s++;\r
+ size--;\r
+ if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {\r
+ ucs = (((ch & 0x03FF) << 10) | (ch2 & 0x03FF)) + 0x00010000;\r
+ *p++ = '\\';\r
+ *p++ = 'U';\r
+ *p++ = hexdigit[(ucs >> 28) & 0xf];\r
+ *p++ = hexdigit[(ucs >> 24) & 0xf];\r
+ *p++ = hexdigit[(ucs >> 20) & 0xf];\r
+ *p++ = hexdigit[(ucs >> 16) & 0xf];\r
+ *p++ = hexdigit[(ucs >> 12) & 0xf];\r
+ *p++ = hexdigit[(ucs >> 8) & 0xf];\r
+ *p++ = hexdigit[(ucs >> 4) & 0xf];\r
+ *p++ = hexdigit[ucs & 0xf];\r
+ continue;\r
+ }\r
+ /* Fall through: isolated surrogates are copied as-is */\r
+ s--;\r
+ size++;\r
+ }\r
+#endif\r
+ /* Map 16-bit characters to '\uxxxx' */\r
+ if (ch >= 256 || ch == '\\' || ch == '\n') {\r
+ *p++ = '\\';\r
+ *p++ = 'u';\r
+ *p++ = hexdigit[(ch >> 12) & 0xf];\r
+ *p++ = hexdigit[(ch >> 8) & 0xf];\r
+ *p++ = hexdigit[(ch >> 4) & 0xf];\r
+ *p++ = hexdigit[ch & 15];\r
+ }\r
+ /* Copy everything else as-is */\r
+ else\r
+ *p++ = (char) ch;\r
+ }\r
+ *p = '\0';\r
+ _PyString_Resize(&repr, p - q);\r
+ return repr;\r
+}\r
+\r
+static int\r
+save_unicode(Picklerobject *self, PyObject *args, int doput)\r
+{\r
+ Py_ssize_t size, len;\r
+ PyObject *repr=0;\r
+\r
+ if (!PyUnicode_Check(args))\r
+ return -1;\r
+\r
+ if (!self->bin) {\r
+ char *repr_str;\r
+ static char string = UNICODE;\r
+\r
+ repr = modified_EncodeRawUnicodeEscape(\r
+ PyUnicode_AS_UNICODE(args), PyUnicode_GET_SIZE(args));\r
+ if (!repr)\r
+ return -1;\r
+\r
+ if ((len = PyString_Size(repr)) < 0)\r
+ goto err;\r
+ repr_str = PyString_AS_STRING((PyStringObject *)repr);\r
+\r
+ if (self->write_func(self, &string, 1) < 0)\r
+ goto err;\r
+\r
+ if (self->write_func(self, repr_str, len) < 0)\r
+ goto err;\r
+\r
+ if (self->write_func(self, "\n", 1) < 0)\r
+ goto err;\r
+\r
+ Py_XDECREF(repr);\r
+ }\r
+ else {\r
+ int i;\r
+ char c_str[5];\r
+\r
+ if (!( repr = PyUnicode_AsUTF8String(args)))\r
+ return -1;\r
+\r
+ if ((size = PyString_Size(repr)) < 0)\r
+ goto err;\r
+ if (size > INT_MAX)\r
+ return -1; /* string too large */\r
+\r
+ c_str[0] = BINUNICODE;\r
+ for (i = 1; i < 5; i++)\r
+ c_str[i] = (int)(size >> ((i - 1) * 8));\r
+ len = 5;\r
+\r
+ if (self->write_func(self, c_str, len) < 0)\r
+ goto err;\r
+\r
+ if (size > 128 && Pdata_Check(self->file)) {\r
+ if (write_other(self, NULL, 0) < 0)\r
+ goto err;\r
+ PDATA_APPEND(self->file, repr, -1);\r
+ }\r
+ else {\r
+ if (self->write_func(self, PyString_AS_STRING(repr),\r
+ size) < 0)\r
+ goto err;\r
+ }\r
+\r
+ Py_DECREF(repr);\r
+ }\r
+\r
+ if (doput)\r
+ if (put(self, args) < 0)\r
+ return -1;\r
+\r
+ return 0;\r
+\r
+ err:\r
+ Py_XDECREF(repr);\r
+ return -1;\r
+}\r
+#endif\r
+\r
+/* A helper for save_tuple. Push the len elements in tuple t on the stack. */\r
+static int\r
+store_tuple_elements(Picklerobject *self, PyObject *t, int len)\r
+{\r
+ Py_ssize_t i;\r
+ int res = -1; /* guilty until proved innocent */\r
+\r
+ assert(PyTuple_Size(t) == len);\r
+\r
+ for (i = 0; i < len; i++) {\r
+ PyObject *element = PyTuple_GET_ITEM(t, i);\r
+\r
+ if (element == NULL)\r
+ goto finally;\r
+ if (save(self, element, 0) < 0)\r
+ goto finally;\r
+ }\r
+ res = 0;\r
+\r
+ finally:\r
+ return res;\r
+}\r
+\r
+/* Tuples are ubiquitous in the pickle protocols, so many techniques are\r
+ * used across protocols to minimize the space needed to pickle them.\r
+ * Tuples are also the only builtin immutable type that can be recursive\r
+ * (a tuple can be reached from itself), and that requires some subtle\r
+ * magic so that it works in all cases. IOW, this is a long routine.\r
+ */\r
+static int\r
+save_tuple(Picklerobject *self, PyObject *args)\r
+{\r
+ PyObject *py_tuple_id = NULL;\r
+ Py_ssize_t len, i;\r
+ int res = -1;\r
+\r
+ static char tuple = TUPLE;\r
+ static char pop = POP;\r
+ static char pop_mark = POP_MARK;\r
+ static char len2opcode[] = {EMPTY_TUPLE, TUPLE1, TUPLE2, TUPLE3};\r
+\r
+ if ((len = PyTuple_Size(args)) < 0)\r
+ goto finally;\r
+\r
+ if (len == 0) {\r
+ char c_str[2];\r
+\r
+ if (self->proto) {\r
+ c_str[0] = EMPTY_TUPLE;\r
+ len = 1;\r
+ }\r
+ else {\r
+ c_str[0] = MARK;\r
+ c_str[1] = TUPLE;\r
+ len = 2;\r
+ }\r
+ if (self->write_func(self, c_str, len) >= 0)\r
+ res = 0;\r
+ /* Don't memoize an empty tuple. */\r
+ goto finally;\r
+ }\r
+\r
+ /* A non-empty tuple. */\r
+\r
+ /* id(tuple) isn't in the memo now. If it shows up there after\r
+ * saving the tuple elements, the tuple must be recursive, in\r
+ * which case we'll pop everything we put on the stack, and fetch\r
+ * its value from the memo.\r
+ */\r
+ py_tuple_id = PyLong_FromVoidPtr(args);\r
+ if (py_tuple_id == NULL)\r
+ goto finally;\r
+\r
+ if (len <= 3 && self->proto >= 2) {\r
+ /* Use TUPLE{1,2,3} opcodes. */\r
+ if (store_tuple_elements(self, args, len) < 0)\r
+ goto finally;\r
+ if (PyDict_GetItem(self->memo, py_tuple_id)) {\r
+ /* pop the len elements */\r
+ for (i = 0; i < len; ++i)\r
+ if (self->write_func(self, &pop, 1) < 0)\r
+ goto finally;\r
+ /* fetch from memo */\r
+ if (get(self, py_tuple_id) < 0)\r
+ goto finally;\r
+ res = 0;\r
+ goto finally;\r
+ }\r
+ /* Not recursive. */\r
+ if (self->write_func(self, len2opcode + len, 1) < 0)\r
+ goto finally;\r
+ goto memoize;\r
+ }\r
+\r
+ /* proto < 2 and len > 0, or proto >= 2 and len > 3.\r
+ * Generate MARK elt1 elt2 ... TUPLE\r
+ */\r
+ if (self->write_func(self, &MARKv, 1) < 0)\r
+ goto finally;\r
+\r
+ if (store_tuple_elements(self, args, len) < 0)\r
+ goto finally;\r
+\r
+ if (PyDict_GetItem(self->memo, py_tuple_id)) {\r
+ /* pop the stack stuff we pushed */\r
+ if (self->bin) {\r
+ if (self->write_func(self, &pop_mark, 1) < 0)\r
+ goto finally;\r
+ }\r
+ else {\r
+ /* Note that we pop one more than len, to remove\r
+ * the MARK too.\r
+ */\r
+ for (i = 0; i <= len; i++)\r
+ if (self->write_func(self, &pop, 1) < 0)\r
+ goto finally;\r
+ }\r
+ /* fetch from memo */\r
+ if (get(self, py_tuple_id) >= 0)\r
+ res = 0;\r
+ goto finally;\r
+ }\r
+\r
+ /* Not recursive. */\r
+ if (self->write_func(self, &tuple, 1) < 0)\r
+ goto finally;\r
+\r
+ memoize:\r
+ if (put(self, args) >= 0)\r
+ res = 0;\r
+\r
+ finally:\r
+ Py_XDECREF(py_tuple_id);\r
+ return res;\r
+}\r
+\r
+/* iter is an iterator giving items, and we batch up chunks of\r
+ * MARK item item ... item APPENDS\r
+ * opcode sequences. Calling code should have arranged to first create an\r
+ * empty list, or list-like object, for the APPENDS to operate on.\r
+ * Returns 0 on success, <0 on error.\r
+ */\r
+static int\r
+batch_list(Picklerobject *self, PyObject *iter)\r
+{\r
+ PyObject *obj = NULL;\r
+ PyObject *firstitem = NULL;\r
+ int i, n;\r
+\r
+ static char append = APPEND;\r
+ static char appends = APPENDS;\r
+\r
+ assert(iter != NULL);\r
+\r
+ if (self->proto == 0) {\r
+ /* APPENDS isn't available; do one at a time. */\r
+ for (;;) {\r
+ obj = PyIter_Next(iter);\r
+ if (obj == NULL) {\r
+ if (PyErr_Occurred())\r
+ return -1;\r
+ break;\r
+ }\r
+ i = save(self, obj, 0);\r
+ Py_DECREF(obj);\r
+ if (i < 0)\r
+ return -1;\r
+ if (self->write_func(self, &append, 1) < 0)\r
+ return -1;\r
+ }\r
+ return 0;\r
+ }\r
+\r
+ /* proto > 0: write in batches of BATCHSIZE. */\r
+ do {\r
+ /* Get first item */\r
+ firstitem = PyIter_Next(iter);\r
+ if (firstitem == NULL) {\r
+ if (PyErr_Occurred())\r
+ goto BatchFailed;\r
+\r
+ /* nothing more to add */\r
+ break;\r
+ }\r
+\r
+ /* Try to get a second item */\r
+ obj = PyIter_Next(iter);\r
+ if (obj == NULL) {\r
+ if (PyErr_Occurred())\r
+ goto BatchFailed;\r
+\r
+ /* Only one item to write */\r
+ if (save(self, firstitem, 0) < 0)\r
+ goto BatchFailed;\r
+ if (self->write_func(self, &append, 1) < 0)\r
+ goto BatchFailed;\r
+ Py_CLEAR(firstitem);\r
+ break;\r
+ }\r
+\r
+ /* More than one item to write */\r
+\r
+ /* Pump out MARK, items, APPENDS. */\r
+ if (self->write_func(self, &MARKv, 1) < 0)\r
+ goto BatchFailed;\r
+\r
+ if (save(self, firstitem, 0) < 0)\r
+ goto BatchFailed;\r
+ Py_CLEAR(firstitem);\r
+ n = 1;\r
+\r
+ /* Fetch and save up to BATCHSIZE items */\r
+ while (obj) {\r
+ if (save(self, obj, 0) < 0)\r
+ goto BatchFailed;\r
+ Py_CLEAR(obj);\r
+ n += 1;\r
+\r
+ if (n == BATCHSIZE)\r
+ break;\r
+\r
+ obj = PyIter_Next(iter);\r
+ if (obj == NULL) {\r
+ if (PyErr_Occurred())\r
+ goto BatchFailed;\r
+ break;\r
+ }\r
+ }\r
+\r
+ if (self->write_func(self, &appends, 1) < 0)\r
+ goto BatchFailed;\r
+\r
+ } while (n == BATCHSIZE);\r
+ return 0;\r
+\r
+BatchFailed:\r
+ Py_XDECREF(firstitem);\r
+ Py_XDECREF(obj);\r
+ return -1;\r
+}\r
+\r
+static int\r
+save_list(Picklerobject *self, PyObject *args)\r
+{\r
+ int res = -1;\r
+ char s[3];\r
+ Py_ssize_t len;\r
+ PyObject *iter;\r
+\r
+ if (self->fast && !fast_save_enter(self, args))\r
+ goto finally;\r
+\r
+ /* Create an empty list. */\r
+ if (self->bin) {\r
+ s[0] = EMPTY_LIST;\r
+ len = 1;\r
+ }\r
+ else {\r
+ s[0] = MARK;\r
+ s[1] = LIST;\r
+ len = 2;\r
+ }\r
+\r
+ if (self->write_func(self, s, len) < 0)\r
+ goto finally;\r
+\r
+ /* Get list length, and bow out early if empty. */\r
+ if ((len = PyList_Size(args)) < 0)\r
+ goto finally;\r
+\r
+ /* Memoize. */\r
+ if (len == 0) {\r
+ if (put(self, args) >= 0)\r
+ res = 0;\r
+ goto finally;\r
+ }\r
+ if (put2(self, args) < 0)\r
+ goto finally;\r
+\r
+ /* Materialize the list elements. */\r
+ iter = PyObject_GetIter(args);\r
+ if (iter == NULL)\r
+ goto finally;\r
+\r
+ if (Py_EnterRecursiveCall(" while pickling an object") == 0)\r
+ {\r
+ res = batch_list(self, iter);\r
+ Py_LeaveRecursiveCall();\r
+ }\r
+ Py_DECREF(iter);\r
+\r
+ finally:\r
+ if (self->fast && !fast_save_leave(self, args))\r
+ res = -1;\r
+\r
+ return res;\r
+}\r
+\r
+\r
+/* iter is an iterator giving (key, value) pairs, and we batch up chunks of\r
+ * MARK key value ... key value SETITEMS\r
+ * opcode sequences. Calling code should have arranged to first create an\r
+ * empty dict, or dict-like object, for the SETITEMS to operate on.\r
+ * Returns 0 on success, <0 on error.\r
+ *\r
+ * This is very much like batch_list(). The difference between saving\r
+ * elements directly, and picking apart two-tuples, is so long-winded at\r
+ * the C level, though, that attempts to combine these routines were too\r
+ * ugly to bear.\r
+ */\r
+static int\r
+batch_dict(Picklerobject *self, PyObject *iter)\r
+{\r
+ PyObject *p = NULL;\r
+ PyObject *firstitem = NULL;\r
+ int i, n;\r
+\r
+ static char setitem = SETITEM;\r
+ static char setitems = SETITEMS;\r
+\r
+ assert(iter != NULL);\r
+\r
+ if (self->proto == 0) {\r
+ /* SETITEMS isn't available; do one at a time. */\r
+ for (;;) {\r
+ p = PyIter_Next(iter);\r
+ if (p == NULL) {\r
+ if (PyErr_Occurred())\r
+ return -1;\r
+ break;\r
+ }\r
+ if (!PyTuple_Check(p) || PyTuple_Size(p) != 2) {\r
+ PyErr_SetString(PyExc_TypeError, "dict items "\r
+ "iterator must return 2-tuples");\r
+ return -1;\r
+ }\r
+ i = save(self, PyTuple_GET_ITEM(p, 0), 0);\r
+ if (i >= 0)\r
+ i = save(self, PyTuple_GET_ITEM(p, 1), 0);\r
+ Py_DECREF(p);\r
+ if (i < 0)\r
+ return -1;\r
+ if (self->write_func(self, &setitem, 1) < 0)\r
+ return -1;\r
+ }\r
+ return 0;\r
+ }\r
+\r
+ /* proto > 0: write in batches of BATCHSIZE. */\r
+ do {\r
+ /* Get first item */\r
+ firstitem = PyIter_Next(iter);\r
+ if (firstitem == NULL) {\r
+ if (PyErr_Occurred())\r
+ goto BatchFailed;\r
+\r
+ /* nothing more to add */\r
+ break;\r
+ }\r
+ if (!PyTuple_Check(firstitem) || PyTuple_Size(firstitem) != 2) {\r
+ PyErr_SetString(PyExc_TypeError, "dict items "\r
+ "iterator must return 2-tuples");\r
+ goto BatchFailed;\r
+ }\r
+\r
+ /* Try to get a second item */\r
+ p = PyIter_Next(iter);\r
+ if (p == NULL) {\r
+ if (PyErr_Occurred())\r
+ goto BatchFailed;\r
+\r
+ /* Only one item to write */\r
+ if (save(self, PyTuple_GET_ITEM(firstitem, 0), 0) < 0)\r
+ goto BatchFailed;\r
+ if (save(self, PyTuple_GET_ITEM(firstitem, 1), 0) < 0)\r
+ goto BatchFailed;\r
+ if (self->write_func(self, &setitem, 1) < 0)\r
+ goto BatchFailed;\r
+ Py_CLEAR(firstitem);\r
+ break;\r
+ }\r
+\r
+ /* More than one item to write */\r
+\r
+ /* Pump out MARK, items, SETITEMS. */\r
+ if (self->write_func(self, &MARKv, 1) < 0)\r
+ goto BatchFailed;\r
+\r
+ if (save(self, PyTuple_GET_ITEM(firstitem, 0), 0) < 0)\r
+ goto BatchFailed;\r
+ if (save(self, PyTuple_GET_ITEM(firstitem, 1), 0) < 0)\r
+ goto BatchFailed;\r
+ Py_CLEAR(firstitem);\r
+ n = 1;\r
+\r
+ /* Fetch and save up to BATCHSIZE items */\r
+ while (p) {\r
+ if (!PyTuple_Check(p) || PyTuple_Size(p) != 2) {\r
+ PyErr_SetString(PyExc_TypeError, "dict items "\r
+ "iterator must return 2-tuples");\r
+ goto BatchFailed;\r
+ }\r
+ if (save(self, PyTuple_GET_ITEM(p, 0), 0) < 0)\r
+ goto BatchFailed;\r
+ if (save(self, PyTuple_GET_ITEM(p, 1), 0) < 0)\r
+ goto BatchFailed;\r
+ Py_CLEAR(p);\r
+ n += 1;\r
+\r
+ if (n == BATCHSIZE)\r
+ break;\r
+\r
+ p = PyIter_Next(iter);\r
+ if (p == NULL) {\r
+ if (PyErr_Occurred())\r
+ goto BatchFailed;\r
+ break;\r
+ }\r
+ }\r
+\r
+ if (self->write_func(self, &setitems, 1) < 0)\r
+ goto BatchFailed;\r
+\r
+ } while (n == BATCHSIZE);\r
+ return 0;\r
+\r
+BatchFailed:\r
+ Py_XDECREF(firstitem);\r
+ Py_XDECREF(p);\r
+ return -1;\r
+}\r
+\r
+/* This is a variant of batch_dict() above that specializes for dicts, with no\r
+ * support for dict subclasses. Like batch_dict(), we batch up chunks of\r
+ * MARK key value ... key value SETITEMS\r
+ * opcode sequences. Calling code should have arranged to first create an\r
+ * empty dict, or dict-like object, for the SETITEMS to operate on.\r
+ * Returns 0 on success, -1 on error.\r
+ *\r
+ * Note that this currently doesn't work for protocol 0.\r
+ */\r
+static int\r
+batch_dict_exact(Picklerobject *self, PyObject *obj)\r
+{\r
+ PyObject *key = NULL, *value = NULL;\r
+ int i;\r
+ Py_ssize_t dict_size, ppos = 0;\r
+\r
+ static char setitem = SETITEM;\r
+ static char setitems = SETITEMS;\r
+\r
+ assert(obj != NULL);\r
+ assert(self->proto > 0);\r
+\r
+ dict_size = PyDict_Size(obj);\r
+\r
+ /* Special-case len(d) == 1 to save space. */\r
+ if (dict_size == 1) {\r
+ PyDict_Next(obj, &ppos, &key, &value);\r
+ if (save(self, key, 0) < 0)\r
+ return -1;\r
+ if (save(self, value, 0) < 0)\r
+ return -1;\r
+ if (self->write_func(self, &setitem, 1) < 0)\r
+ return -1;\r
+ return 0;\r
+ }\r
+\r
+ /* Write in batches of BATCHSIZE. */\r
+ do {\r
+ i = 0;\r
+ if (self->write_func(self, &MARKv, 1) < 0)\r
+ return -1;\r
+ while (PyDict_Next(obj, &ppos, &key, &value)) {\r
+ if (save(self, key, 0) < 0)\r
+ return -1;\r
+ if (save(self, value, 0) < 0)\r
+ return -1;\r
+ if (++i == BATCHSIZE)\r
+ break;\r
+ }\r
+ if (self->write_func(self, &setitems, 1) < 0)\r
+ return -1;\r
+ if (PyDict_Size(obj) != dict_size) {\r
+ PyErr_Format(\r
+ PyExc_RuntimeError,\r
+ "dictionary changed size during iteration");\r
+ return -1;\r
+ }\r
+\r
+ } while (i == BATCHSIZE);\r
+ return 0;\r
+}\r
+\r
+static int\r
+save_dict(Picklerobject *self, PyObject *args)\r
+{\r
+ int res = -1;\r
+ char s[3];\r
+ Py_ssize_t len;\r
+\r
+ if (self->fast && !fast_save_enter(self, args))\r
+ goto finally;\r
+\r
+ /* Create an empty dict. */\r
+ if (self->bin) {\r
+ s[0] = EMPTY_DICT;\r
+ len = 1;\r
+ }\r
+ else {\r
+ s[0] = MARK;\r
+ s[1] = DICT;\r
+ len = 2;\r
+ }\r
+\r
+ if (self->write_func(self, s, len) < 0)\r
+ goto finally;\r
+\r
+ /* Get dict size, and bow out early if empty. */\r
+ if ((len = PyDict_Size(args)) < 0)\r
+ goto finally;\r
+\r
+ if (len == 0) {\r
+ if (put(self, args) >= 0)\r
+ res = 0;\r
+ goto finally;\r
+ }\r
+ if (put2(self, args) < 0)\r
+ goto finally;\r
+\r
+ /* Materialize the dict items. */\r
+ if (PyDict_CheckExact(args) && self->proto > 0) {\r
+ /* We can take certain shortcuts if we know this is a dict and\r
+ not a dict subclass. */\r
+ if (Py_EnterRecursiveCall(" while pickling an object") == 0) {\r
+ res = batch_dict_exact(self, args);\r
+ Py_LeaveRecursiveCall();\r
+ }\r
+ } else {\r
+ PyObject *iter = PyObject_CallMethod(args, "iteritems", "()");\r
+ if (iter == NULL)\r
+ goto finally;\r
+ if (Py_EnterRecursiveCall(" while pickling an object") == 0) {\r
+ res = batch_dict(self, iter);\r
+ Py_LeaveRecursiveCall();\r
+ }\r
+ Py_DECREF(iter);\r
+ }\r
+\r
+ finally:\r
+ if (self->fast && !fast_save_leave(self, args))\r
+ res = -1;\r
+\r
+ return res;\r
+}\r
+\r
+\r
+static int\r
+save_inst(Picklerobject *self, PyObject *args)\r
+{\r
+ PyObject *class = 0, *module = 0, *name = 0, *state = 0,\r
+ *getinitargs_func = 0, *getstate_func = 0, *class_args = 0;\r
+ char *module_str, *name_str;\r
+ int module_size, name_size, res = -1;\r
+\r
+ static char inst = INST, obj = OBJ, build = BUILD;\r
+\r
+ if (self->fast && !fast_save_enter(self, args))\r
+ goto finally;\r
+\r
+ if (self->write_func(self, &MARKv, 1) < 0)\r
+ goto finally;\r
+\r
+ if (!( class = PyObject_GetAttr(args, __class___str)))\r
+ goto finally;\r
+\r
+ if (self->bin) {\r
+ if (save(self, class, 0) < 0)\r
+ goto finally;\r
+ }\r
+\r
+ if ((getinitargs_func = PyObject_GetAttr(args, __getinitargs___str))) {\r
+ PyObject *element = 0;\r
+ Py_ssize_t i, len;\r
+\r
+ if (!( class_args =\r
+ PyObject_Call(getinitargs_func, empty_tuple, NULL)))\r
+ goto finally;\r
+\r
+ if ((len = PyObject_Size(class_args)) < 0)\r
+ goto finally;\r
+\r
+ for (i = 0; i < len; i++) {\r
+ if (!( element = PySequence_GetItem(class_args, i)))\r
+ goto finally;\r
+\r
+ if (save(self, element, 0) < 0) {\r
+ Py_DECREF(element);\r
+ goto finally;\r
+ }\r
+\r
+ Py_DECREF(element);\r
+ }\r
+ }\r
+ else {\r
+ if (PyErr_ExceptionMatches(PyExc_AttributeError))\r
+ PyErr_Clear();\r
+ else\r
+ goto finally;\r
+ }\r
+\r
+ if (!self->bin) {\r
+ if (!( name = ((PyClassObject *)class)->cl_name )) {\r
+ PyErr_SetString(PicklingError, "class has no name");\r
+ goto finally;\r
+ }\r
+\r
+ if (!( module = whichmodule(class, name)))\r
+ goto finally;\r
+\r
+\r
+ if ((module_size = PyString_Size(module)) < 0 ||\r
+ (name_size = PyString_Size(name)) < 0)\r
+ goto finally;\r
+\r
+ module_str = PyString_AS_STRING((PyStringObject *)module);\r
+ name_str = PyString_AS_STRING((PyStringObject *)name);\r
+\r
+ if (self->write_func(self, &inst, 1) < 0)\r
+ goto finally;\r
+\r
+ if (self->write_func(self, module_str, module_size) < 0)\r
+ goto finally;\r
+\r
+ if (self->write_func(self, "\n", 1) < 0)\r
+ goto finally;\r
+\r
+ if (self->write_func(self, name_str, name_size) < 0)\r
+ goto finally;\r
+\r
+ if (self->write_func(self, "\n", 1) < 0)\r
+ goto finally;\r
+ }\r
+ else if (self->write_func(self, &obj, 1) < 0) {\r
+ goto finally;\r
+ }\r
+\r
+ if ((getstate_func = PyObject_GetAttr(args, __getstate___str))) {\r
+ state = PyObject_Call(getstate_func, empty_tuple, NULL);\r
+ if (!state)\r
+ goto finally;\r
+ }\r
+ else {\r
+ if (PyErr_ExceptionMatches(PyExc_AttributeError))\r
+ PyErr_Clear();\r
+ else\r
+ goto finally;\r
+\r
+ if (!( state = PyObject_GetAttr(args, __dict___str))) {\r
+ if (PyErr_ExceptionMatches(PyExc_AttributeError))\r
+ PyErr_Clear();\r
+ else\r
+ goto finally;\r
+ res = 0;\r
+ goto finally;\r
+ }\r
+ }\r
+\r
+ if (!PyDict_Check(state)) {\r
+ if (put2(self, args) < 0)\r
+ goto finally;\r
+ }\r
+ else {\r
+ if (put(self, args) < 0)\r
+ goto finally;\r
+ }\r
+\r
+ if (save(self, state, 0) < 0)\r
+ goto finally;\r
+\r
+ if (self->write_func(self, &build, 1) < 0)\r
+ goto finally;\r
+\r
+ res = 0;\r
+\r
+ finally:\r
+ if (self->fast && !fast_save_leave(self, args))\r
+ res = -1;\r
+\r
+ Py_XDECREF(module);\r
+ Py_XDECREF(class);\r
+ Py_XDECREF(state);\r
+ Py_XDECREF(getinitargs_func);\r
+ Py_XDECREF(getstate_func);\r
+ Py_XDECREF(class_args);\r
+\r
+ return res;\r
+}\r
+\r
+\r
+static int\r
+save_global(Picklerobject *self, PyObject *args, PyObject *name)\r
+{\r
+ PyObject *global_name = 0, *module = 0, *mod = 0, *klass = 0;\r
+ char *name_str, *module_str;\r
+ int module_size, name_size, res = -1;\r
+\r
+ static char global = GLOBAL;\r
+\r
+ if (name) {\r
+ global_name = name;\r
+ Py_INCREF(global_name);\r
+ }\r
+ else {\r
+ if (!( global_name = PyObject_GetAttr(args, __name___str)))\r
+ goto finally;\r
+ }\r
+\r
+ if (!( module = whichmodule(args, global_name)))\r
+ goto finally;\r
+\r
+ if ((module_size = PyString_Size(module)) < 0 ||\r
+ (name_size = PyString_Size(global_name)) < 0)\r
+ goto finally;\r
+\r
+ module_str = PyString_AS_STRING((PyStringObject *)module);\r
+ name_str = PyString_AS_STRING((PyStringObject *)global_name);\r
+\r
+ /* XXX This can be doing a relative import. Clearly it shouldn't,\r
+ but I don't know how to stop it. :-( */\r
+ mod = PyImport_ImportModule(module_str);\r
+ if (mod == NULL) {\r
+ cPickle_ErrFormat(PicklingError,\r
+ "Can't pickle %s: import of module %s "\r
+ "failed",\r
+ "OS", args, module);\r
+ goto finally;\r
+ }\r
+ klass = PyObject_GetAttrString(mod, name_str);\r
+ if (klass == NULL) {\r
+ cPickle_ErrFormat(PicklingError,\r
+ "Can't pickle %s: attribute lookup %s.%s "\r
+ "failed",\r
+ "OSS", args, module, global_name);\r
+ goto finally;\r
+ }\r
+ if (klass != args) {\r
+ Py_DECREF(klass);\r
+ cPickle_ErrFormat(PicklingError,\r
+ "Can't pickle %s: it's not the same object "\r
+ "as %s.%s",\r
+ "OSS", args, module, global_name);\r
+ goto finally;\r
+ }\r
+ Py_DECREF(klass);\r
+\r
+ if (self->proto >= 2) {\r
+ /* See whether this is in the extension registry, and if\r
+ * so generate an EXT opcode.\r
+ */\r
+ PyObject *py_code; /* extension code as Python object */\r
+ long code; /* extension code as C value */\r
+ char c_str[5];\r
+ int n;\r
+\r
+ PyTuple_SET_ITEM(two_tuple, 0, module);\r
+ PyTuple_SET_ITEM(two_tuple, 1, global_name);\r
+ py_code = PyDict_GetItem(extension_registry, two_tuple);\r
+ if (py_code == NULL)\r
+ goto gen_global; /* not registered */\r
+\r
+ /* Verify py_code has the right type and value. */\r
+ if (!PyInt_Check(py_code)) {\r
+ cPickle_ErrFormat(PicklingError, "Can't pickle %s: "\r
+ "extension code %s isn't an integer",\r
+ "OO", args, py_code);\r
+ goto finally;\r
+ }\r
+ code = PyInt_AS_LONG(py_code);\r
+ if (code <= 0 || code > 0x7fffffffL) {\r
+ cPickle_ErrFormat(PicklingError, "Can't pickle %s: "\r
+ "extension code %ld is out of range",\r
+ "Ol", args, code);\r
+ goto finally;\r
+ }\r
+\r
+ /* Generate an EXT opcode. */\r
+ if (code <= 0xff) {\r
+ c_str[0] = EXT1;\r
+ c_str[1] = (char)code;\r
+ n = 2;\r
+ }\r
+ else if (code <= 0xffff) {\r
+ c_str[0] = EXT2;\r
+ c_str[1] = (char)(code & 0xff);\r
+ c_str[2] = (char)((code >> 8) & 0xff);\r
+ n = 3;\r
+ }\r
+ else {\r
+ c_str[0] = EXT4;\r
+ c_str[1] = (char)(code & 0xff);\r
+ c_str[2] = (char)((code >> 8) & 0xff);\r
+ c_str[3] = (char)((code >> 16) & 0xff);\r
+ c_str[4] = (char)((code >> 24) & 0xff);\r
+ n = 5;\r
+ }\r
+\r
+ if (self->write_func(self, c_str, n) >= 0)\r
+ res = 0;\r
+ goto finally; /* and don't memoize */\r
+ }\r
+\r
+ gen_global:\r
+ if (self->write_func(self, &global, 1) < 0)\r
+ goto finally;\r
+\r
+ if (self->write_func(self, module_str, module_size) < 0)\r
+ goto finally;\r
+\r
+ if (self->write_func(self, "\n", 1) < 0)\r
+ goto finally;\r
+\r
+ if (self->write_func(self, name_str, name_size) < 0)\r
+ goto finally;\r
+\r
+ if (self->write_func(self, "\n", 1) < 0)\r
+ goto finally;\r
+\r
+ if (put(self, args) < 0)\r
+ goto finally;\r
+\r
+ res = 0;\r
+\r
+ finally:\r
+ Py_XDECREF(module);\r
+ Py_XDECREF(global_name);\r
+ Py_XDECREF(mod);\r
+\r
+ return res;\r
+}\r
+\r
+static int\r
+save_pers(Picklerobject *self, PyObject *args, PyObject *f)\r
+{\r
+ PyObject *pid = 0;\r
+ Py_ssize_t size;\r
+ int res = -1;\r
+\r
+ static char persid = PERSID, binpersid = BINPERSID;\r
+\r
+ Py_INCREF(args);\r
+ ARG_TUP(self, args);\r
+ if (self->arg) {\r
+ pid = PyObject_Call(f, self->arg, NULL);\r
+ FREE_ARG_TUP(self);\r
+ }\r
+ if (! pid) return -1;\r
+\r
+ if (pid != Py_None) {\r
+ if (!self->bin) {\r
+ if (!PyString_Check(pid)) {\r
+ PyErr_SetString(PicklingError,\r
+ "persistent id must be string");\r
+ goto finally;\r
+ }\r
+\r
+ if (self->write_func(self, &persid, 1) < 0)\r
+ goto finally;\r
+\r
+ if ((size = PyString_Size(pid)) < 0)\r
+ goto finally;\r
+\r
+ if (self->write_func(self,\r
+ PyString_AS_STRING(\r
+ (PyStringObject *)pid),\r
+ size) < 0)\r
+ goto finally;\r
+\r
+ if (self->write_func(self, "\n", 1) < 0)\r
+ goto finally;\r
+\r
+ res = 1;\r
+ goto finally;\r
+ }\r
+ else if (save(self, pid, 1) >= 0) {\r
+ if (self->write_func(self, &binpersid, 1) < 0)\r
+ res = -1;\r
+ else\r
+ res = 1;\r
+ }\r
+\r
+ goto finally;\r
+ }\r
+\r
+ res = 0;\r
+\r
+ finally:\r
+ Py_XDECREF(pid);\r
+\r
+ return res;\r
+}\r
+\r
+/* We're saving ob, and args is the 2-thru-5 tuple returned by the\r
+ * appropriate __reduce__ method for ob.\r
+ */\r
+static int\r
+save_reduce(Picklerobject *self, PyObject *args, PyObject *fn, PyObject *ob)\r
+{\r
+ PyObject *callable;\r
+ PyObject *argtup;\r
+ PyObject *state = NULL;\r
+ PyObject *listitems = Py_None;\r
+ PyObject *dictitems = Py_None;\r
+ Py_ssize_t size;\r
+\r
+ int use_newobj = self->proto >= 2;\r
+\r
+ static char reduce = REDUCE;\r
+ static char build = BUILD;\r
+ static char newobj = NEWOBJ;\r
+\r
+ size = PyTuple_Size(args);\r
+ if (size < 2 || size > 5) {\r
+ cPickle_ErrFormat(PicklingError, "tuple returned by "\r
+ "%s must contain 2 through 5 elements",\r
+ "O", fn);\r
+ return -1;\r
+ }\r
+\r
+ if (! PyArg_UnpackTuple(args, "save_reduce", 2, 5,\r
+ &callable,\r
+ &argtup,\r
+ &state,\r
+ &listitems,\r
+ &dictitems))\r
+ return -1;\r
+\r
+ if (!PyTuple_Check(argtup)) {\r
+ cPickle_ErrFormat(PicklingError, "Second element of "\r
+ "tuple returned by %s must be a tuple",\r
+ "O", fn);\r
+ return -1;\r
+ }\r
+\r
+ if (state == Py_None)\r
+ state = NULL;\r
+\r
+ if (listitems == Py_None)\r
+ listitems = NULL;\r
+ else if (!PyIter_Check(listitems)) {\r
+ cPickle_ErrFormat(PicklingError, "Fourth element of "\r
+ "tuple returned by %s must be an iterator, not %s",\r
+ "Os", fn, Py_TYPE(listitems)->tp_name);\r
+ return -1;\r
+ }\r
+\r
+ if (dictitems == Py_None)\r
+ dictitems = NULL;\r
+ else if (!PyIter_Check(dictitems)) {\r
+ cPickle_ErrFormat(PicklingError, "Fifth element of "\r
+ "tuple returned by %s must be an iterator, not %s",\r
+ "Os", fn, Py_TYPE(dictitems)->tp_name);\r
+ return -1;\r
+ }\r
+\r
+ /* Protocol 2 special case: if callable's name is __newobj__, use\r
+ * NEWOBJ. This consumes a lot of code.\r
+ */\r
+ if (use_newobj) {\r
+ PyObject *temp = PyObject_GetAttr(callable, __name___str);\r
+\r
+ if (temp == NULL) {\r
+ if (PyErr_ExceptionMatches(PyExc_AttributeError))\r
+ PyErr_Clear();\r
+ else\r
+ return -1;\r
+ use_newobj = 0;\r
+ }\r
+ else {\r
+ use_newobj = PyString_Check(temp) &&\r
+ strcmp(PyString_AS_STRING(temp),\r
+ "__newobj__") == 0;\r
+ Py_DECREF(temp);\r
+ }\r
+ }\r
+ if (use_newobj) {\r
+ PyObject *cls;\r
+ PyObject *newargtup;\r
+ Py_ssize_t n, i;\r
+\r
+ /* Sanity checks. */\r
+ n = PyTuple_Size(argtup);\r
+ if (n < 1) {\r
+ PyErr_SetString(PicklingError, "__newobj__ arglist "\r
+ "is empty");\r
+ return -1;\r
+ }\r
+\r
+ cls = PyTuple_GET_ITEM(argtup, 0);\r
+ if (! PyObject_HasAttrString(cls, "__new__")) {\r
+ PyErr_SetString(PicklingError, "args[0] from "\r
+ "__newobj__ args has no __new__");\r
+ return -1;\r
+ }\r
+\r
+ /* XXX How could ob be NULL? */\r
+ if (ob != NULL) {\r
+ PyObject *ob_dot_class;\r
+\r
+ ob_dot_class = PyObject_GetAttr(ob, __class___str);\r
+ if (ob_dot_class == NULL) {\r
+ if (PyErr_ExceptionMatches(\r
+ PyExc_AttributeError))\r
+ PyErr_Clear();\r
+ else\r
+ return -1;\r
+ }\r
+ i = ob_dot_class != cls; /* true iff a problem */\r
+ Py_XDECREF(ob_dot_class);\r
+ if (i) {\r
+ PyErr_SetString(PicklingError, "args[0] from "\r
+ "__newobj__ args has the wrong class");\r
+ return -1;\r
+ }\r
+ }\r
+\r
+ /* Save the class and its __new__ arguments. */\r
+ if (save(self, cls, 0) < 0)\r
+ return -1;\r
+\r
+ newargtup = PyTuple_New(n-1); /* argtup[1:] */\r
+ if (newargtup == NULL)\r
+ return -1;\r
+ for (i = 1; i < n; ++i) {\r
+ PyObject *temp = PyTuple_GET_ITEM(argtup, i);\r
+ Py_INCREF(temp);\r
+ PyTuple_SET_ITEM(newargtup, i-1, temp);\r
+ }\r
+ i = save(self, newargtup, 0);\r
+ Py_DECREF(newargtup);\r
+ if (i < 0)\r
+ return -1;\r
+\r
+ /* Add NEWOBJ opcode. */\r
+ if (self->write_func(self, &newobj, 1) < 0)\r
+ return -1;\r
+ }\r
+ else {\r
+ /* Not using NEWOBJ. */\r
+ if (save(self, callable, 0) < 0 ||\r
+ save(self, argtup, 0) < 0 ||\r
+ self->write_func(self, &reduce, 1) < 0)\r
+ return -1;\r
+ }\r
+\r
+ /* Memoize. */\r
+ /* XXX How can ob be NULL? */\r
+ if (ob != NULL) {\r
+ if (state && !PyDict_Check(state)) {\r
+ if (put2(self, ob) < 0)\r
+ return -1;\r
+ }\r
+ else if (put(self, ob) < 0)\r
+ return -1;\r
+ }\r
+\r
+\r
+ if (listitems && batch_list(self, listitems) < 0)\r
+ return -1;\r
+\r
+ if (dictitems && batch_dict(self, dictitems) < 0)\r
+ return -1;\r
+\r
+ if (state) {\r
+ if (save(self, state, 0) < 0 ||\r
+ self->write_func(self, &build, 1) < 0)\r
+ return -1;\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+static int\r
+save(Picklerobject *self, PyObject *args, int pers_save)\r
+{\r
+ PyTypeObject *type;\r
+ PyObject *py_ob_id = 0, *__reduce__ = 0, *t = 0;\r
+ int res = -1;\r
+ int tmp;\r
+\r
+ if (Py_EnterRecursiveCall(" while pickling an object"))\r
+ return -1;\r
+\r
+ if (!pers_save && self->pers_func) {\r
+ if ((tmp = save_pers(self, args, self->pers_func)) != 0) {\r
+ res = tmp;\r
+ goto finally;\r
+ }\r
+ }\r
+\r
+ if (args == Py_None) {\r
+ res = save_none(self, args);\r
+ goto finally;\r
+ }\r
+\r
+ type = Py_TYPE(args);\r
+\r
+ switch (type->tp_name[0]) {\r
+ case 'b':\r
+ if (args == Py_False || args == Py_True) {\r
+ res = save_bool(self, args);\r
+ goto finally;\r
+ }\r
+ break;\r
+ case 'i':\r
+ if (type == &PyInt_Type) {\r
+ res = save_int(self, args);\r
+ goto finally;\r
+ }\r
+ break;\r
+\r
+ case 'l':\r
+ if (type == &PyLong_Type) {\r
+ res = save_long(self, args);\r
+ goto finally;\r
+ }\r
+ break;\r
+\r
+ case 'f':\r
+ if (type == &PyFloat_Type) {\r
+ res = save_float(self, args);\r
+ goto finally;\r
+ }\r
+ break;\r
+\r
+ case 't':\r
+ if (type == &PyTuple_Type && PyTuple_Size(args) == 0) {\r
+ res = save_tuple(self, args);\r
+ goto finally;\r
+ }\r
+ break;\r
+\r
+ case 's':\r
+ if ((type == &PyString_Type) && (PyString_GET_SIZE(args) < 2)) {\r
+ res = save_string(self, args, 0);\r
+ goto finally;\r
+ }\r
+ break;\r
+\r
+#ifdef Py_USING_UNICODE\r
+ case 'u':\r
+ if ((type == &PyUnicode_Type) && (PyString_GET_SIZE(args) < 2)) {\r
+ res = save_unicode(self, args, 0);\r
+ goto finally;\r
+ }\r
+ break;\r
+#endif\r
+ }\r
+\r
+ if (Py_REFCNT(args) > 1) {\r
+ if (!( py_ob_id = PyLong_FromVoidPtr(args)))\r
+ goto finally;\r
+\r
+ if (PyDict_GetItem(self->memo, py_ob_id)) {\r
+ if (get(self, py_ob_id) < 0)\r
+ goto finally;\r
+\r
+ res = 0;\r
+ goto finally;\r
+ }\r
+ }\r
+\r
+ switch (type->tp_name[0]) {\r
+ case 's':\r
+ if (type == &PyString_Type) {\r
+ res = save_string(self, args, 1);\r
+ goto finally;\r
+ }\r
+ break;\r
+\r
+#ifdef Py_USING_UNICODE\r
+ case 'u':\r
+ if (type == &PyUnicode_Type) {\r
+ res = save_unicode(self, args, 1);\r
+ goto finally;\r
+ }\r
+ break;\r
+#endif\r
+\r
+ case 't':\r
+ if (type == &PyTuple_Type) {\r
+ res = save_tuple(self, args);\r
+ goto finally;\r
+ }\r
+ if (type == &PyType_Type) {\r
+ res = save_global(self, args, NULL);\r
+ goto finally;\r
+ }\r
+ break;\r
+\r
+ case 'l':\r
+ if (type == &PyList_Type) {\r
+ res = save_list(self, args);\r
+ goto finally;\r
+ }\r
+ break;\r
+\r
+ case 'd':\r
+ if (type == &PyDict_Type) {\r
+ res = save_dict(self, args);\r
+ goto finally;\r
+ }\r
+ break;\r
+\r
+ case 'i':\r
+ if (type == &PyInstance_Type) {\r
+ res = save_inst(self, args);\r
+ goto finally;\r
+ }\r
+ break;\r
+\r
+ case 'c':\r
+ if (type == &PyClass_Type) {\r
+ res = save_global(self, args, NULL);\r
+ goto finally;\r
+ }\r
+ break;\r
+\r
+ case 'f':\r
+ if (type == &PyFunction_Type) {\r
+ res = save_global(self, args, NULL);\r
+ if (res && PyErr_ExceptionMatches(PickleError)) {\r
+ /* fall back to reduce */\r
+ PyErr_Clear();\r
+ break;\r
+ }\r
+ goto finally;\r
+ }\r
+ break;\r
+\r
+ case 'b':\r
+ if (type == &PyCFunction_Type) {\r
+ res = save_global(self, args, NULL);\r
+ goto finally;\r
+ }\r
+ }\r
+\r
+ if (!pers_save && self->inst_pers_func) {\r
+ if ((tmp = save_pers(self, args, self->inst_pers_func)) != 0) {\r
+ res = tmp;\r
+ goto finally;\r
+ }\r
+ }\r
+\r
+ /* Get a reduction callable, and call it. This may come from\r
+ * copy_reg.dispatch_table, the object's __reduce_ex__ method,\r
+ * or the object's __reduce__ method.\r
+ */\r
+ __reduce__ = PyDict_GetItem(dispatch_table, (PyObject *)type);\r
+ if (__reduce__ != NULL) {\r
+ Py_INCREF(__reduce__);\r
+ Py_INCREF(args);\r
+ ARG_TUP(self, args);\r
+ if (self->arg) {\r
+ t = PyObject_Call(__reduce__, self->arg, NULL);\r
+ FREE_ARG_TUP(self);\r
+ }\r
+ }\r
+ else {\r
+ if (PyType_IsSubtype(type, &PyType_Type)) {\r
+ res = save_global(self, args, NULL);\r
+ goto finally;\r
+ }\r
+\r
+ /* Check for a __reduce_ex__ method. */\r
+ __reduce__ = PyObject_GetAttr(args, __reduce_ex___str);\r
+ if (__reduce__ != NULL) {\r
+ t = PyInt_FromLong(self->proto);\r
+ if (t != NULL) {\r
+ ARG_TUP(self, t);\r
+ t = NULL;\r
+ if (self->arg) {\r
+ t = PyObject_Call(__reduce__,\r
+ self->arg, NULL);\r
+ FREE_ARG_TUP(self);\r
+ }\r
+ }\r
+ }\r
+ else {\r
+ if (PyErr_ExceptionMatches(PyExc_AttributeError))\r
+ PyErr_Clear();\r
+ else\r
+ goto finally;\r
+ /* Check for a __reduce__ method. */\r
+ __reduce__ = PyObject_GetAttr(args, __reduce___str);\r
+ if (__reduce__ != NULL) {\r
+ t = PyObject_Call(__reduce__,\r
+ empty_tuple, NULL);\r
+ }\r
+ else {\r
+ PyErr_SetObject(UnpickleableError, args);\r
+ goto finally;\r
+ }\r
+ }\r
+ }\r
+\r
+ if (t == NULL)\r
+ goto finally;\r
+\r
+ if (PyString_Check(t)) {\r
+ res = save_global(self, args, t);\r
+ goto finally;\r
+ }\r
+\r
+ if (!PyTuple_Check(t)) {\r
+ cPickle_ErrFormat(PicklingError, "Value returned by "\r
+ "%s must be string or tuple",\r
+ "O", __reduce__);\r
+ goto finally;\r
+ }\r
+\r
+ res = save_reduce(self, t, __reduce__, args);\r
+\r
+ finally:\r
+ Py_LeaveRecursiveCall();\r
+ Py_XDECREF(py_ob_id);\r
+ Py_XDECREF(__reduce__);\r
+ Py_XDECREF(t);\r
+\r
+ return res;\r
+}\r
+\r
+\r
+static int\r
+dump(Picklerobject *self, PyObject *args)\r
+{\r
+ static char stop = STOP;\r
+\r
+ if (self->proto >= 2) {\r
+ char bytes[2];\r
+\r
+ bytes[0] = PROTO;\r
+ assert(self->proto >= 0 && self->proto < 256);\r
+ bytes[1] = (char)self->proto;\r
+ if (self->write_func(self, bytes, 2) < 0)\r
+ return -1;\r
+ }\r
+\r
+ if (save(self, args, 0) < 0)\r
+ return -1;\r
+\r
+ if (self->write_func(self, &stop, 1) < 0)\r
+ return -1;\r
+\r
+ if (self->write_func(self, NULL, 0) < 0)\r
+ return -1;\r
+\r
+ return 0;\r
+}\r
+\r
+static PyObject *\r
+Pickle_clear_memo(Picklerobject *self, PyObject *args)\r
+{\r
+ if (self->memo)\r
+ PyDict_Clear(self->memo);\r
+ Py_INCREF(Py_None);\r
+ return Py_None;\r
+}\r
+\r
+static PyObject *\r
+Pickle_getvalue(Picklerobject *self, PyObject *args)\r
+{\r
+ Py_ssize_t l, i, rsize, ssize, clear=1, lm;\r
+ long ik;\r
+ PyObject *k, *r;\r
+ char *s, *p, *have_get;\r
+ Pdata *data;\r
+\r
+ /* Can be called by Python code or C code */\r
+ if (args && !PyArg_ParseTuple(args, "|i:getvalue", &clear))\r
+ return NULL;\r
+\r
+ /* Check to make sure we are based on a list */\r
+ if (! Pdata_Check(self->file)) {\r
+ PyErr_SetString(PicklingError,\r
+ "Attempt to getvalue() a non-list-based pickler");\r
+ return NULL;\r
+ }\r
+\r
+ /* flush write buffer */\r
+ if (write_other(self, NULL, 0) < 0) return NULL;\r
+\r
+ data=(Pdata*)self->file;\r
+ l=data->length;\r
+\r
+ /* set up an array to hold get/put status */\r
+ lm = PyDict_Size(self->memo);\r
+ if (lm < 0) return NULL;\r
+ lm++;\r
+ have_get = malloc(lm);\r
+ if (have_get == NULL) return PyErr_NoMemory();\r
+ memset(have_get, 0, lm);\r
+\r
+ /* Scan for gets. */\r
+ for (rsize = 0, i = l; --i >= 0; ) {\r
+ k = data->data[i];\r
+\r
+ if (PyString_Check(k))\r
+ rsize += PyString_GET_SIZE(k);\r
+\r
+ else if (PyInt_Check(k)) { /* put */\r
+ ik = PyInt_AS_LONG((PyIntObject*)k);\r
+ if (ik >= lm || ik == 0) {\r
+ PyErr_SetString(PicklingError,\r
+ "Invalid get data");\r
+ goto err;\r
+ }\r
+ if (have_get[ik]) /* with matching get */\r
+ rsize += ik < 256 ? 2 : 5;\r
+ }\r
+\r
+ else if (! (PyTuple_Check(k) &&\r
+ PyTuple_GET_SIZE(k) == 2 &&\r
+ PyInt_Check((k = PyTuple_GET_ITEM(k, 0))))\r
+ ) {\r
+ PyErr_SetString(PicklingError,\r
+ "Unexpected data in internal list");\r
+ goto err;\r
+ }\r
+\r
+ else { /* put */\r
+ ik = PyInt_AS_LONG((PyIntObject *)k);\r
+ if (ik >= lm || ik == 0) {\r
+ PyErr_SetString(PicklingError,\r
+ "Invalid get data");\r
+ return NULL;\r
+ }\r
+ have_get[ik] = 1;\r
+ rsize += ik < 256 ? 2 : 5;\r
+ }\r
+ }\r
+\r
+ /* Now generate the result */\r
+ r = PyString_FromStringAndSize(NULL, rsize);\r
+ if (r == NULL) goto err;\r
+ s = PyString_AS_STRING((PyStringObject *)r);\r
+\r
+ for (i = 0; i < l; i++) {\r
+ k = data->data[i];\r
+\r
+ if (PyString_Check(k)) {\r
+ ssize = PyString_GET_SIZE(k);\r
+ if (ssize) {\r
+ p=PyString_AS_STRING((PyStringObject *)k);\r
+ while (--ssize >= 0)\r
+ *s++ = *p++;\r
+ }\r
+ }\r
+\r
+ else if (PyTuple_Check(k)) { /* get */\r
+ ik = PyInt_AS_LONG((PyIntObject *)\r
+ PyTuple_GET_ITEM(k, 0));\r
+ if (ik < 256) {\r
+ *s++ = BINGET;\r
+ *s++ = (int)(ik & 0xff);\r
+ }\r
+ else {\r
+ *s++ = LONG_BINGET;\r
+ *s++ = (int)(ik & 0xff);\r
+ *s++ = (int)((ik >> 8) & 0xff);\r
+ *s++ = (int)((ik >> 16) & 0xff);\r
+ *s++ = (int)((ik >> 24) & 0xff);\r
+ }\r
+ }\r
+\r
+ else { /* put */\r
+ ik = PyInt_AS_LONG((PyIntObject*)k);\r
+\r
+ if (have_get[ik]) { /* with matching get */\r
+ if (ik < 256) {\r
+ *s++ = BINPUT;\r
+ *s++ = (int)(ik & 0xff);\r
+ }\r
+ else {\r
+ *s++ = LONG_BINPUT;\r
+ *s++ = (int)(ik & 0xff);\r
+ *s++ = (int)((ik >> 8) & 0xff);\r
+ *s++ = (int)((ik >> 16) & 0xff);\r
+ *s++ = (int)((ik >> 24) & 0xff);\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ if (clear) {\r
+ PyDict_Clear(self->memo);\r
+ Pdata_clear(data, 0);\r
+ }\r
+\r
+ free(have_get);\r
+ return r;\r
+ err:\r
+ free(have_get);\r
+ return NULL;\r
+}\r
+\r
+static PyObject *\r
+Pickler_dump(Picklerobject *self, PyObject *args)\r
+{\r
+ PyObject *ob;\r
+ int get=0;\r
+\r
+ if (!( PyArg_ParseTuple(args, "O|i:dump", &ob, &get)))\r
+ return NULL;\r
+\r
+ if (dump(self, ob) < 0)\r
+ return NULL;\r
+\r
+ if (get) return Pickle_getvalue(self, NULL);\r
+\r
+ /* XXX Why does dump() return self? */\r
+ Py_INCREF(self);\r
+ return (PyObject*)self;\r
+}\r
+\r
+\r
+static struct PyMethodDef Pickler_methods[] =\r
+{\r
+ {"dump", (PyCFunction)Pickler_dump, METH_VARARGS,\r
+ PyDoc_STR("dump(object) -- "\r
+ "Write an object in pickle format to the object's pickle stream")},\r
+ {"clear_memo", (PyCFunction)Pickle_clear_memo, METH_NOARGS,\r
+ PyDoc_STR("clear_memo() -- Clear the picklers memo")},\r
+ {"getvalue", (PyCFunction)Pickle_getvalue, METH_VARARGS,\r
+ PyDoc_STR("getvalue() -- Finish picking a list-based pickle")},\r
+ {NULL, NULL} /* sentinel */\r
+};\r
+\r
+\r
+static Picklerobject *\r
+newPicklerobject(PyObject *file, int proto)\r
+{\r
+ Picklerobject *self;\r
+\r
+ if (proto < 0)\r
+ proto = HIGHEST_PROTOCOL;\r
+ if (proto > HIGHEST_PROTOCOL) {\r
+ PyErr_Format(PyExc_ValueError, "pickle protocol %d asked for; "\r
+ "the highest available protocol is %d",\r
+ proto, HIGHEST_PROTOCOL);\r
+ return NULL;\r
+ }\r
+\r
+ self = PyObject_GC_New(Picklerobject, &Picklertype);\r
+ if (self == NULL)\r
+ return NULL;\r
+ self->proto = proto;\r
+ self->bin = proto > 0;\r
+ self->fp = NULL;\r
+ self->write = NULL;\r
+ self->memo = NULL;\r
+ self->arg = NULL;\r
+ self->pers_func = NULL;\r
+ self->inst_pers_func = NULL;\r
+ self->write_buf = NULL;\r
+ self->fast = 0;\r
+ self->fast_container = 0;\r
+ self->fast_memo = NULL;\r
+ self->buf_size = 0;\r
+ self->dispatch_table = NULL;\r
+\r
+ self->file = NULL;\r
+ if (file)\r
+ Py_INCREF(file);\r
+ else {\r
+ file = Pdata_New();\r
+ if (file == NULL)\r
+ goto err;\r
+ }\r
+ self->file = file;\r
+\r
+ if (!( self->memo = PyDict_New()))\r
+ goto err;\r
+\r
+ if (PyFile_Check(file)) {\r
+ self->fp = PyFile_AsFile(file);\r
+ if (self->fp == NULL) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "I/O operation on closed file");\r
+ goto err;\r
+ }\r
+ self->write_func = write_file;\r
+ }\r
+ else if (PycStringIO_OutputCheck(file)) {\r
+ self->write_func = write_cStringIO;\r
+ }\r
+ else if (file == Py_None) {\r
+ self->write_func = write_none;\r
+ }\r
+ else {\r
+ self->write_func = write_other;\r
+\r
+ if (! Pdata_Check(file)) {\r
+ self->write = PyObject_GetAttr(file, write_str);\r
+ if (!self->write) {\r
+ PyErr_Clear();\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "argument must have 'write' "\r
+ "attribute");\r
+ goto err;\r
+ }\r
+ }\r
+\r
+ self->write_buf = (char *)PyMem_Malloc(WRITE_BUF_SIZE);\r
+ if (self->write_buf == NULL) {\r
+ PyErr_NoMemory();\r
+ goto err;\r
+ }\r
+ }\r
+\r
+ if (PyEval_GetRestricted()) {\r
+ /* Restricted execution, get private tables */\r
+ PyObject *m = PyImport_ImportModule("copy_reg");\r
+\r
+ if (m == NULL)\r
+ goto err;\r
+ self->dispatch_table = PyObject_GetAttr(m, dispatch_table_str);\r
+ Py_DECREF(m);\r
+ if (self->dispatch_table == NULL)\r
+ goto err;\r
+ }\r
+ else {\r
+ self->dispatch_table = dispatch_table;\r
+ Py_INCREF(dispatch_table);\r
+ }\r
+ PyObject_GC_Track(self);\r
+\r
+ return self;\r
+\r
+ err:\r
+ Py_DECREF(self);\r
+ return NULL;\r
+}\r
+\r
+\r
+static PyObject *\r
+get_Pickler(PyObject *self, PyObject *args, PyObject *kwds)\r
+{\r
+ static char *kwlist[] = {"file", "protocol", NULL};\r
+ PyObject *file = NULL;\r
+ int proto = 0;\r
+\r
+ /* XXX\r
+ * The documented signature is Pickler(file, protocol=0), but this\r
+ * accepts Pickler() and Pickler(integer) too. The meaning then\r
+ * is clear as mud, undocumented, and not supported by pickle.py.\r
+ * I'm told Zope uses this, but I haven't traced into this code\r
+ * far enough to figure out what it means.\r
+ */\r
+ if (!PyArg_ParseTuple(args, "|i:Pickler", &proto)) {\r
+ PyErr_Clear();\r
+ proto = 0;\r
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|i:Pickler",\r
+ kwlist, &file, &proto))\r
+ return NULL;\r
+ }\r
+ return (PyObject *)newPicklerobject(file, proto);\r
+}\r
+\r
+\r
+static void\r
+Pickler_dealloc(Picklerobject *self)\r
+{\r
+ PyObject_GC_UnTrack(self);\r
+ Py_XDECREF(self->write);\r
+ Py_XDECREF(self->memo);\r
+ Py_XDECREF(self->fast_memo);\r
+ Py_XDECREF(self->arg);\r
+ Py_XDECREF(self->file);\r
+ Py_XDECREF(self->pers_func);\r
+ Py_XDECREF(self->inst_pers_func);\r
+ Py_XDECREF(self->dispatch_table);\r
+ PyMem_Free(self->write_buf);\r
+ Py_TYPE(self)->tp_free((PyObject *)self);\r
+}\r
+\r
+static int\r
+Pickler_traverse(Picklerobject *self, visitproc visit, void *arg)\r
+{\r
+ Py_VISIT(self->write);\r
+ Py_VISIT(self->memo);\r
+ Py_VISIT(self->fast_memo);\r
+ Py_VISIT(self->arg);\r
+ Py_VISIT(self->file);\r
+ Py_VISIT(self->pers_func);\r
+ Py_VISIT(self->inst_pers_func);\r
+ Py_VISIT(self->dispatch_table);\r
+ return 0;\r
+}\r
+\r
+static int\r
+Pickler_clear(Picklerobject *self)\r
+{\r
+ Py_CLEAR(self->write);\r
+ Py_CLEAR(self->memo);\r
+ Py_CLEAR(self->fast_memo);\r
+ Py_CLEAR(self->arg);\r
+ Py_CLEAR(self->file);\r
+ Py_CLEAR(self->pers_func);\r
+ Py_CLEAR(self->inst_pers_func);\r
+ Py_CLEAR(self->dispatch_table);\r
+ return 0;\r
+}\r
+\r
+static PyObject *\r
+Pickler_get_pers_func(Picklerobject *p)\r
+{\r
+ if (p->pers_func == NULL)\r
+ PyErr_SetString(PyExc_AttributeError, "persistent_id");\r
+ else\r
+ Py_INCREF(p->pers_func);\r
+ return p->pers_func;\r
+}\r
+\r
+static int\r
+Pickler_set_pers_func(Picklerobject *p, PyObject *v)\r
+{\r
+ if (v == NULL) {\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "attribute deletion is not supported");\r
+ return -1;\r
+ }\r
+ Py_XDECREF(p->pers_func);\r
+ Py_INCREF(v);\r
+ p->pers_func = v;\r
+ return 0;\r
+}\r
+\r
+static int\r
+Pickler_set_inst_pers_func(Picklerobject *p, PyObject *v)\r
+{\r
+ if (v == NULL) {\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "attribute deletion is not supported");\r
+ return -1;\r
+ }\r
+ Py_XDECREF(p->inst_pers_func);\r
+ Py_INCREF(v);\r
+ p->inst_pers_func = v;\r
+ return 0;\r
+}\r
+\r
+static PyObject *\r
+Pickler_get_memo(Picklerobject *p)\r
+{\r
+ if (p->memo == NULL)\r
+ PyErr_SetString(PyExc_AttributeError, "memo");\r
+ else\r
+ Py_INCREF(p->memo);\r
+ return p->memo;\r
+}\r
+\r
+static int\r
+Pickler_set_memo(Picklerobject *p, PyObject *v)\r
+{\r
+ if (v == NULL) {\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "attribute deletion is not supported");\r
+ return -1;\r
+ }\r
+ if (!PyDict_Check(v)) {\r
+ PyErr_SetString(PyExc_TypeError, "memo must be a dictionary");\r
+ return -1;\r
+ }\r
+ Py_XDECREF(p->memo);\r
+ Py_INCREF(v);\r
+ p->memo = v;\r
+ return 0;\r
+}\r
+\r
+static PyObject *\r
+Pickler_get_error(Picklerobject *p)\r
+{\r
+ /* why is this an attribute on the Pickler? */\r
+ Py_INCREF(PicklingError);\r
+ return PicklingError;\r
+}\r
+\r
+static PyMemberDef Pickler_members[] = {\r
+ {"binary", T_INT, offsetof(Picklerobject, bin)},\r
+ {"fast", T_INT, offsetof(Picklerobject, fast)},\r
+ {NULL}\r
+};\r
+\r
+static PyGetSetDef Pickler_getsets[] = {\r
+ {"persistent_id", (getter)Pickler_get_pers_func,\r
+ (setter)Pickler_set_pers_func},\r
+ {"inst_persistent_id", NULL, (setter)Pickler_set_inst_pers_func},\r
+ {"memo", (getter)Pickler_get_memo, (setter)Pickler_set_memo},\r
+ {"PicklingError", (getter)Pickler_get_error, NULL},\r
+ {NULL}\r
+};\r
+\r
+PyDoc_STRVAR(Picklertype__doc__,\r
+"Objects that know how to pickle objects\n");\r
+\r
+static PyTypeObject Picklertype = {\r
+ PyVarObject_HEAD_INIT(NULL, 0)\r
+ "cPickle.Pickler", /*tp_name*/\r
+ sizeof(Picklerobject), /*tp_basicsize*/\r
+ 0,\r
+ (destructor)Pickler_dealloc, /* tp_dealloc */\r
+ 0, /* tp_print */\r
+ 0, /* tp_getattr */\r
+ 0, /* tp_setattr */\r
+ 0, /* tp_compare */\r
+ 0, /* tp_repr */\r
+ 0, /* tp_as_number */\r
+ 0, /* tp_as_sequence */\r
+ 0, /* tp_as_mapping */\r
+ 0, /* tp_hash */\r
+ 0, /* tp_call */\r
+ 0, /* tp_str */\r
+ PyObject_GenericGetAttr, /* tp_getattro */\r
+ PyObject_GenericSetAttr, /* tp_setattro */\r
+ 0, /* tp_as_buffer */\r
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,\r
+ Picklertype__doc__, /* tp_doc */\r
+ (traverseproc)Pickler_traverse, /* tp_traverse */\r
+ (inquiry)Pickler_clear, /* tp_clear */\r
+ 0, /* tp_richcompare */\r
+ 0, /* tp_weaklistoffset */\r
+ 0, /* tp_iter */\r
+ 0, /* tp_iternext */\r
+ Pickler_methods, /* tp_methods */\r
+ Pickler_members, /* tp_members */\r
+ Pickler_getsets, /* tp_getset */\r
+};\r
+\r
+static PyObject *\r
+find_class(PyObject *py_module_name, PyObject *py_global_name, PyObject *fc)\r
+{\r
+ PyObject *global = 0, *module;\r
+\r
+ if (fc) {\r
+ if (fc==Py_None) {\r
+ PyErr_SetString(UnpicklingError, "Global and instance "\r
+ "pickles are not supported.");\r
+ return NULL;\r
+ }\r
+ return PyObject_CallFunctionObjArgs(fc, py_module_name,\r
+ py_global_name, NULL);\r
+ }\r
+\r
+ module = PySys_GetObject("modules");\r
+ if (module == NULL)\r
+ return NULL;\r
+\r
+ module = PyDict_GetItem(module, py_module_name);\r
+ if (module == NULL) {\r
+ module = PyImport_Import(py_module_name);\r
+ if (!module)\r
+ return NULL;\r
+ global = PyObject_GetAttr(module, py_global_name);\r
+ Py_DECREF(module);\r
+ }\r
+ else\r
+ global = PyObject_GetAttr(module, py_global_name);\r
+ return global;\r
+}\r
+\r
+static Py_ssize_t\r
+marker(Unpicklerobject *self)\r
+{\r
+ if (self->num_marks < 1) {\r
+ PyErr_SetString(UnpicklingError, "could not find MARK");\r
+ return -1;\r
+ }\r
+\r
+ return self->marks[--self->num_marks];\r
+}\r
+\r
+\r
+static int\r
+load_none(Unpicklerobject *self)\r
+{\r
+ PDATA_APPEND(self->stack, Py_None, -1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+bad_readline(void)\r
+{\r
+ PyErr_SetString(UnpicklingError, "pickle data was truncated");\r
+ return -1;\r
+}\r
+\r
+static int\r
+load_int(Unpicklerobject *self)\r
+{\r
+ PyObject *py_int = 0;\r
+ char *endptr, *s;\r
+ Py_ssize_t len;\r
+ int res = -1;\r
+ long l;\r
+\r
+ if ((len = self->readline_func(self, &s)) < 0) return -1;\r
+ if (len < 2) return bad_readline();\r
+ if (!( s=pystrndup(s,len))) return -1;\r
+\r
+ errno = 0;\r
+ l = strtol(s, &endptr, 0);\r
+\r
+ if (errno || (*endptr != '\n') || (endptr[1] != '\0')) {\r
+ /* Hm, maybe we've got something long. Let's try reading\r
+ it as a Python long object. */\r
+ errno = 0;\r
+ py_int = PyLong_FromString(s, NULL, 0);\r
+ if (py_int == NULL) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "could not convert string to int");\r
+ goto finally;\r
+ }\r
+ }\r
+ else {\r
+ if (len == 3 && (l == 0 || l == 1)) {\r
+ if (!( py_int = PyBool_FromLong(l))) goto finally;\r
+ }\r
+ else {\r
+ if (!( py_int = PyInt_FromLong(l))) goto finally;\r
+ }\r
+ }\r
+\r
+ free(s);\r
+ PDATA_PUSH(self->stack, py_int, -1);\r
+ return 0;\r
+\r
+ finally:\r
+ free(s);\r
+\r
+ return res;\r
+}\r
+\r
+static int\r
+load_bool(Unpicklerobject *self, PyObject *boolean)\r
+{\r
+ assert(boolean == Py_True || boolean == Py_False);\r
+ PDATA_APPEND(self->stack, boolean, -1);\r
+ return 0;\r
+}\r
+\r
+/* s contains x bytes of a little-endian integer. Return its value as a\r
+ * C int. Obscure: when x is 1 or 2, this is an unsigned little-endian\r
+ * int, but when x is 4 it's a signed one. This is an historical source\r
+ * of x-platform bugs.\r
+ */\r
+static long\r
+calc_binint(char *s, int x)\r
+{\r
+ unsigned char c;\r
+ int i;\r
+ long l;\r
+\r
+ for (i = 0, l = 0L; i < x; i++) {\r
+ c = (unsigned char)s[i];\r
+ l |= (long)c << (i * 8);\r
+ }\r
+#if SIZEOF_LONG > 4\r
+ /* Unlike BININT1 and BININT2, BININT (more accurately BININT4)\r
+ * is signed, so on a box with longs bigger than 4 bytes we need\r
+ * to extend a BININT's sign bit to the full width.\r
+ */\r
+ if (x == 4 && l & (1L << 31))\r
+ l |= (~0L) << 32;\r
+#endif\r
+ return l;\r
+}\r
+\r
+\r
+static int\r
+load_binintx(Unpicklerobject *self, char *s, int x)\r
+{\r
+ PyObject *py_int = 0;\r
+ long l;\r
+\r
+ l = calc_binint(s, x);\r
+\r
+ if (!( py_int = PyInt_FromLong(l)))\r
+ return -1;\r
+\r
+ PDATA_PUSH(self->stack, py_int, -1);\r
+ return 0;\r
+}\r
+\r
+\r
+static int\r
+load_binint(Unpicklerobject *self)\r
+{\r
+ char *s;\r
+\r
+ if (self->read_func(self, &s, 4) < 0)\r
+ return -1;\r
+\r
+ return load_binintx(self, s, 4);\r
+}\r
+\r
+\r
+static int\r
+load_binint1(Unpicklerobject *self)\r
+{\r
+ char *s;\r
+\r
+ if (self->read_func(self, &s, 1) < 0)\r
+ return -1;\r
+\r
+ return load_binintx(self, s, 1);\r
+}\r
+\r
+\r
+static int\r
+load_binint2(Unpicklerobject *self)\r
+{\r
+ char *s;\r
+\r
+ if (self->read_func(self, &s, 2) < 0)\r
+ return -1;\r
+\r
+ return load_binintx(self, s, 2);\r
+}\r
+\r
+static int\r
+load_long(Unpicklerobject *self)\r
+{\r
+ PyObject *l = 0;\r
+ char *end, *s;\r
+ Py_ssize_t len;\r
+ int res = -1;\r
+\r
+ if ((len = self->readline_func(self, &s)) < 0) return -1;\r
+ if (len < 2) return bad_readline();\r
+ if (!( s=pystrndup(s,len))) return -1;\r
+\r
+ if (!( l = PyLong_FromString(s, &end, 0)))\r
+ goto finally;\r
+\r
+ free(s);\r
+ PDATA_PUSH(self->stack, l, -1);\r
+ return 0;\r
+\r
+ finally:\r
+ free(s);\r
+\r
+ return res;\r
+}\r
+\r
+/* 'size' bytes contain the # of bytes of little-endian 256's-complement\r
+ * data following.\r
+ */\r
+static int\r
+load_counted_long(Unpicklerobject *self, int size)\r
+{\r
+ Py_ssize_t i;\r
+ char *nbytes;\r
+ unsigned char *pdata;\r
+ PyObject *along;\r
+\r
+ assert(size == 1 || size == 4);\r
+ i = self->read_func(self, &nbytes, size);\r
+ if (i < 0) return -1;\r
+\r
+ size = calc_binint(nbytes, size);\r
+ if (size < 0) {\r
+ /* Corrupt or hostile pickle -- we never write one like\r
+ * this.\r
+ */\r
+ PyErr_SetString(UnpicklingError, "LONG pickle has negative "\r
+ "byte count");\r
+ return -1;\r
+ }\r
+\r
+ if (size == 0)\r
+ along = PyLong_FromLong(0L);\r
+ else {\r
+ /* Read the raw little-endian bytes & convert. */\r
+ i = self->read_func(self, (char **)&pdata, size);\r
+ if (i < 0) return -1;\r
+ along = _PyLong_FromByteArray(pdata, (size_t)size,\r
+ 1 /* little endian */, 1 /* signed */);\r
+ }\r
+ if (along == NULL)\r
+ return -1;\r
+ PDATA_PUSH(self->stack, along, -1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+load_float(Unpicklerobject *self)\r
+{\r
+ PyObject *py_float = 0;\r
+ char *endptr, *s;\r
+ Py_ssize_t len;\r
+ int res = -1;\r
+ double d;\r
+\r
+ if ((len = self->readline_func(self, &s)) < 0) return -1;\r
+ if (len < 2) return bad_readline();\r
+ if (!( s=pystrndup(s,len))) return -1;\r
+\r
+ d = PyOS_string_to_double(s, &endptr, PyExc_OverflowError);\r
+\r
+ if (d == -1.0 && PyErr_Occurred()) {\r
+ goto finally;\r
+ } else if ((endptr[0] != '\n') || (endptr[1] != '\0')) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "could not convert string to float");\r
+ goto finally;\r
+ }\r
+\r
+ if (!( py_float = PyFloat_FromDouble(d)))\r
+ goto finally;\r
+\r
+ free(s);\r
+ PDATA_PUSH(self->stack, py_float, -1);\r
+ return 0;\r
+\r
+ finally:\r
+ free(s);\r
+\r
+ return res;\r
+}\r
+\r
+static int\r
+load_binfloat(Unpicklerobject *self)\r
+{\r
+ PyObject *py_float;\r
+ double x;\r
+ char *p;\r
+\r
+ if (self->read_func(self, &p, 8) < 0)\r
+ return -1;\r
+\r
+ x = _PyFloat_Unpack8((unsigned char *)p, 0);\r
+ if (x == -1.0 && PyErr_Occurred())\r
+ return -1;\r
+\r
+ py_float = PyFloat_FromDouble(x);\r
+ if (py_float == NULL)\r
+ return -1;\r
+\r
+ PDATA_PUSH(self->stack, py_float, -1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+load_string(Unpicklerobject *self)\r
+{\r
+ PyObject *str = 0;\r
+ Py_ssize_t len;\r
+ int res = -1;\r
+ char *s, *p;\r
+\r
+ if ((len = self->readline_func(self, &s)) < 0) return -1;\r
+ if (len < 2) return bad_readline();\r
+ if (!( s=pystrndup(s,len))) return -1;\r
+\r
+\r
+ /* Strip outermost quotes */\r
+ while (len > 0 && s[len-1] <= ' ')\r
+ len--;\r
+ if (len > 1 && s[0]=='"' && s[len-1]=='"') {\r
+ s[len-1] = '\0';\r
+ p = s + 1 ;\r
+ len -= 2;\r
+ }\r
+ else if (len > 1 && s[0]=='\'' && s[len-1]=='\'') {\r
+ s[len-1] = '\0';\r
+ p = s + 1 ;\r
+ len -= 2;\r
+ }\r
+ else\r
+ goto insecure;\r
+ /********************************************/\r
+\r
+ str = PyString_DecodeEscape(p, len, NULL, 0, NULL);\r
+ free(s);\r
+ if (str) {\r
+ PDATA_PUSH(self->stack, str, -1);\r
+ res = 0;\r
+ }\r
+ return res;\r
+\r
+ insecure:\r
+ free(s);\r
+ PyErr_SetString(PyExc_ValueError,"insecure string pickle");\r
+ return -1;\r
+}\r
+\r
+\r
+static int\r
+load_binstring(Unpicklerobject *self)\r
+{\r
+ PyObject *py_string = 0;\r
+ Py_ssize_t l;\r
+ char *s;\r
+\r
+ if (self->read_func(self, &s, 4) < 0) return -1;\r
+\r
+ l = calc_binint(s, 4);\r
+ if (l < 0) {\r
+ /* Corrupt or hostile pickle -- we never write one like\r
+ * this.\r
+ */\r
+ PyErr_SetString(UnpicklingError,\r
+ "BINSTRING pickle has negative byte count");\r
+ return -1;\r
+ }\r
+\r
+ if (self->read_func(self, &s, l) < 0)\r
+ return -1;\r
+\r
+ if (!( py_string = PyString_FromStringAndSize(s, l)))\r
+ return -1;\r
+\r
+ PDATA_PUSH(self->stack, py_string, -1);\r
+ return 0;\r
+}\r
+\r
+\r
+static int\r
+load_short_binstring(Unpicklerobject *self)\r
+{\r
+ PyObject *py_string = 0;\r
+ unsigned char l;\r
+ char *s;\r
+\r
+ if (self->read_func(self, &s, 1) < 0)\r
+ return -1;\r
+\r
+ l = (unsigned char)s[0];\r
+\r
+ if (self->read_func(self, &s, l) < 0) return -1;\r
+\r
+ if (!( py_string = PyString_FromStringAndSize(s, l))) return -1;\r
+\r
+ PDATA_PUSH(self->stack, py_string, -1);\r
+ return 0;\r
+}\r
+\r
+\r
+#ifdef Py_USING_UNICODE\r
+static int\r
+load_unicode(Unpicklerobject *self)\r
+{\r
+ PyObject *str = 0;\r
+ Py_ssize_t len;\r
+ char *s;\r
+\r
+ if ((len = self->readline_func(self, &s)) < 0) return -1;\r
+ if (len < 1) return bad_readline();\r
+\r
+ if (!( str = PyUnicode_DecodeRawUnicodeEscape(s, len - 1, NULL)))\r
+ return -1;\r
+\r
+ PDATA_PUSH(self->stack, str, -1);\r
+ return 0;\r
+}\r
+#endif\r
+\r
+\r
+#ifdef Py_USING_UNICODE\r
+static int\r
+load_binunicode(Unpicklerobject *self)\r
+{\r
+ PyObject *unicode;\r
+ Py_ssize_t l;\r
+ char *s;\r
+\r
+ if (self->read_func(self, &s, 4) < 0) return -1;\r
+\r
+ l = calc_binint(s, 4);\r
+ if (l < 0) {\r
+ /* Corrupt or hostile pickle -- we never write one like\r
+ * this.\r
+ */\r
+ PyErr_SetString(UnpicklingError,\r
+ "BINUNICODE pickle has negative byte count");\r
+ return -1;\r
+ }\r
+\r
+ if (self->read_func(self, &s, l) < 0)\r
+ return -1;\r
+\r
+ if (!( unicode = PyUnicode_DecodeUTF8(s, l, NULL)))\r
+ return -1;\r
+\r
+ PDATA_PUSH(self->stack, unicode, -1);\r
+ return 0;\r
+}\r
+#endif\r
+\r
+\r
+static int\r
+load_tuple(Unpicklerobject *self)\r
+{\r
+ PyObject *tup;\r
+ Py_ssize_t i;\r
+\r
+ if ((i = marker(self)) < 0) return -1;\r
+ if (!( tup=Pdata_popTuple(self->stack, i))) return -1;\r
+ PDATA_PUSH(self->stack, tup, -1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+load_counted_tuple(Unpicklerobject *self, int len)\r
+{\r
+ PyObject *tup = PyTuple_New(len);\r
+\r
+ if (tup == NULL)\r
+ return -1;\r
+\r
+ while (--len >= 0) {\r
+ PyObject *element;\r
+\r
+ PDATA_POP(self->stack, element);\r
+ if (element == NULL)\r
+ return -1;\r
+ PyTuple_SET_ITEM(tup, len, element);\r
+ }\r
+ PDATA_PUSH(self->stack, tup, -1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+load_empty_list(Unpicklerobject *self)\r
+{\r
+ PyObject *list;\r
+\r
+ if (!( list=PyList_New(0))) return -1;\r
+ PDATA_PUSH(self->stack, list, -1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+load_empty_dict(Unpicklerobject *self)\r
+{\r
+ PyObject *dict;\r
+\r
+ if (!( dict=PyDict_New())) return -1;\r
+ PDATA_PUSH(self->stack, dict, -1);\r
+ return 0;\r
+}\r
+\r
+\r
+static int\r
+load_list(Unpicklerobject *self)\r
+{\r
+ PyObject *list = 0;\r
+ Py_ssize_t i;\r
+\r
+ if ((i = marker(self)) < 0) return -1;\r
+ if (!( list=Pdata_popList(self->stack, i))) return -1;\r
+ PDATA_PUSH(self->stack, list, -1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+load_dict(Unpicklerobject *self)\r
+{\r
+ PyObject *dict, *key, *value;\r
+ Py_ssize_t i, j, k;\r
+\r
+ if ((i = marker(self)) < 0) return -1;\r
+ j=self->stack->length;\r
+\r
+ if (!( dict = PyDict_New())) return -1;\r
+\r
+ for (k = i+1; k < j; k += 2) {\r
+ key =self->stack->data[k-1];\r
+ value=self->stack->data[k ];\r
+ if (PyDict_SetItem(dict, key, value) < 0) {\r
+ Py_DECREF(dict);\r
+ return -1;\r
+ }\r
+ }\r
+ Pdata_clear(self->stack, i);\r
+ PDATA_PUSH(self->stack, dict, -1);\r
+ return 0;\r
+}\r
+\r
+static PyObject *\r
+Instance_New(PyObject *cls, PyObject *args)\r
+{\r
+ PyObject *r = 0;\r
+\r
+ if (PyClass_Check(cls)) {\r
+ int l;\r
+\r
+ if ((l=PyObject_Size(args)) < 0) goto err;\r
+ if (!( l )) {\r
+ PyObject *__getinitargs__;\r
+\r
+ __getinitargs__ = PyObject_GetAttr(cls,\r
+ __getinitargs___str);\r
+ if (!__getinitargs__) {\r
+ /* We have a class with no __getinitargs__,\r
+ so bypass usual construction */\r
+ PyObject *inst;\r
+\r
+ PyErr_Clear();\r
+ if (!( inst=PyInstance_NewRaw(cls, NULL)))\r
+ goto err;\r
+ return inst;\r
+ }\r
+ Py_DECREF(__getinitargs__);\r
+ }\r
+\r
+ if ((r=PyInstance_New(cls, args, NULL))) return r;\r
+ else goto err;\r
+ }\r
+\r
+ if ((r=PyObject_CallObject(cls, args))) return r;\r
+\r
+ err:\r
+ {\r
+ PyObject *tp, *v, *tb, *tmp_value;\r
+\r
+ PyErr_Fetch(&tp, &v, &tb);\r
+ tmp_value = v;\r
+ /* NULL occurs when there was a KeyboardInterrupt */\r
+ if (tmp_value == NULL)\r
+ tmp_value = Py_None;\r
+ if ((r = PyTuple_Pack(3, tmp_value, cls, args))) {\r
+ Py_XDECREF(v);\r
+ v=r;\r
+ }\r
+ PyErr_Restore(tp,v,tb);\r
+ }\r
+ return NULL;\r
+}\r
+\r
+\r
+static int\r
+load_obj(Unpicklerobject *self)\r
+{\r
+ PyObject *class, *tup, *obj=0;\r
+ Py_ssize_t i;\r
+\r
+ if ((i = marker(self)) < 0) return -1;\r
+ if (!( tup=Pdata_popTuple(self->stack, i+1))) return -1;\r
+ PDATA_POP(self->stack, class);\r
+ if (class) {\r
+ obj = Instance_New(class, tup);\r
+ Py_DECREF(class);\r
+ }\r
+ Py_DECREF(tup);\r
+\r
+ if (! obj) return -1;\r
+ PDATA_PUSH(self->stack, obj, -1);\r
+ return 0;\r
+}\r
+\r
+\r
+static int\r
+load_inst(Unpicklerobject *self)\r
+{\r
+ PyObject *tup, *class=0, *obj=0, *module_name, *class_name;\r
+ Py_ssize_t i, len;\r
+ char *s;\r
+\r
+ if ((i = marker(self)) < 0) return -1;\r
+\r
+ if ((len = self->readline_func(self, &s)) < 0) return -1;\r
+ if (len < 2) return bad_readline();\r
+ module_name = PyString_FromStringAndSize(s, len - 1);\r
+ if (!module_name) return -1;\r
+\r
+ if ((len = self->readline_func(self, &s)) >= 0) {\r
+ if (len < 2) return bad_readline();\r
+ if ((class_name = PyString_FromStringAndSize(s, len - 1))) {\r
+ class = find_class(module_name, class_name,\r
+ self->find_class);\r
+ Py_DECREF(class_name);\r
+ }\r
+ }\r
+ Py_DECREF(module_name);\r
+\r
+ if (! class) return -1;\r
+\r
+ if ((tup=Pdata_popTuple(self->stack, i))) {\r
+ obj = Instance_New(class, tup);\r
+ Py_DECREF(tup);\r
+ }\r
+ Py_DECREF(class);\r
+\r
+ if (! obj) return -1;\r
+\r
+ PDATA_PUSH(self->stack, obj, -1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+load_newobj(Unpicklerobject *self)\r
+{\r
+ PyObject *args = NULL;\r
+ PyObject *clsraw = NULL;\r
+ PyTypeObject *cls; /* clsraw cast to its true type */\r
+ PyObject *obj;\r
+\r
+ /* Stack is ... cls argtuple, and we want to call\r
+ * cls.__new__(cls, *argtuple).\r
+ */\r
+ PDATA_POP(self->stack, args);\r
+ if (args == NULL) goto Fail;\r
+ if (! PyTuple_Check(args)) {\r
+ PyErr_SetString(UnpicklingError, "NEWOBJ expected an arg "\r
+ "tuple.");\r
+ goto Fail;\r
+ }\r
+\r
+ PDATA_POP(self->stack, clsraw);\r
+ cls = (PyTypeObject *)clsraw;\r
+ if (cls == NULL) goto Fail;\r
+ if (! PyType_Check(cls)) {\r
+ PyErr_SetString(UnpicklingError, "NEWOBJ class argument "\r
+ "isn't a type object");\r
+ goto Fail;\r
+ }\r
+ if (cls->tp_new == NULL) {\r
+ PyErr_SetString(UnpicklingError, "NEWOBJ class argument "\r
+ "has NULL tp_new");\r
+ goto Fail;\r
+ }\r
+\r
+ /* Call __new__. */\r
+ obj = cls->tp_new(cls, args, NULL);\r
+ if (obj == NULL) goto Fail;\r
+\r
+ Py_DECREF(args);\r
+ Py_DECREF(clsraw);\r
+ PDATA_PUSH(self->stack, obj, -1);\r
+ return 0;\r
+\r
+ Fail:\r
+ Py_XDECREF(args);\r
+ Py_XDECREF(clsraw);\r
+ return -1;\r
+}\r
+\r
+static int\r
+load_global(Unpicklerobject *self)\r
+{\r
+ PyObject *class = 0, *module_name = 0, *class_name = 0;\r
+ Py_ssize_t len;\r
+ char *s;\r
+\r
+ if ((len = self->readline_func(self, &s)) < 0) return -1;\r
+ if (len < 2) return bad_readline();\r
+ module_name = PyString_FromStringAndSize(s, len - 1);\r
+ if (!module_name) return -1;\r
+\r
+ if ((len = self->readline_func(self, &s)) >= 0) {\r
+ if (len < 2) {\r
+ Py_DECREF(module_name);\r
+ return bad_readline();\r
+ }\r
+ if ((class_name = PyString_FromStringAndSize(s, len - 1))) {\r
+ class = find_class(module_name, class_name,\r
+ self->find_class);\r
+ Py_DECREF(class_name);\r
+ }\r
+ }\r
+ Py_DECREF(module_name);\r
+\r
+ if (! class) return -1;\r
+ PDATA_PUSH(self->stack, class, -1);\r
+ return 0;\r
+}\r
+\r
+\r
+static int\r
+load_persid(Unpicklerobject *self)\r
+{\r
+ PyObject *pid = 0;\r
+ Py_ssize_t len;\r
+ char *s;\r
+\r
+ if (self->pers_func) {\r
+ if ((len = self->readline_func(self, &s)) < 0) return -1;\r
+ if (len < 2) return bad_readline();\r
+\r
+ pid = PyString_FromStringAndSize(s, len - 1);\r
+ if (!pid) return -1;\r
+\r
+ if (PyList_Check(self->pers_func)) {\r
+ if (PyList_Append(self->pers_func, pid) < 0) {\r
+ Py_DECREF(pid);\r
+ return -1;\r
+ }\r
+ }\r
+ else {\r
+ ARG_TUP(self, pid);\r
+ if (self->arg) {\r
+ pid = PyObject_Call(self->pers_func, self->arg,\r
+ NULL);\r
+ FREE_ARG_TUP(self);\r
+ }\r
+ }\r
+\r
+ if (! pid) return -1;\r
+\r
+ PDATA_PUSH(self->stack, pid, -1);\r
+ return 0;\r
+ }\r
+ else {\r
+ PyErr_SetString(UnpicklingError,\r
+ "A load persistent id instruction was encountered,\n"\r
+ "but no persistent_load function was specified.");\r
+ return -1;\r
+ }\r
+}\r
+\r
+static int\r
+load_binpersid(Unpicklerobject *self)\r
+{\r
+ PyObject *pid = 0;\r
+\r
+ if (self->pers_func) {\r
+ PDATA_POP(self->stack, pid);\r
+ if (! pid) return -1;\r
+\r
+ if (PyList_Check(self->pers_func)) {\r
+ if (PyList_Append(self->pers_func, pid) < 0) {\r
+ Py_DECREF(pid);\r
+ return -1;\r
+ }\r
+ }\r
+ else {\r
+ ARG_TUP(self, pid);\r
+ if (self->arg) {\r
+ pid = PyObject_Call(self->pers_func, self->arg,\r
+ NULL);\r
+ FREE_ARG_TUP(self);\r
+ }\r
+ if (! pid) return -1;\r
+ }\r
+\r
+ PDATA_PUSH(self->stack, pid, -1);\r
+ return 0;\r
+ }\r
+ else {\r
+ PyErr_SetString(UnpicklingError,\r
+ "A load persistent id instruction was encountered,\n"\r
+ "but no persistent_load function was specified.");\r
+ return -1;\r
+ }\r
+}\r
+\r
+\r
+static int\r
+load_pop(Unpicklerobject *self)\r
+{\r
+ Py_ssize_t len = self->stack->length;\r
+\r
+ /* Note that we split the (pickle.py) stack into two stacks,\r
+ an object stack and a mark stack. We have to be clever and\r
+ pop the right one. We do this by looking at the top of the\r
+ mark stack first, and only signalling a stack underflow if\r
+ the object stack is empty and the mark stack doesn't match\r
+ our expectations.\r
+ */\r
+ if (self->num_marks > 0 && self->marks[self->num_marks - 1] == len) {\r
+ self->num_marks--;\r
+ } else if (len > 0) {\r
+ len--;\r
+ Py_DECREF(self->stack->data[len]);\r
+ self->stack->length = len;\r
+ } else {\r
+ return stackUnderflow();\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+static int\r
+load_pop_mark(Unpicklerobject *self)\r
+{\r
+ Py_ssize_t i;\r
+\r
+ if ((i = marker(self)) < 0)\r
+ return -1;\r
+\r
+ Pdata_clear(self->stack, i);\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+static int\r
+load_dup(Unpicklerobject *self)\r
+{\r
+ PyObject *last;\r
+ Py_ssize_t len;\r
+\r
+ if ((len = self->stack->length) <= 0) return stackUnderflow();\r
+ last=self->stack->data[len-1];\r
+ Py_INCREF(last);\r
+ PDATA_PUSH(self->stack, last, -1);\r
+ return 0;\r
+}\r
+\r
+\r
+static int\r
+load_get(Unpicklerobject *self)\r
+{\r
+ PyObject *py_str = 0, *value = 0;\r
+ Py_ssize_t len;\r
+ char *s;\r
+ int rc;\r
+\r
+ if ((len = self->readline_func(self, &s)) < 0) return -1;\r
+ if (len < 2) return bad_readline();\r
+\r
+ if (!( py_str = PyString_FromStringAndSize(s, len - 1))) return -1;\r
+\r
+ value = PyDict_GetItem(self->memo, py_str);\r
+ if (! value) {\r
+ PyErr_SetObject(BadPickleGet, py_str);\r
+ rc = -1;\r
+ }\r
+ else {\r
+ PDATA_APPEND(self->stack, value, -1);\r
+ rc = 0;\r
+ }\r
+\r
+ Py_DECREF(py_str);\r
+ return rc;\r
+}\r
+\r
+\r
+static int\r
+load_binget(Unpicklerobject *self)\r
+{\r
+ PyObject *py_key = 0, *value = 0;\r
+ unsigned char key;\r
+ char *s;\r
+ int rc;\r
+\r
+ if (self->read_func(self, &s, 1) < 0) return -1;\r
+\r
+ key = (unsigned char)s[0];\r
+ if (!( py_key = PyInt_FromLong((long)key))) return -1;\r
+\r
+ value = PyDict_GetItem(self->memo, py_key);\r
+ if (! value) {\r
+ PyErr_SetObject(BadPickleGet, py_key);\r
+ rc = -1;\r
+ }\r
+ else {\r
+ PDATA_APPEND(self->stack, value, -1);\r
+ rc = 0;\r
+ }\r
+\r
+ Py_DECREF(py_key);\r
+ return rc;\r
+}\r
+\r
+\r
+static int\r
+load_long_binget(Unpicklerobject *self)\r
+{\r
+ PyObject *py_key = 0, *value = 0;\r
+ unsigned char c;\r
+ char *s;\r
+ Py_ssize_t key;\r
+ int rc;\r
+\r
+ if (self->read_func(self, &s, 4) < 0) return -1;\r
+\r
+ c = (unsigned char)s[0];\r
+ key = (long)c;\r
+ c = (unsigned char)s[1];\r
+ key |= (long)c << 8;\r
+ c = (unsigned char)s[2];\r
+ key |= (long)c << 16;\r
+ c = (unsigned char)s[3];\r
+ key |= (long)c << 24;\r
+\r
+ if (!( py_key = PyInt_FromLong((long)key))) return -1;\r
+\r
+ value = PyDict_GetItem(self->memo, py_key);\r
+ if (! value) {\r
+ PyErr_SetObject(BadPickleGet, py_key);\r
+ rc = -1;\r
+ }\r
+ else {\r
+ PDATA_APPEND(self->stack, value, -1);\r
+ rc = 0;\r
+ }\r
+\r
+ Py_DECREF(py_key);\r
+ return rc;\r
+}\r
+\r
+/* Push an object from the extension registry (EXT[124]). nbytes is\r
+ * the number of bytes following the opcode, holding the index (code) value.\r
+ */\r
+static int\r
+load_extension(Unpicklerobject *self, int nbytes)\r
+{\r
+ char *codebytes; /* the nbytes bytes after the opcode */\r
+ long code; /* calc_binint returns long */\r
+ PyObject *py_code; /* code as a Python int */\r
+ PyObject *obj; /* the object to push */\r
+ PyObject *pair; /* (module_name, class_name) */\r
+ PyObject *module_name, *class_name;\r
+\r
+ assert(nbytes == 1 || nbytes == 2 || nbytes == 4);\r
+ if (self->read_func(self, &codebytes, nbytes) < 0) return -1;\r
+ code = calc_binint(codebytes, nbytes);\r
+ if (code <= 0) { /* note that 0 is forbidden */\r
+ /* Corrupt or hostile pickle. */\r
+ PyErr_SetString(UnpicklingError, "EXT specifies code <= 0");\r
+ return -1;\r
+ }\r
+\r
+ /* Look for the code in the cache. */\r
+ py_code = PyInt_FromLong(code);\r
+ if (py_code == NULL) return -1;\r
+ obj = PyDict_GetItem(extension_cache, py_code);\r
+ if (obj != NULL) {\r
+ /* Bingo. */\r
+ Py_DECREF(py_code);\r
+ PDATA_APPEND(self->stack, obj, -1);\r
+ return 0;\r
+ }\r
+\r
+ /* Look up the (module_name, class_name) pair. */\r
+ pair = PyDict_GetItem(inverted_registry, py_code);\r
+ if (pair == NULL) {\r
+ Py_DECREF(py_code);\r
+ PyErr_Format(PyExc_ValueError, "unregistered extension "\r
+ "code %ld", code);\r
+ return -1;\r
+ }\r
+ /* Since the extension registry is manipulable via Python code,\r
+ * confirm that pair is really a 2-tuple of strings.\r
+ */\r
+ if (!PyTuple_Check(pair) || PyTuple_Size(pair) != 2 ||\r
+ !PyString_Check(module_name = PyTuple_GET_ITEM(pair, 0)) ||\r
+ !PyString_Check(class_name = PyTuple_GET_ITEM(pair, 1))) {\r
+ Py_DECREF(py_code);\r
+ PyErr_Format(PyExc_ValueError, "_inverted_registry[%ld] "\r
+ "isn't a 2-tuple of strings", code);\r
+ return -1;\r
+ }\r
+ /* Load the object. */\r
+ obj = find_class(module_name, class_name, self->find_class);\r
+ if (obj == NULL) {\r
+ Py_DECREF(py_code);\r
+ return -1;\r
+ }\r
+ /* Cache code -> obj. */\r
+ code = PyDict_SetItem(extension_cache, py_code, obj);\r
+ Py_DECREF(py_code);\r
+ if (code < 0) {\r
+ Py_DECREF(obj);\r
+ return -1;\r
+ }\r
+ PDATA_PUSH(self->stack, obj, -1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+load_put(Unpicklerobject *self)\r
+{\r
+ PyObject *py_str = 0, *value = 0;\r
+ Py_ssize_t len, l;\r
+ char *s;\r
+\r
+ if ((l = self->readline_func(self, &s)) < 0) return -1;\r
+ if (l < 2) return bad_readline();\r
+ if (!( len=self->stack->length )) return stackUnderflow();\r
+ if (!( py_str = PyString_FromStringAndSize(s, l - 1))) return -1;\r
+ value=self->stack->data[len-1];\r
+ l=PyDict_SetItem(self->memo, py_str, value);\r
+ Py_DECREF(py_str);\r
+ return l;\r
+}\r
+\r
+\r
+static int\r
+load_binput(Unpicklerobject *self)\r
+{\r
+ PyObject *py_key = 0, *value = 0;\r
+ unsigned char key;\r
+ char *s;\r
+ Py_ssize_t len;\r
+\r
+ if (self->read_func(self, &s, 1) < 0) return -1;\r
+ if (!( (len=self->stack->length) > 0 )) return stackUnderflow();\r
+\r
+ key = (unsigned char)s[0];\r
+\r
+ if (!( py_key = PyInt_FromLong((long)key))) return -1;\r
+ value=self->stack->data[len-1];\r
+ len=PyDict_SetItem(self->memo, py_key, value);\r
+ Py_DECREF(py_key);\r
+ return len;\r
+}\r
+\r
+\r
+static int\r
+load_long_binput(Unpicklerobject *self)\r
+{\r
+ PyObject *py_key = 0, *value = 0;\r
+ Py_ssize_t key;\r
+ unsigned char c;\r
+ char *s;\r
+ Py_ssize_t len;\r
+\r
+ if (self->read_func(self, &s, 4) < 0) return -1;\r
+ if (!( len=self->stack->length )) return stackUnderflow();\r
+\r
+ c = (unsigned char)s[0];\r
+ key = (long)c;\r
+ c = (unsigned char)s[1];\r
+ key |= (long)c << 8;\r
+ c = (unsigned char)s[2];\r
+ key |= (long)c << 16;\r
+ c = (unsigned char)s[3];\r
+ key |= (long)c << 24;\r
+\r
+ if (!( py_key = PyInt_FromLong(key))) return -1;\r
+ value=self->stack->data[len-1];\r
+ len=PyDict_SetItem(self->memo, py_key, value);\r
+ Py_DECREF(py_key);\r
+ return len;\r
+}\r
+\r
+\r
+static int\r
+do_append(Unpicklerobject *self, Py_ssize_t x)\r
+{\r
+ PyObject *value = 0, *list = 0, *append_method = 0;\r
+ Py_ssize_t len, i;\r
+\r
+ len=self->stack->length;\r
+ if (!( len >= x && x > 0 )) return stackUnderflow();\r
+ /* nothing to do */\r
+ if (len==x) return 0;\r
+\r
+ list=self->stack->data[x-1];\r
+\r
+ if (PyList_Check(list)) {\r
+ PyObject *slice;\r
+ int list_len;\r
+\r
+ slice=Pdata_popList(self->stack, x);\r
+ if (! slice) return -1;\r
+ list_len = PyList_GET_SIZE(list);\r
+ i=PyList_SetSlice(list, list_len, list_len, slice);\r
+ Py_DECREF(slice);\r
+ return i;\r
+ }\r
+ else {\r
+\r
+ if (!( append_method = PyObject_GetAttr(list, append_str)))\r
+ return -1;\r
+\r
+ for (i = x; i < len; i++) {\r
+ PyObject *junk;\r
+\r
+ value=self->stack->data[i];\r
+ junk=0;\r
+ ARG_TUP(self, value);\r
+ if (self->arg) {\r
+ junk = PyObject_Call(append_method, self->arg,\r
+ NULL);\r
+ FREE_ARG_TUP(self);\r
+ }\r
+ if (! junk) {\r
+ Pdata_clear(self->stack, i+1);\r
+ self->stack->length=x;\r
+ Py_DECREF(append_method);\r
+ return -1;\r
+ }\r
+ Py_DECREF(junk);\r
+ }\r
+ self->stack->length=x;\r
+ Py_DECREF(append_method);\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+static int\r
+load_append(Unpicklerobject *self)\r
+{\r
+ return do_append(self, self->stack->length - 1);\r
+}\r
+\r
+\r
+static int\r
+load_appends(Unpicklerobject *self)\r
+{\r
+ return do_append(self, marker(self));\r
+}\r
+\r
+\r
+static Py_ssize_t\r
+do_setitems(Unpicklerobject *self, Py_ssize_t x)\r
+{\r
+ PyObject *value = 0, *key = 0, *dict = 0;\r
+ Py_ssize_t len, i, r=0;\r
+\r
+ if (!( (len=self->stack->length) >= x\r
+ && x > 0 )) return stackUnderflow();\r
+\r
+ dict=self->stack->data[x-1];\r
+\r
+ for (i = x+1; i < len; i += 2) {\r
+ key =self->stack->data[i-1];\r
+ value=self->stack->data[i ];\r
+ if (PyObject_SetItem(dict, key, value) < 0) {\r
+ r=-1;\r
+ break;\r
+ }\r
+ }\r
+\r
+ Pdata_clear(self->stack, x);\r
+\r
+ return r;\r
+}\r
+\r
+\r
+static int\r
+load_setitem(Unpicklerobject *self)\r
+{\r
+ return do_setitems(self, self->stack->length - 2);\r
+}\r
+\r
+static int\r
+load_setitems(Unpicklerobject *self)\r
+{\r
+ return do_setitems(self, marker(self));\r
+}\r
+\r
+\r
+static int\r
+load_build(Unpicklerobject *self)\r
+{\r
+ PyObject *state, *inst, *slotstate;\r
+ PyObject *__setstate__;\r
+ PyObject *d_key, *d_value;\r
+ int res = -1;\r
+ Py_ssize_t i;\r
+\r
+ /* Stack is ... instance, state. We want to leave instance at\r
+ * the stack top, possibly mutated via instance.__setstate__(state).\r
+ */\r
+ if (self->stack->length < 2)\r
+ return stackUnderflow();\r
+ PDATA_POP(self->stack, state);\r
+ if (state == NULL)\r
+ return -1;\r
+ inst = self->stack->data[self->stack->length - 1];\r
+\r
+ __setstate__ = PyObject_GetAttr(inst, __setstate___str);\r
+ if (__setstate__ != NULL) {\r
+ PyObject *junk = NULL;\r
+\r
+ /* The explicit __setstate__ is responsible for everything. */\r
+ ARG_TUP(self, state);\r
+ if (self->arg) {\r
+ junk = PyObject_Call(__setstate__, self->arg, NULL);\r
+ FREE_ARG_TUP(self);\r
+ }\r
+ Py_DECREF(__setstate__);\r
+ if (junk == NULL)\r
+ return -1;\r
+ Py_DECREF(junk);\r
+ return 0;\r
+ }\r
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))\r
+ return -1;\r
+ PyErr_Clear();\r
+\r
+ /* A default __setstate__. First see whether state embeds a\r
+ * slot state dict too (a proto 2 addition).\r
+ */\r
+ if (PyTuple_Check(state) && PyTuple_Size(state) == 2) {\r
+ PyObject *temp = state;\r
+ state = PyTuple_GET_ITEM(temp, 0);\r
+ slotstate = PyTuple_GET_ITEM(temp, 1);\r
+ Py_INCREF(state);\r
+ Py_INCREF(slotstate);\r
+ Py_DECREF(temp);\r
+ }\r
+ else\r
+ slotstate = NULL;\r
+\r
+ /* Set inst.__dict__ from the state dict (if any). */\r
+ if (state != Py_None) {\r
+ PyObject *dict;\r
+ if (! PyDict_Check(state)) {\r
+ PyErr_SetString(UnpicklingError, "state is not a "\r
+ "dictionary");\r
+ goto finally;\r
+ }\r
+ dict = PyObject_GetAttr(inst, __dict___str);\r
+ if (dict == NULL)\r
+ goto finally;\r
+\r
+ i = 0;\r
+ while (PyDict_Next(state, &i, &d_key, &d_value)) {\r
+ /* normally the keys for instance attributes are\r
+ interned. we should try to do that here. */\r
+ Py_INCREF(d_key);\r
+ if (PyString_CheckExact(d_key))\r
+ PyString_InternInPlace(&d_key);\r
+ if (PyObject_SetItem(dict, d_key, d_value) < 0) {\r
+ Py_DECREF(d_key);\r
+ goto finally;\r
+ }\r
+ Py_DECREF(d_key);\r
+ }\r
+ Py_DECREF(dict);\r
+ }\r
+\r
+ /* Also set instance attributes from the slotstate dict (if any). */\r
+ if (slotstate != NULL) {\r
+ if (! PyDict_Check(slotstate)) {\r
+ PyErr_SetString(UnpicklingError, "slot state is not "\r
+ "a dictionary");\r
+ goto finally;\r
+ }\r
+ i = 0;\r
+ while (PyDict_Next(slotstate, &i, &d_key, &d_value)) {\r
+ if (PyObject_SetAttr(inst, d_key, d_value) < 0)\r
+ goto finally;\r
+ }\r
+ }\r
+ res = 0;\r
+\r
+ finally:\r
+ Py_DECREF(state);\r
+ Py_XDECREF(slotstate);\r
+ return res;\r
+}\r
+\r
+\r
+static int\r
+load_mark(Unpicklerobject *self)\r
+{\r
+ Py_ssize_t s;\r
+\r
+ /* Note that we split the (pickle.py) stack into two stacks, an\r
+ object stack and a mark stack. Here we push a mark onto the\r
+ mark stack.\r
+ */\r
+\r
+ if ((self->num_marks + 1) >= self->marks_size) {\r
+ Py_ssize_t *marks;\r
+ s=self->marks_size+20;\r
+ if (s <= self->num_marks) s=self->num_marks + 1;\r
+ if (self->marks == NULL)\r
+ marks=(Py_ssize_t *)malloc(s * sizeof(Py_ssize_t));\r
+ else\r
+ marks=(Py_ssize_t *)realloc(self->marks,\r
+ s * sizeof(Py_ssize_t));\r
+ if (!marks) {\r
+ PyErr_NoMemory();\r
+ return -1;\r
+ }\r
+ self->marks = marks;\r
+ self->marks_size = s;\r
+ }\r
+\r
+ self->marks[self->num_marks++] = self->stack->length;\r
+\r
+ return 0;\r
+}\r
+\r
+static int\r
+load_reduce(Unpicklerobject *self)\r
+{\r
+ PyObject *callable = 0, *arg_tup = 0, *ob = 0;\r
+\r
+ PDATA_POP(self->stack, arg_tup);\r
+ if (! arg_tup) return -1;\r
+ PDATA_POP(self->stack, callable);\r
+ if (callable) {\r
+ ob = Instance_New(callable, arg_tup);\r
+ Py_DECREF(callable);\r
+ }\r
+ Py_DECREF(arg_tup);\r
+\r
+ if (! ob) return -1;\r
+\r
+ PDATA_PUSH(self->stack, ob, -1);\r
+ return 0;\r
+}\r
+\r
+/* Just raises an error if we don't know the protocol specified. PROTO\r
+ * is the first opcode for protocols >= 2.\r
+ */\r
+static int\r
+load_proto(Unpicklerobject *self)\r
+{\r
+ int i;\r
+ char *protobyte;\r
+\r
+ i = self->read_func(self, &protobyte, 1);\r
+ if (i < 0)\r
+ return -1;\r
+\r
+ i = calc_binint(protobyte, 1);\r
+ /* No point checking for < 0, since calc_binint returns an unsigned\r
+ * int when chewing on 1 byte.\r
+ */\r
+ assert(i >= 0);\r
+ if (i <= HIGHEST_PROTOCOL)\r
+ return 0;\r
+\r
+ PyErr_Format(PyExc_ValueError, "unsupported pickle protocol: %d", i);\r
+ return -1;\r
+}\r
+\r
+static PyObject *\r
+load(Unpicklerobject *self)\r
+{\r
+ PyObject *err = 0, *val = 0;\r
+ char *s;\r
+\r
+ self->num_marks = 0;\r
+ if (self->stack->length) Pdata_clear(self->stack, 0);\r
+\r
+ while (1) {\r
+ if (self->read_func(self, &s, 1) < 0)\r
+ break;\r
+\r
+ switch (s[0]) {\r
+ case NONE:\r
+ if (load_none(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BININT:\r
+ if (load_binint(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BININT1:\r
+ if (load_binint1(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BININT2:\r
+ if (load_binint2(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case INT:\r
+ if (load_int(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case LONG:\r
+ if (load_long(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case LONG1:\r
+ if (load_counted_long(self, 1) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case LONG4:\r
+ if (load_counted_long(self, 4) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case FLOAT:\r
+ if (load_float(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BINFLOAT:\r
+ if (load_binfloat(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BINSTRING:\r
+ if (load_binstring(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case SHORT_BINSTRING:\r
+ if (load_short_binstring(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case STRING:\r
+ if (load_string(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+#ifdef Py_USING_UNICODE\r
+ case UNICODE:\r
+ if (load_unicode(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BINUNICODE:\r
+ if (load_binunicode(self) < 0)\r
+ break;\r
+ continue;\r
+#endif\r
+\r
+ case EMPTY_TUPLE:\r
+ if (load_counted_tuple(self, 0) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case TUPLE1:\r
+ if (load_counted_tuple(self, 1) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case TUPLE2:\r
+ if (load_counted_tuple(self, 2) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case TUPLE3:\r
+ if (load_counted_tuple(self, 3) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case TUPLE:\r
+ if (load_tuple(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case EMPTY_LIST:\r
+ if (load_empty_list(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case LIST:\r
+ if (load_list(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case EMPTY_DICT:\r
+ if (load_empty_dict(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case DICT:\r
+ if (load_dict(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case OBJ:\r
+ if (load_obj(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case INST:\r
+ if (load_inst(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case NEWOBJ:\r
+ if (load_newobj(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case GLOBAL:\r
+ if (load_global(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case APPEND:\r
+ if (load_append(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case APPENDS:\r
+ if (load_appends(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BUILD:\r
+ if (load_build(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case DUP:\r
+ if (load_dup(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BINGET:\r
+ if (load_binget(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case LONG_BINGET:\r
+ if (load_long_binget(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case GET:\r
+ if (load_get(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case EXT1:\r
+ if (load_extension(self, 1) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case EXT2:\r
+ if (load_extension(self, 2) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case EXT4:\r
+ if (load_extension(self, 4) < 0)\r
+ break;\r
+ continue;\r
+ case MARK:\r
+ if (load_mark(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BINPUT:\r
+ if (load_binput(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case LONG_BINPUT:\r
+ if (load_long_binput(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case PUT:\r
+ if (load_put(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case POP:\r
+ if (load_pop(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case POP_MARK:\r
+ if (load_pop_mark(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case SETITEM:\r
+ if (load_setitem(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case SETITEMS:\r
+ if (load_setitems(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case STOP:\r
+ break;\r
+\r
+ case PERSID:\r
+ if (load_persid(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BINPERSID:\r
+ if (load_binpersid(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case REDUCE:\r
+ if (load_reduce(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case PROTO:\r
+ if (load_proto(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case NEWTRUE:\r
+ if (load_bool(self, Py_True) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case NEWFALSE:\r
+ if (load_bool(self, Py_False) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case '\0':\r
+ /* end of file */\r
+ PyErr_SetNone(PyExc_EOFError);\r
+ break;\r
+\r
+ default:\r
+ cPickle_ErrFormat(UnpicklingError,\r
+ "invalid load key, '%s'.",\r
+ "c", s[0]);\r
+ return NULL;\r
+ }\r
+\r
+ break;\r
+ }\r
+\r
+ if ((err = PyErr_Occurred())) {\r
+ if (err == PyExc_EOFError) {\r
+ PyErr_SetNone(PyExc_EOFError);\r
+ }\r
+ return NULL;\r
+ }\r
+\r
+ PDATA_POP(self->stack, val);\r
+ return val;\r
+}\r
+\r
+\r
+/* No-load functions to support noload, which is used to\r
+ find persistent references. */\r
+\r
+static int\r
+noload_obj(Unpicklerobject *self)\r
+{\r
+ Py_ssize_t i;\r
+\r
+ if ((i = marker(self)) < 0) return -1;\r
+ return Pdata_clear(self->stack, i+1);\r
+}\r
+\r
+\r
+static int\r
+noload_inst(Unpicklerobject *self)\r
+{\r
+ Py_ssize_t i;\r
+ char *s;\r
+\r
+ if ((i = marker(self)) < 0) return -1;\r
+ Pdata_clear(self->stack, i);\r
+ if (self->readline_func(self, &s) < 0) return -1;\r
+ if (self->readline_func(self, &s) < 0) return -1;\r
+ PDATA_APPEND(self->stack, Py_None, -1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+noload_newobj(Unpicklerobject *self)\r
+{\r
+ PyObject *obj;\r
+\r
+ PDATA_POP(self->stack, obj); /* pop argtuple */\r
+ if (obj == NULL) return -1;\r
+ Py_DECREF(obj);\r
+\r
+ PDATA_POP(self->stack, obj); /* pop cls */\r
+ if (obj == NULL) return -1;\r
+ Py_DECREF(obj);\r
+\r
+ PDATA_APPEND(self->stack, Py_None, -1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+noload_global(Unpicklerobject *self)\r
+{\r
+ char *s;\r
+\r
+ if (self->readline_func(self, &s) < 0) return -1;\r
+ if (self->readline_func(self, &s) < 0) return -1;\r
+ PDATA_APPEND(self->stack, Py_None,-1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+noload_reduce(Unpicklerobject *self)\r
+{\r
+\r
+ if (self->stack->length < 2) return stackUnderflow();\r
+ Pdata_clear(self->stack, self->stack->length-2);\r
+ PDATA_APPEND(self->stack, Py_None,-1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+noload_build(Unpicklerobject *self) {\r
+\r
+ if (self->stack->length < 1) return stackUnderflow();\r
+ Pdata_clear(self->stack, self->stack->length-1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+noload_extension(Unpicklerobject *self, int nbytes)\r
+{\r
+ char *codebytes;\r
+\r
+ assert(nbytes == 1 || nbytes == 2 || nbytes == 4);\r
+ if (self->read_func(self, &codebytes, nbytes) < 0) return -1;\r
+ PDATA_APPEND(self->stack, Py_None, -1);\r
+ return 0;\r
+}\r
+\r
+static int\r
+noload_append(Unpicklerobject *self)\r
+{\r
+ return Pdata_clear(self->stack, self->stack->length - 1);\r
+}\r
+\r
+static int\r
+noload_appends(Unpicklerobject *self)\r
+{\r
+ Py_ssize_t i;\r
+ if ((i = marker(self)) < 0) return -1;\r
+ return Pdata_clear(self->stack, i);\r
+}\r
+\r
+static int\r
+noload_setitem(Unpicklerobject *self)\r
+{\r
+ return Pdata_clear(self->stack, self->stack->length - 2);\r
+}\r
+\r
+static int\r
+noload_setitems(Unpicklerobject *self)\r
+{\r
+ Py_ssize_t i;\r
+ if ((i = marker(self)) < 0) return -1;\r
+ return Pdata_clear(self->stack, i);\r
+}\r
+\r
+static PyObject *\r
+noload(Unpicklerobject *self)\r
+{\r
+ PyObject *err = 0, *val = 0;\r
+ char *s;\r
+\r
+ self->num_marks = 0;\r
+ Pdata_clear(self->stack, 0);\r
+\r
+ while (1) {\r
+ if (self->read_func(self, &s, 1) < 0)\r
+ break;\r
+\r
+ switch (s[0]) {\r
+ case NONE:\r
+ if (load_none(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BININT:\r
+ if (load_binint(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BININT1:\r
+ if (load_binint1(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BININT2:\r
+ if (load_binint2(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case INT:\r
+ if (load_int(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case LONG:\r
+ if (load_long(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case LONG1:\r
+ if (load_counted_long(self, 1) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case LONG4:\r
+ if (load_counted_long(self, 4) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case FLOAT:\r
+ if (load_float(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BINFLOAT:\r
+ if (load_binfloat(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BINSTRING:\r
+ if (load_binstring(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case SHORT_BINSTRING:\r
+ if (load_short_binstring(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case STRING:\r
+ if (load_string(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+#ifdef Py_USING_UNICODE\r
+ case UNICODE:\r
+ if (load_unicode(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BINUNICODE:\r
+ if (load_binunicode(self) < 0)\r
+ break;\r
+ continue;\r
+#endif\r
+\r
+ case EMPTY_TUPLE:\r
+ if (load_counted_tuple(self, 0) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case TUPLE1:\r
+ if (load_counted_tuple(self, 1) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case TUPLE2:\r
+ if (load_counted_tuple(self, 2) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case TUPLE3:\r
+ if (load_counted_tuple(self, 3) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case TUPLE:\r
+ if (load_tuple(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case EMPTY_LIST:\r
+ if (load_empty_list(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case LIST:\r
+ if (load_list(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case EMPTY_DICT:\r
+ if (load_empty_dict(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case DICT:\r
+ if (load_dict(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case OBJ:\r
+ if (noload_obj(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case INST:\r
+ if (noload_inst(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case NEWOBJ:\r
+ if (noload_newobj(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case GLOBAL:\r
+ if (noload_global(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case APPEND:\r
+ if (noload_append(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case APPENDS:\r
+ if (noload_appends(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BUILD:\r
+ if (noload_build(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case DUP:\r
+ if (load_dup(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BINGET:\r
+ if (load_binget(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case LONG_BINGET:\r
+ if (load_long_binget(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case GET:\r
+ if (load_get(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case EXT1:\r
+ if (noload_extension(self, 1) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case EXT2:\r
+ if (noload_extension(self, 2) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case EXT4:\r
+ if (noload_extension(self, 4) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case MARK:\r
+ if (load_mark(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BINPUT:\r
+ if (load_binput(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case LONG_BINPUT:\r
+ if (load_long_binput(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case PUT:\r
+ if (load_put(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case POP:\r
+ if (load_pop(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case POP_MARK:\r
+ if (load_pop_mark(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case SETITEM:\r
+ if (noload_setitem(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case SETITEMS:\r
+ if (noload_setitems(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case STOP:\r
+ break;\r
+\r
+ case PERSID:\r
+ if (load_persid(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case BINPERSID:\r
+ if (load_binpersid(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case REDUCE:\r
+ if (noload_reduce(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case PROTO:\r
+ if (load_proto(self) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case NEWTRUE:\r
+ if (load_bool(self, Py_True) < 0)\r
+ break;\r
+ continue;\r
+\r
+ case NEWFALSE:\r
+ if (load_bool(self, Py_False) < 0)\r
+ break;\r
+ continue;\r
+ default:\r
+ cPickle_ErrFormat(UnpicklingError,\r
+ "invalid load key, '%s'.",\r
+ "c", s[0]);\r
+ return NULL;\r
+ }\r
+\r
+ break;\r
+ }\r
+\r
+ if ((err = PyErr_Occurred())) {\r
+ if (err == PyExc_EOFError) {\r
+ PyErr_SetNone(PyExc_EOFError);\r
+ }\r
+ return NULL;\r
+ }\r
+\r
+ PDATA_POP(self->stack, val);\r
+ return val;\r
+}\r
+\r
+\r
+static PyObject *\r
+Unpickler_load(Unpicklerobject *self, PyObject *unused)\r
+{\r
+ return load(self);\r
+}\r
+\r
+static PyObject *\r
+Unpickler_noload(Unpicklerobject *self, PyObject *unused)\r
+{\r
+ return noload(self);\r
+}\r
+\r
+\r
+static struct PyMethodDef Unpickler_methods[] = {\r
+ {"load", (PyCFunction)Unpickler_load, METH_NOARGS,\r
+ PyDoc_STR("load() -- Load a pickle")\r
+ },\r
+ {"noload", (PyCFunction)Unpickler_noload, METH_NOARGS,\r
+ PyDoc_STR(\r
+ "noload() -- not load a pickle, but go through most of the motions\n"\r
+ "\n"\r
+ "This function can be used to read past a pickle without instantiating\n"\r
+ "any objects or importing any modules. It can also be used to find all\n"\r
+ "persistent references without instantiating any objects or importing\n"\r
+ "any modules.\n")\r
+ },\r
+ {NULL, NULL} /* sentinel */\r
+};\r
+\r
+\r
+static Unpicklerobject *\r
+newUnpicklerobject(PyObject *f)\r
+{\r
+ Unpicklerobject *self;\r
+\r
+ if (!( self = PyObject_GC_New(Unpicklerobject, &Unpicklertype)))\r
+ return NULL;\r
+\r
+ self->file = NULL;\r
+ self->arg = NULL;\r
+ self->stack = (Pdata*)Pdata_New();\r
+ self->pers_func = NULL;\r
+ self->last_string = NULL;\r
+ self->marks = NULL;\r
+ self->num_marks = 0;\r
+ self->marks_size = 0;\r
+ self->buf_size = 0;\r
+ self->read = NULL;\r
+ self->readline = NULL;\r
+ self->find_class = NULL;\r
+\r
+ if (!( self->memo = PyDict_New()))\r
+ goto err;\r
+\r
+ if (!self->stack)\r
+ goto err;\r
+\r
+ Py_INCREF(f);\r
+ self->file = f;\r
+\r
+ /* Set read, readline based on type of f */\r
+ if (PyFile_Check(f)) {\r
+ self->fp = PyFile_AsFile(f);\r
+ if (self->fp == NULL) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "I/O operation on closed file");\r
+ goto err;\r
+ }\r
+ self->read_func = read_file;\r
+ self->readline_func = readline_file;\r
+ }\r
+ else if (PycStringIO_InputCheck(f)) {\r
+ self->fp = NULL;\r
+ self->read_func = read_cStringIO;\r
+ self->readline_func = readline_cStringIO;\r
+ }\r
+ else {\r
+\r
+ self->fp = NULL;\r
+ self->read_func = read_other;\r
+ self->readline_func = readline_other;\r
+\r
+ if (!( (self->readline = PyObject_GetAttr(f, readline_str)) &&\r
+ (self->read = PyObject_GetAttr(f, read_str)))) {\r
+ PyErr_Clear();\r
+ PyErr_SetString( PyExc_TypeError,\r
+ "argument must have 'read' and "\r
+ "'readline' attributes" );\r
+ goto err;\r
+ }\r
+ }\r
+ PyObject_GC_Track(self);\r
+\r
+ return self;\r
+\r
+ err:\r
+ Py_DECREF((PyObject *)self);\r
+ return NULL;\r
+}\r
+\r
+\r
+static PyObject *\r
+get_Unpickler(PyObject *self, PyObject *file)\r
+{\r
+ return (PyObject *)newUnpicklerobject(file);\r
+}\r
+\r
+\r
+static void\r
+Unpickler_dealloc(Unpicklerobject *self)\r
+{\r
+ PyObject_GC_UnTrack((PyObject *)self);\r
+ Py_XDECREF(self->readline);\r
+ Py_XDECREF(self->read);\r
+ Py_XDECREF(self->file);\r
+ Py_XDECREF(self->memo);\r
+ Py_XDECREF(self->stack);\r
+ Py_XDECREF(self->pers_func);\r
+ Py_XDECREF(self->arg);\r
+ Py_XDECREF(self->last_string);\r
+ Py_XDECREF(self->find_class);\r
+\r
+ if (self->marks) {\r
+ free(self->marks);\r
+ }\r
+\r
+ if (self->buf_size) {\r
+ free(self->buf);\r
+ }\r
+\r
+ Py_TYPE(self)->tp_free((PyObject *)self);\r
+}\r
+\r
+static int\r
+Unpickler_traverse(Unpicklerobject *self, visitproc visit, void *arg)\r
+{\r
+ Py_VISIT(self->readline);\r
+ Py_VISIT(self->read);\r
+ Py_VISIT(self->file);\r
+ Py_VISIT(self->memo);\r
+ Py_VISIT(self->stack);\r
+ Py_VISIT(self->pers_func);\r
+ Py_VISIT(self->arg);\r
+ Py_VISIT(self->last_string);\r
+ Py_VISIT(self->find_class);\r
+ return 0;\r
+}\r
+\r
+static int\r
+Unpickler_clear(Unpicklerobject *self)\r
+{\r
+ Py_CLEAR(self->readline);\r
+ Py_CLEAR(self->read);\r
+ Py_CLEAR(self->file);\r
+ Py_CLEAR(self->memo);\r
+ Py_CLEAR(self->stack);\r
+ Py_CLEAR(self->pers_func);\r
+ Py_CLEAR(self->arg);\r
+ Py_CLEAR(self->last_string);\r
+ Py_CLEAR(self->find_class);\r
+ return 0;\r
+}\r
+\r
+static PyObject *\r
+Unpickler_getattr(Unpicklerobject *self, char *name)\r
+{\r
+ if (!strcmp(name, "persistent_load")) {\r
+ if (!self->pers_func) {\r
+ PyErr_SetString(PyExc_AttributeError, name);\r
+ return NULL;\r
+ }\r
+\r
+ Py_INCREF(self->pers_func);\r
+ return self->pers_func;\r
+ }\r
+\r
+ if (!strcmp(name, "find_global")) {\r
+ if (!self->find_class) {\r
+ PyErr_SetString(PyExc_AttributeError, name);\r
+ return NULL;\r
+ }\r
+\r
+ Py_INCREF(self->find_class);\r
+ return self->find_class;\r
+ }\r
+\r
+ if (!strcmp(name, "memo")) {\r
+ if (!self->memo) {\r
+ PyErr_SetString(PyExc_AttributeError, name);\r
+ return NULL;\r
+ }\r
+\r
+ Py_INCREF(self->memo);\r
+ return self->memo;\r
+ }\r
+\r
+ if (!strcmp(name, "UnpicklingError")) {\r
+ Py_INCREF(UnpicklingError);\r
+ return UnpicklingError;\r
+ }\r
+\r
+ return Py_FindMethod(Unpickler_methods, (PyObject *)self, name);\r
+}\r
+\r
+\r
+static int\r
+Unpickler_setattr(Unpicklerobject *self, char *name, PyObject *value)\r
+{\r
+\r
+ if (!strcmp(name, "persistent_load")) {\r
+ Py_XDECREF(self->pers_func);\r
+ self->pers_func = value;\r
+ Py_XINCREF(value);\r
+ return 0;\r
+ }\r
+\r
+ if (!strcmp(name, "find_global")) {\r
+ Py_XDECREF(self->find_class);\r
+ self->find_class = value;\r
+ Py_XINCREF(value);\r
+ return 0;\r
+ }\r
+\r
+ if (! value) {\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "attribute deletion is not supported");\r
+ return -1;\r
+ }\r
+\r
+ if (strcmp(name, "memo") == 0) {\r
+ if (!PyDict_Check(value)) {\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "memo must be a dictionary");\r
+ return -1;\r
+ }\r
+ Py_XDECREF(self->memo);\r
+ self->memo = value;\r
+ Py_INCREF(value);\r
+ return 0;\r
+ }\r
+\r
+ PyErr_SetString(PyExc_AttributeError, name);\r
+ return -1;\r
+}\r
+\r
+/* ---------------------------------------------------------------------------\r
+ * Module-level functions.\r
+ */\r
+\r
+/* dump(obj, file, protocol=0). */\r
+static PyObject *\r
+cpm_dump(PyObject *self, PyObject *args, PyObject *kwds)\r
+{\r
+ static char *kwlist[] = {"obj", "file", "protocol", NULL};\r
+ PyObject *ob, *file, *res = NULL;\r
+ Picklerobject *pickler = 0;\r
+ int proto = 0;\r
+\r
+ if (!( PyArg_ParseTupleAndKeywords(args, kwds, "OO|i", kwlist,\r
+ &ob, &file, &proto)))\r
+ goto finally;\r
+\r
+ if (!( pickler = newPicklerobject(file, proto)))\r
+ goto finally;\r
+\r
+ if (dump(pickler, ob) < 0)\r
+ goto finally;\r
+\r
+ Py_INCREF(Py_None);\r
+ res = Py_None;\r
+\r
+ finally:\r
+ Py_XDECREF(pickler);\r
+\r
+ return res;\r
+}\r
+\r
+\r
+/* dumps(obj, protocol=0). */\r
+static PyObject *\r
+cpm_dumps(PyObject *self, PyObject *args, PyObject *kwds)\r
+{\r
+ static char *kwlist[] = {"obj", "protocol", NULL};\r
+ PyObject *ob, *file = 0, *res = NULL;\r
+ Picklerobject *pickler = 0;\r
+ int proto = 0;\r
+\r
+ if (!( PyArg_ParseTupleAndKeywords(args, kwds, "O|i:dumps", kwlist,\r
+ &ob, &proto)))\r
+ goto finally;\r
+\r
+ if (!( file = PycStringIO->NewOutput(128)))\r
+ goto finally;\r
+\r
+ if (!( pickler = newPicklerobject(file, proto)))\r
+ goto finally;\r
+\r
+ if (dump(pickler, ob) < 0)\r
+ goto finally;\r
+\r
+ res = PycStringIO->cgetvalue(file);\r
+\r
+ finally:\r
+ Py_XDECREF(pickler);\r
+ Py_XDECREF(file);\r
+\r
+ return res;\r
+}\r
+\r
+\r
+/* load(fileobj). */\r
+static PyObject *\r
+cpm_load(PyObject *self, PyObject *ob)\r
+{\r
+ Unpicklerobject *unpickler = 0;\r
+ PyObject *res = NULL;\r
+\r
+ if (!( unpickler = newUnpicklerobject(ob)))\r
+ goto finally;\r
+\r
+ res = load(unpickler);\r
+\r
+ finally:\r
+ Py_XDECREF(unpickler);\r
+\r
+ return res;\r
+}\r
+\r
+\r
+/* loads(string) */\r
+static PyObject *\r
+cpm_loads(PyObject *self, PyObject *args)\r
+{\r
+ PyObject *ob, *file = 0, *res = NULL;\r
+ Unpicklerobject *unpickler = 0;\r
+\r
+ if (!( PyArg_ParseTuple(args, "S:loads", &ob)))\r
+ goto finally;\r
+\r
+ if (!( file = PycStringIO->NewInput(ob)))\r
+ goto finally;\r
+\r
+ if (!( unpickler = newUnpicklerobject(file)))\r
+ goto finally;\r
+\r
+ res = load(unpickler);\r
+\r
+ finally:\r
+ Py_XDECREF(file);\r
+ Py_XDECREF(unpickler);\r
+\r
+ return res;\r
+}\r
+\r
+\r
+PyDoc_STRVAR(Unpicklertype__doc__,\r
+"Objects that know how to unpickle");\r
+\r
+static PyTypeObject Unpicklertype = {\r
+ PyVarObject_HEAD_INIT(NULL, 0)\r
+ "cPickle.Unpickler", /*tp_name*/\r
+ sizeof(Unpicklerobject), /*tp_basicsize*/\r
+ 0,\r
+ (destructor)Unpickler_dealloc, /* tp_dealloc */\r
+ 0, /* tp_print */\r
+ (getattrfunc)Unpickler_getattr, /* tp_getattr */\r
+ (setattrfunc)Unpickler_setattr, /* tp_setattr */\r
+ 0, /* tp_compare */\r
+ 0, /* tp_repr */\r
+ 0, /* tp_as_number */\r
+ 0, /* tp_as_sequence */\r
+ 0, /* tp_as_mapping */\r
+ 0, /* tp_hash */\r
+ 0, /* tp_call */\r
+ 0, /* tp_str */\r
+ 0, /* tp_getattro */\r
+ 0, /* tp_setattro */\r
+ 0, /* tp_as_buffer */\r
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,\r
+ Unpicklertype__doc__, /* tp_doc */\r
+ (traverseproc)Unpickler_traverse, /* tp_traverse */\r
+ (inquiry)Unpickler_clear, /* tp_clear */\r
+};\r
+\r
+static struct PyMethodDef cPickle_methods[] = {\r
+ {"dump", (PyCFunction)cpm_dump, METH_VARARGS | METH_KEYWORDS,\r
+ PyDoc_STR("dump(obj, file, protocol=0) -- "\r
+ "Write an object in pickle format to the given file.\n"\r
+ "\n"\r
+ "See the Pickler docstring for the meaning of optional argument proto.")\r
+ },\r
+\r
+ {"dumps", (PyCFunction)cpm_dumps, METH_VARARGS | METH_KEYWORDS,\r
+ PyDoc_STR("dumps(obj, protocol=0) -- "\r
+ "Return a string containing an object in pickle format.\n"\r
+ "\n"\r
+ "See the Pickler docstring for the meaning of optional argument proto.")\r
+ },\r
+\r
+ {"load", (PyCFunction)cpm_load, METH_O,\r
+ PyDoc_STR("load(file) -- Load a pickle from the given file")},\r
+\r
+ {"loads", (PyCFunction)cpm_loads, METH_VARARGS,\r
+ PyDoc_STR("loads(string) -- Load a pickle from the given string")},\r
+\r
+ {"Pickler", (PyCFunction)get_Pickler, METH_VARARGS | METH_KEYWORDS,\r
+ PyDoc_STR("Pickler(file, protocol=0) -- Create a pickler.\n"\r
+ "\n"\r
+ "This takes a file-like object for writing a pickle data stream.\n"\r
+ "The optional proto argument tells the pickler to use the given\n"\r
+ "protocol; supported protocols are 0, 1, 2. The default\n"\r
+ "protocol is 0, to be backwards compatible. (Protocol 0 is the\n"\r
+ "only protocol that can be written to a file opened in text\n"\r
+ "mode and read back successfully. When using a protocol higher\n"\r
+ "than 0, make sure the file is opened in binary mode, both when\n"\r
+ "pickling and unpickling.)\n"\r
+ "\n"\r
+ "Protocol 1 is more efficient than protocol 0; protocol 2 is\n"\r
+ "more efficient than protocol 1.\n"\r
+ "\n"\r
+ "Specifying a negative protocol version selects the highest\n"\r
+ "protocol version supported. The higher the protocol used, the\n"\r
+ "more recent the version of Python needed to read the pickle\n"\r
+ "produced.\n"\r
+ "\n"\r
+ "The file parameter must have a write() method that accepts a single\n"\r
+ "string argument. It can thus be an open file object, a StringIO\n"\r
+ "object, or any other custom object that meets this interface.\n")\r
+ },\r
+\r
+ {"Unpickler", (PyCFunction)get_Unpickler, METH_O,\r
+ PyDoc_STR("Unpickler(file) -- Create an unpickler.")},\r
+\r
+ { NULL, NULL }\r
+};\r
+\r
+static int\r
+init_stuff(PyObject *module_dict)\r
+{\r
+ PyObject *copyreg, *t, *r;\r
+\r
+#define INIT_STR(S) if (!( S ## _str=PyString_InternFromString(#S))) return -1;\r
+\r
+ if (PyType_Ready(&Unpicklertype) < 0)\r
+ return -1;\r
+ if (PyType_Ready(&Picklertype) < 0)\r
+ return -1;\r
+\r
+ INIT_STR(__class__);\r
+ INIT_STR(__getinitargs__);\r
+ INIT_STR(__dict__);\r
+ INIT_STR(__getstate__);\r
+ INIT_STR(__setstate__);\r
+ INIT_STR(__name__);\r
+ INIT_STR(__main__);\r
+ INIT_STR(__reduce__);\r
+ INIT_STR(__reduce_ex__);\r
+ INIT_STR(write);\r
+ INIT_STR(append);\r
+ INIT_STR(read);\r
+ INIT_STR(readline);\r
+ INIT_STR(dispatch_table);\r
+\r
+ if (!( copyreg = PyImport_ImportModule("copy_reg")))\r
+ return -1;\r
+\r
+ /* This is special because we want to use a different\r
+ one in restricted mode. */\r
+ dispatch_table = PyObject_GetAttr(copyreg, dispatch_table_str);\r
+ if (!dispatch_table) return -1;\r
+\r
+ extension_registry = PyObject_GetAttrString(copyreg,\r
+ "_extension_registry");\r
+ if (!extension_registry) return -1;\r
+\r
+ inverted_registry = PyObject_GetAttrString(copyreg,\r
+ "_inverted_registry");\r
+ if (!inverted_registry) return -1;\r
+\r
+ extension_cache = PyObject_GetAttrString(copyreg,\r
+ "_extension_cache");\r
+ if (!extension_cache) return -1;\r
+\r
+ Py_DECREF(copyreg);\r
+\r
+ if (!(empty_tuple = PyTuple_New(0)))\r
+ return -1;\r
+\r
+ two_tuple = PyTuple_New(2);\r
+ if (two_tuple == NULL)\r
+ return -1;\r
+ /* We use this temp container with no regard to refcounts, or to\r
+ * keeping containees alive. Exempt from GC, because we don't\r
+ * want anything looking at two_tuple() by magic.\r
+ */\r
+ PyObject_GC_UnTrack(two_tuple);\r
+\r
+ /* Ugh */\r
+ if (!( t=PyImport_ImportModule("__builtin__"))) return -1;\r
+ if (PyDict_SetItemString(module_dict, "__builtins__", t) < 0)\r
+ return -1;\r
+\r
+ if (!( t=PyDict_New())) return -1;\r
+ if (!( r=PyRun_String(\r
+ "def __str__(self):\n"\r
+ " return self.args and ('%s' % self.args[0]) or '(what)'\n",\r
+ Py_file_input,\r
+ module_dict, t) )) return -1;\r
+ Py_DECREF(r);\r
+\r
+ PickleError = PyErr_NewException("cPickle.PickleError", NULL, t);\r
+ if (!PickleError)\r
+ return -1;\r
+\r
+ Py_DECREF(t);\r
+\r
+ PicklingError = PyErr_NewException("cPickle.PicklingError",\r
+ PickleError, NULL);\r
+ if (!PicklingError)\r
+ return -1;\r
+\r
+ if (!( t=PyDict_New())) return -1;\r
+ if (!( r=PyRun_String(\r
+ "def __str__(self):\n"\r
+ " a=self.args\n"\r
+ " a=a and type(a[0]) or '(what)'\n"\r
+ " return 'Cannot pickle %s objects' % a\n"\r
+ , Py_file_input,\r
+ module_dict, t) )) return -1;\r
+ Py_DECREF(r);\r
+\r
+ if (!( UnpickleableError = PyErr_NewException(\r
+ "cPickle.UnpickleableError", PicklingError, t)))\r
+ return -1;\r
+\r
+ Py_DECREF(t);\r
+\r
+ if (!( UnpicklingError = PyErr_NewException("cPickle.UnpicklingError",\r
+ PickleError, NULL)))\r
+ return -1;\r
+\r
+ if (!( BadPickleGet = PyErr_NewException("cPickle.BadPickleGet",\r
+ UnpicklingError, NULL)))\r
+ return -1;\r
+\r
+ if (PyDict_SetItemString(module_dict, "PickleError",\r
+ PickleError) < 0)\r
+ return -1;\r
+\r
+ if (PyDict_SetItemString(module_dict, "PicklingError",\r
+ PicklingError) < 0)\r
+ return -1;\r
+\r
+ if (PyDict_SetItemString(module_dict, "UnpicklingError",\r
+ UnpicklingError) < 0)\r
+ return -1;\r
+\r
+ if (PyDict_SetItemString(module_dict, "UnpickleableError",\r
+ UnpickleableError) < 0)\r
+ return -1;\r
+\r
+ if (PyDict_SetItemString(module_dict, "BadPickleGet",\r
+ BadPickleGet) < 0)\r
+ return -1;\r
+\r
+ PycString_IMPORT;\r
+\r
+ return 0;\r
+}\r
+\r
+#ifndef PyMODINIT_FUNC /* declarations for DLL import/export */\r
+#define PyMODINIT_FUNC void\r
+#endif\r
+PyMODINIT_FUNC\r
+initcPickle(void)\r
+{\r
+ PyObject *m, *d, *di, *v, *k;\r
+ Py_ssize_t i;\r
+ char *rev = "1.71"; /* XXX when does this change? */\r
+ PyObject *format_version;\r
+ PyObject *compatible_formats;\r
+\r
+ Py_TYPE(&Picklertype) = &PyType_Type;\r
+ Py_TYPE(&Unpicklertype) = &PyType_Type;\r
+ Py_TYPE(&PdataType) = &PyType_Type;\r
+\r
+ /* Initialize some pieces. We need to do this before module creation,\r
+ * so we're forced to use a temporary dictionary. :(\r
+ */\r
+ di = PyDict_New();\r
+ if (!di) return;\r
+ if (init_stuff(di) < 0) return;\r
+\r
+ /* Create the module and add the functions */\r
+ m = Py_InitModule4("cPickle", cPickle_methods,\r
+ cPickle_module_documentation,\r
+ (PyObject*)NULL,PYTHON_API_VERSION);\r
+ if (m == NULL)\r
+ return;\r
+\r
+ /* Add some symbolic constants to the module */\r
+ d = PyModule_GetDict(m);\r
+ v = PyString_FromString(rev);\r
+ PyDict_SetItemString(d, "__version__", v);\r
+ Py_XDECREF(v);\r
+\r
+ /* Copy data from di. Waaa. */\r
+ for (i=0; PyDict_Next(di, &i, &k, &v); ) {\r
+ if (PyObject_SetItem(d, k, v) < 0) {\r
+ Py_DECREF(di);\r
+ return;\r
+ }\r
+ }\r
+ Py_DECREF(di);\r
+\r
+ i = PyModule_AddIntConstant(m, "HIGHEST_PROTOCOL", HIGHEST_PROTOCOL);\r
+ if (i < 0)\r
+ return;\r
+\r
+ /* These are purely informational; no code uses them. */\r
+ /* File format version we write. */\r
+ format_version = PyString_FromString("2.0");\r
+ /* Format versions we can read. */\r
+ compatible_formats = Py_BuildValue("[sssss]",\r
+ "1.0", /* Original protocol 0 */\r
+ "1.1", /* Protocol 0 + INST */\r
+ "1.2", /* Original protocol 1 */\r
+ "1.3", /* Protocol 1 + BINFLOAT */\r
+ "2.0"); /* Original protocol 2 */\r
+ PyDict_SetItemString(d, "format_version", format_version);\r
+ PyDict_SetItemString(d, "compatible_formats", compatible_formats);\r
+ Py_XDECREF(format_version);\r
+ Py_XDECREF(compatible_formats);\r
+}\r