+++ /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
projects / mirror_edk2.git / blobdiff