diff options
Diffstat (limited to 'Modules/cPickle.c')
| -rw-r--r-- | Modules/cPickle.c | 7123 |
1 files changed, 3641 insertions, 3482 deletions
diff --git a/Modules/cPickle.c b/Modules/cPickle.c index 5b96af8..fb44f05 100644 --- a/Modules/cPickle.c +++ b/Modules/cPickle.c @@ -149,80 +149,85 @@ static PyObject *__class___str, *__getinitargs___str, *__dict___str, Internal Data type for pickle data. */ typedef struct { - PyObject_HEAD - int length, size; - PyObject **data; + PyObject_HEAD + int length, size; + PyObject **data; } Pdata; static void -Pdata_dealloc(Pdata *self) { - int i; - PyObject **p; - - for (i=self->length, p=self->data; --i >= 0; p++) Py_DECREF(*p); +Pdata_dealloc(Pdata *self) +{ + int i; + PyObject **p; + + for (i=self->length, p=self->data; --i >= 0; p++) Py_DECREF(*p); - if (self->data) free(self->data); + if (self->data) free(self->data); - PyObject_Del(self); + PyObject_Del(self); } static PyTypeObject PdataType = { - PyObject_HEAD_INIT(NULL) 0, "cPickle.Pdata", sizeof(Pdata), 0, - (destructor)Pdata_dealloc, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0L,0L,0L,0L, "" + PyObject_HEAD_INIT(NULL) 0, "cPickle.Pdata", sizeof(Pdata), 0, + (destructor)Pdata_dealloc, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0L,0L,0L,0L, "" }; #define Pdata_Check(O) ((O)->ob_type == &PdataType) static PyObject * -Pdata_New(void) { - Pdata *self; +Pdata_New(void) +{ + Pdata *self; - if (!( self = PyObject_New(Pdata, &PdataType))) return NULL; - self->size=8; - self->length=0; - self->data=malloc(self->size * sizeof(PyObject*)); - if (self->data) return (PyObject*)self; - Py_DECREF(self); - return PyErr_NoMemory(); + if (!( self = PyObject_New(Pdata, &PdataType))) return NULL; + self->size=8; + self->length=0; + self->data=malloc(self->size * sizeof(PyObject*)); + if (self->data) return (PyObject*)self; + Py_DECREF(self); + return PyErr_NoMemory(); } static int -stackUnderflow(void) { - PyErr_SetString(UnpicklingError, "unpickling stack underflow"); - return -1; +stackUnderflow(void) +{ + PyErr_SetString(UnpicklingError, "unpickling stack underflow"); + return -1; } static int -Pdata_clear(Pdata *self, int clearto) { - int i; - PyObject **p; +Pdata_clear(Pdata *self, int clearto) +{ + int i; + PyObject **p; - if (clearto < 0) return stackUnderflow(); - if (clearto >= self->length) return 0; + if (clearto < 0) return stackUnderflow(); + if (clearto >= self->length) return 0; - for (i=self->length, p=self->data+clearto; --i >= clearto; p++) - Py_DECREF(*p); - self->length=clearto; + for (i=self->length, p=self->data+clearto; --i >= clearto; p++) + Py_DECREF(*p); + self->length=clearto; - return 0; + return 0; } static int -Pdata_grow(Pdata *self) { - if (! self->size) { - PyErr_NoMemory(); - return -1; - } - self->size *= 2; - self->data = realloc(self->data, self->size*sizeof(PyObject*)); - if (! self->data) { - self->size = 0; - PyErr_NoMemory(); - return -1; - } - return 0; +Pdata_grow(Pdata *self) +{ + if (! self->size) { + PyErr_NoMemory(); + return -1; + } + self->size *= 2; + self->data = realloc(self->data, self->size*sizeof(PyObject*)); + if (! self->data) { + self->size = 0; + PyErr_NoMemory(); + return -1; + } + return 0; } #define PDATA_POP(D,V) { \ @@ -235,31 +240,33 @@ Pdata_grow(Pdata *self) { static PyObject * -Pdata_popTuple(Pdata *self, int start) { - PyObject *r; - int i, j, l; - - l=self->length-start; - if (!( r=PyTuple_New(l))) return NULL; - for (i=start, j=0 ; j < l; i++, j++) - PyTuple_SET_ITEM(r, j, self->data[i]); - - self->length=start; - return r; +Pdata_popTuple(Pdata *self, int start) +{ + PyObject *r; + int i, j, l; + + l=self->length-start; + if (!( r=PyTuple_New(l))) return NULL; + for (i=start, j=0 ; j < l; i++, j++) + PyTuple_SET_ITEM(r, j, self->data[i]); + + self->length=start; + return r; } static PyObject * -Pdata_popList(Pdata *self, int start) { - PyObject *r; - int i, j, l; +Pdata_popList(Pdata *self, int start) +{ + PyObject *r; + int i, j, l; - l=self->length-start; - if (!( r=PyList_New(l))) return NULL; - for (i=start, j=0 ; j < l; i++, j++) - PyList_SET_ITEM(r, j, self->data[i]); + l=self->length-start; + if (!( r=PyList_New(l))) return NULL; + for (i=start, j=0 ; j < l; i++, j++) + PyList_SET_ITEM(r, j, self->data[i]); - self->length=start; - return r; + self->length=start; + return r; } #define PDATA_APPEND_(D,O,ER) { \ @@ -303,22 +310,22 @@ Pdata_popList(Pdata *self, int start) { } typedef struct Picklerobject { - PyObject_HEAD - FILE *fp; - PyObject *write; - PyObject *file; - PyObject *memo; - PyObject *arg; - PyObject *pers_func; - PyObject *inst_pers_func; - int bin; - int fast; /* Fast mode doesn't save in memo, don't use if circ ref */ - int (*write_func)(struct Picklerobject *, char *, int); - char *write_buf; - int buf_size; - PyObject *dispatch_table; - int fast_container; /* count nested container dumps */ - PyObject *fast_memo; + PyObject_HEAD + FILE *fp; + PyObject *write; + PyObject *file; + PyObject *memo; + PyObject *arg; + PyObject *pers_func; + PyObject *inst_pers_func; + int bin; + int fast; /* Fast mode doesn't save in memo, don't use if circ ref */ + int (*write_func)(struct Picklerobject *, char *, int); + char *write_buf; + int buf_size; + PyObject *dispatch_table; + int fast_container; /* count nested container dumps */ + PyObject *fast_memo; } Picklerobject; #ifndef PY_CPICKLE_FAST_LIMIT @@ -328,26 +335,26 @@ typedef struct Picklerobject { staticforward PyTypeObject Picklertype; typedef struct Unpicklerobject { - PyObject_HEAD - FILE *fp; - PyObject *file; - PyObject *readline; - PyObject *read; - PyObject *memo; - PyObject *arg; - Pdata *stack; - PyObject *mark; - PyObject *pers_func; - PyObject *last_string; - int *marks; - int num_marks; - int marks_size; - int (*read_func)(struct Unpicklerobject *, char **, int); - int (*readline_func)(struct Unpicklerobject *, char **); - int buf_size; - char *buf; - PyObject *safe_constructors; - PyObject *find_class; + PyObject_HEAD + FILE *fp; + PyObject *file; + PyObject *readline; + PyObject *read; + PyObject *memo; + PyObject *arg; + Pdata *stack; + PyObject *mark; + PyObject *pers_func; + PyObject *last_string; + int *marks; + int num_marks; + int marks_size; + int (*read_func)(struct Unpicklerobject *, char **, int); + int (*readline_func)(struct Unpicklerobject *, char **); + int buf_size; + char *buf; + PyObject *safe_constructors; + PyObject *find_class; } Unpicklerobject; staticforward PyTypeObject Unpicklertype; @@ -357,855 +364,889 @@ static int save(Picklerobject *, PyObject *, int); static int put2(Picklerobject *, PyObject *); int -cPickle_PyMapping_HasKey(PyObject *o, PyObject *key) { - PyObject *v; - - if ((v = PyObject_GetItem(o,key))) { - Py_DECREF(v); - return 1; - } +cPickle_PyMapping_HasKey(PyObject *o, PyObject *key) +{ + PyObject *v; - PyErr_Clear(); - return 0; + if ((v = PyObject_GetItem(o,key))) { + Py_DECREF(v); + return 1; + } + + PyErr_Clear(); + return 0; } static PyObject * cPickle_ErrFormat(PyObject *ErrType, char *stringformat, char *format, ...) { - va_list va; - PyObject *args=0, *retval=0; - va_start(va, format); - - if (format) args = Py_VaBuildValue(format, va); - va_end(va); - if (format && ! args) return NULL; - if (stringformat && !(retval=PyString_FromString(stringformat))) return NULL; - - if (retval) { - if (args) { - PyObject *v; - v=PyString_Format(retval, args); - Py_DECREF(retval); - Py_DECREF(args); - if (! v) return NULL; - retval=v; - } - } - else - if (args) retval=args; - else { - PyErr_SetObject(ErrType,Py_None); - return NULL; - } - PyErr_SetObject(ErrType,retval); - Py_DECREF(retval); - return NULL; + va_list va; + PyObject *args=0, *retval=0; + va_start(va, format); + + if (format) args = Py_VaBuildValue(format, va); + va_end(va); + if (format && ! args) return NULL; + if (stringformat && !(retval=PyString_FromString(stringformat))) + return NULL; + + if (retval) { + if (args) { + PyObject *v; + v=PyString_Format(retval, args); + Py_DECREF(retval); + Py_DECREF(args); + if (! v) return NULL; + retval=v; + } + } + else + if (args) retval=args; + else { + PyErr_SetObject(ErrType,Py_None); + return NULL; + } + PyErr_SetObject(ErrType,retval); + Py_DECREF(retval); + return NULL; } static int -write_file(Picklerobject *self, char *s, int n) { - size_t nbyteswritten; +write_file(Picklerobject *self, char *s, int n) +{ + size_t nbyteswritten; - if (s == NULL) { - return 0; - } + if (s == NULL) { + return 0; + } - Py_BEGIN_ALLOW_THREADS - nbyteswritten = fwrite(s, sizeof(char), n, self->fp); - Py_END_ALLOW_THREADS - if (nbyteswritten != (size_t)n) { - PyErr_SetFromErrno(PyExc_IOError); - return -1; - } + Py_BEGIN_ALLOW_THREADS + nbyteswritten = fwrite(s, sizeof(char), n, self->fp); + Py_END_ALLOW_THREADS + if (nbyteswritten != (size_t)n) { + PyErr_SetFromErrno(PyExc_IOError); + return -1; + } - return n; + return n; } static int -write_cStringIO(Picklerobject *self, char *s, int n) { - if (s == NULL) { - return 0; - } - - if (PycStringIO->cwrite((PyObject *)self->file, s, n) != n) { - return -1; - } +write_cStringIO(Picklerobject *self, char *s, int n) +{ + if (s == NULL) { + return 0; + } + + if (PycStringIO->cwrite((PyObject *)self->file, s, n) != n) { + return -1; + } - return n; + return n; } static int -write_none(Picklerobject *self, char *s, int n) { - if (s == NULL) return 0; - return n; +write_none(Picklerobject *self, char *s, int n) +{ + if (s == NULL) return 0; + return n; } static int -write_other(Picklerobject *self, char *s, int n) { - PyObject *py_str = 0, *junk = 0; - - if (s == NULL) { - if (!( self->buf_size )) return 0; - if (!( py_str = - PyString_FromStringAndSize(self->write_buf, self->buf_size))) - return -1; - } - else { - if (self->buf_size && (n + self->buf_size) > WRITE_BUF_SIZE) { - if (write_other(self, NULL, 0) < 0) - return -1; - } - - if (n > WRITE_BUF_SIZE) { - if (!( py_str = - PyString_FromStringAndSize(s, n))) - return -1; - } - else { - memcpy(self->write_buf + self->buf_size, s, n); - self->buf_size += n; - return n; - } - } - - if (self->write) { - /* object with write method */ - ARG_TUP(self, py_str); - if (self->arg) { - junk = PyObject_Call(self->write, self->arg, NULL); - FREE_ARG_TUP(self); - } - if (junk) Py_DECREF(junk); - else return -1; - } - else - PDATA_PUSH(self->file, py_str, -1); - - self->buf_size = 0; - return n; -} +write_other(Picklerobject *self, char *s, int n) +{ + PyObject *py_str = 0, *junk = 0; + + if (s == NULL) { + if (!( self->buf_size )) return 0; + py_str = PyString_FromStringAndSize(self->write_buf, + self->buf_size); + if (!py_str) + return -1; + } + else { + if (self->buf_size && (n + self->buf_size) > WRITE_BUF_SIZE) { + if (write_other(self, NULL, 0) < 0) + return -1; + } + + if (n > WRITE_BUF_SIZE) { + if (!( py_str = + PyString_FromStringAndSize(s, n))) + return -1; + } + else { + memcpy(self->write_buf + self->buf_size, s, n); + self->buf_size += n; + return n; + } + } + if (self->write) { + /* object with write method */ + ARG_TUP(self, py_str); + if (self->arg) { + junk = PyObject_Call(self->write, self->arg, NULL); + FREE_ARG_TUP(self); + } + if (junk) Py_DECREF(junk); + else return -1; + } + else + PDATA_PUSH(self->file, py_str, -1); -static int -read_file(Unpicklerobject *self, char **s, int n) { - size_t nbytesread; + self->buf_size = 0; + return n; +} - if (self->buf_size == 0) { - int size; - size = ((n < 32) ? 32 : n); - if (!( self->buf = (char *)malloc(size * sizeof(char)))) { - PyErr_NoMemory(); - return -1; - } +static int +read_file(Unpicklerobject *self, char **s, int n) +{ + size_t nbytesread; - self->buf_size = size; - } - else if (n > self->buf_size) { - if (!( self->buf = (char *)realloc(self->buf, n * sizeof(char)))) { - PyErr_NoMemory(); - return -1; - } + if (self->buf_size == 0) { + int size; - self->buf_size = n; - } + size = ((n < 32) ? 32 : n); + if (!( self->buf = (char *)malloc(size * sizeof(char)))) { + PyErr_NoMemory(); + return -1; + } - Py_BEGIN_ALLOW_THREADS - nbytesread = fread(self->buf, sizeof(char), n, self->fp); - Py_END_ALLOW_THREADS - if (nbytesread != (size_t)n) { - if (feof(self->fp)) { - PyErr_SetNone(PyExc_EOFError); - return -1; - } + self->buf_size = size; + } + else if (n > self->buf_size) { + self->buf = (char *)realloc(self->buf, n * sizeof(char)); + if (!self->buf) { + PyErr_NoMemory(); + return -1; + } + + self->buf_size = n; + } - PyErr_SetFromErrno(PyExc_IOError); - return -1; - } + Py_BEGIN_ALLOW_THREADS + nbytesread = fread(self->buf, sizeof(char), n, self->fp); + Py_END_ALLOW_THREADS + if (nbytesread != (size_t)n) { + if (feof(self->fp)) { + PyErr_SetNone(PyExc_EOFError); + return -1; + } + + PyErr_SetFromErrno(PyExc_IOError); + return -1; + } - *s = self->buf; + *s = self->buf; - return n; + return n; } static int -readline_file(Unpicklerobject *self, char **s) { - int i; +readline_file(Unpicklerobject *self, char **s) +{ + int i; - if (self->buf_size == 0) { - if (!( self->buf = (char *)malloc(40 * sizeof(char)))) { - PyErr_NoMemory(); - return -1; - } + if (self->buf_size == 0) { + if (!( self->buf = (char *)malloc(40 * sizeof(char)))) { + PyErr_NoMemory(); + return -1; + } - self->buf_size = 40; - } + self->buf_size = 40; + } - i = 0; - while (1) { - for (; i < (self->buf_size - 1); i++) { - if (feof(self->fp) || (self->buf[i] = getc(self->fp)) == '\n') { - self->buf[i + 1] = '\0'; - *s = self->buf; - return i + 1; - } - } + i = 0; + while (1) { + for (; i < (self->buf_size - 1); i++) { + if (feof(self->fp) || + (self->buf[i] = getc(self->fp)) == '\n') { + self->buf[i + 1] = '\0'; + *s = self->buf; + return i + 1; + } + } + self->buf = (char *)realloc(self->buf, + (self->buf_size * 2) * sizeof(char)); + if (!self->buf) { + PyErr_NoMemory(); + return -1; + } + + self->buf_size *= 2; + } +} - if (!( self->buf = (char *)realloc(self->buf, - (self->buf_size * 2) * sizeof(char)))) { - PyErr_NoMemory(); - return -1; - } - self->buf_size *= 2; - } +static int +read_cStringIO(Unpicklerobject *self, char **s, int n) +{ + char *ptr; + + if (PycStringIO->cread((PyObject *)self->file, &ptr, n) != n) { + PyErr_SetNone(PyExc_EOFError); + return -1; + } + *s = ptr; + + return n; } static int -read_cStringIO(Unpicklerobject *self, char **s, int n) { - char *ptr; +readline_cStringIO(Unpicklerobject *self, char **s) +{ + int n; + char *ptr; - if (PycStringIO->cread((PyObject *)self->file, &ptr, n) != n) { - PyErr_SetNone(PyExc_EOFError); - return -1; - } + if ((n = PycStringIO->creadline((PyObject *)self->file, &ptr)) < 0) { + return -1; + } - *s = ptr; + *s = ptr; - return n; + return n; } static int -readline_cStringIO(Unpicklerobject *self, char **s) { - int n; - char *ptr; +read_other(Unpicklerobject *self, char **s, int n) +{ + PyObject *bytes, *str=0; - if ((n = PycStringIO->creadline((PyObject *)self->file, &ptr)) < 0) { - return -1; - } + if (!( bytes = PyInt_FromLong(n))) return -1; - *s = ptr; + ARG_TUP(self, bytes); + if (self->arg) { + str = PyObject_Call(self->read, self->arg, NULL); + FREE_ARG_TUP(self); + } + if (! str) return -1; + + Py_XDECREF(self->last_string); + self->last_string = str; - return n; + if (! (*s = PyString_AsString(str))) return -1; + return n; } static int -read_other(Unpicklerobject *self, char **s, int n) { - PyObject *bytes, *str=0; +readline_other(Unpicklerobject *self, char **s) +{ + PyObject *str; + int str_size; + + if (!( str = PyObject_CallObject(self->readline, empty_tuple))) { + return -1; + } - if (!( bytes = PyInt_FromLong(n))) return -1; + if ((str_size = PyString_Size(str)) < 0) + return -1; - ARG_TUP(self, bytes); - if (self->arg) { - str = PyObject_Call(self->read, self->arg, NULL); - FREE_ARG_TUP(self); - } - if (! str) return -1; + Py_XDECREF(self->last_string); + self->last_string = str; - Py_XDECREF(self->last_string); - self->last_string = str; + if (! (*s = PyString_AsString(str))) + return -1; - if (! (*s = PyString_AsString(str))) return -1; - return n; + return str_size; } -static int -readline_other(Unpicklerobject *self, char **s) { - PyObject *str; - int str_size; - - if (!( str = PyObject_CallObject(self->readline, empty_tuple))) { - return -1; - } +static char * +pystrndup(char *s, int l) +{ + char *r; + if (!( r=malloc((l+1)*sizeof(char)))) return (char*)PyErr_NoMemory(); + memcpy(r,s,l); + r[l]=0; + return r; +} - if ((str_size = PyString_Size(str)) < 0) - return -1; - Py_XDECREF(self->last_string); - self->last_string = str; +static int +get(Picklerobject *self, PyObject *id) +{ + PyObject *value, *mv; + long c_value; + char s[30]; + size_t len; + + if (!( mv = PyDict_GetItem(self->memo, id))) { + PyErr_SetObject(PyExc_KeyError, id); + return -1; + } - if (! (*s = PyString_AsString(str))) - return -1; + if (!( value = PyTuple_GetItem(mv, 0))) + return -1; - return str_size; -} + if (!( PyInt_Check(value))) { + PyErr_SetString(PicklingError, "no int where int expected in memo"); + return -1; + } + c_value = PyInt_AS_LONG((PyIntObject*)value); + if (!self->bin) { + s[0] = GET; + PyOS_snprintf(s + 1, sizeof(s) - 1, "%ld\n", c_value); + len = strlen(s); + } + else if (Pdata_Check(self->file)) { + if (write_other(self, NULL, 0) < 0) return -1; + PDATA_APPEND(self->file, mv, -1); + return 0; + } + else { + if (c_value < 256) { + s[0] = BINGET; + s[1] = (int)(c_value & 0xff); + len = 2; + } + else { + s[0] = LONG_BINGET; + s[1] = (int)(c_value & 0xff); + s[2] = (int)((c_value >> 8) & 0xff); + s[3] = (int)((c_value >> 16) & 0xff); + s[4] = (int)((c_value >> 24) & 0xff); + len = 5; + } + } -static char * -pystrndup(char *s, int l) { - char *r; - if (!( r=malloc((l+1)*sizeof(char)))) return (char*)PyErr_NoMemory(); - memcpy(r,s,l); - r[l]=0; - return r; + if ((*self->write_func)(self, s, len) < 0) + return -1; + + return 0; } static int -get(Picklerobject *self, PyObject *id) { - PyObject *value, *mv; - long c_value; - char s[30]; - size_t len; - - if (!( mv = PyDict_GetItem(self->memo, id))) { - PyErr_SetObject(PyExc_KeyError, id); - return -1; - } - - if (!( value = PyTuple_GetItem(mv, 0))) - return -1; - - if (!( PyInt_Check(value))) { - PyErr_SetString(PicklingError, "no int where int expected in memo"); - return -1; - } - c_value = PyInt_AS_LONG((PyIntObject*)value); - - if (!self->bin) { - s[0] = GET; - PyOS_snprintf(s + 1, sizeof(s) - 1, "%ld\n", c_value); - len = strlen(s); - } - else if (Pdata_Check(self->file)) { - if (write_other(self, NULL, 0) < 0) return -1; - PDATA_APPEND(self->file, mv, -1); - return 0; - } - else { - if (c_value < 256) { - s[0] = BINGET; - s[1] = (int)(c_value & 0xff); - len = 2; - } - else { - s[0] = LONG_BINGET; - s[1] = (int)(c_value & 0xff); - s[2] = (int)((c_value >> 8) & 0xff); - s[3] = (int)((c_value >> 16) & 0xff); - s[4] = (int)((c_value >> 24) & 0xff); - len = 5; - } - } - - if ((*self->write_func)(self, s, len) < 0) - return -1; - - return 0; +put(Picklerobject *self, PyObject *ob) +{ + if (ob->ob_refcnt < 2 || self->fast) + return 0; + + return put2(self, ob); } static int -put(Picklerobject *self, PyObject *ob) { - if (ob->ob_refcnt < 2 || self->fast) - return 0; +put2(Picklerobject *self, PyObject *ob) +{ + char c_str[30]; + int p; + size_t len; + int res = -1; + PyObject *py_ob_id = 0, *memo_len = 0, *t = 0; - return put2(self, ob); -} + if (self->fast) + return 0; + if ((p = PyDict_Size(self->memo)) < 0) + goto finally; -static int -put2(Picklerobject *self, PyObject *ob) { - char c_str[30]; - int p; - size_t len; - int res = -1; - PyObject *py_ob_id = 0, *memo_len = 0, *t = 0; - - if (self->fast) - return 0; + /* Make sure memo keys are positive! */ + p++; + + if (!( py_ob_id = PyLong_FromVoidPtr(ob))) + goto finally; + + if (!( memo_len = PyInt_FromLong(p))) + goto finally; + + if (!( t = PyTuple_New(2))) + goto finally; + + PyTuple_SET_ITEM(t, 0, memo_len); + Py_INCREF(memo_len); + PyTuple_SET_ITEM(t, 1, ob); + Py_INCREF(ob); + + if (PyDict_SetItem(self->memo, py_ob_id, t) < 0) + goto finally; + + if (!self->bin) { + c_str[0] = PUT; + PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%d\n", p); + len = strlen(c_str); + } + else if (Pdata_Check(self->file)) { + if (write_other(self, NULL, 0) < 0) return -1; + PDATA_APPEND(self->file, memo_len, -1); + res=0; /* Job well done ;) */ + goto finally; + } + else { + if (p >= 256) { + c_str[0] = LONG_BINPUT; + c_str[1] = (int)(p & 0xff); + c_str[2] = (int)((p >> 8) & 0xff); + c_str[3] = (int)((p >> 16) & 0xff); + c_str[4] = (int)((p >> 24) & 0xff); + len = 5; + } + else { + c_str[0] = BINPUT; + c_str[1] = p; + len = 2; + } + } - if ((p = PyDict_Size(self->memo)) < 0) - goto finally; - - p++; /* Make sure memo keys are positive! */ - - if (!( py_ob_id = PyLong_FromVoidPtr(ob))) - goto finally; - - if (!( memo_len = PyInt_FromLong(p))) - goto finally; - - if (!( t = PyTuple_New(2))) - goto finally; - - PyTuple_SET_ITEM(t, 0, memo_len); - Py_INCREF(memo_len); - PyTuple_SET_ITEM(t, 1, ob); - Py_INCREF(ob); - - if (PyDict_SetItem(self->memo, py_ob_id, t) < 0) - goto finally; - - if (!self->bin) { - c_str[0] = PUT; - PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%d\n", p); - len = strlen(c_str); - } - else if (Pdata_Check(self->file)) { - if (write_other(self, NULL, 0) < 0) return -1; - PDATA_APPEND(self->file, memo_len, -1); - res=0; /* Job well done ;) */ - goto finally; - } - else { - if (p >= 256) { - c_str[0] = LONG_BINPUT; - c_str[1] = (int)(p & 0xff); - c_str[2] = (int)((p >> 8) & 0xff); - c_str[3] = (int)((p >> 16) & 0xff); - c_str[4] = (int)((p >> 24) & 0xff); - len = 5; - } - else { - c_str[0] = BINPUT; - c_str[1] = p; - len = 2; - } - } - - if ((*self->write_func)(self, c_str, len) < 0) - goto finally; - - res = 0; - -finally: - Py_XDECREF(py_ob_id); - Py_XDECREF(memo_len); - Py_XDECREF(t); - - return res; + if ((*self->write_func)(self, c_str, len) < 0) + goto finally; + + res = 0; + + finally: + Py_XDECREF(py_ob_id); + Py_XDECREF(memo_len); + Py_XDECREF(t); + + return res; } #define PyImport_Import cPickle_Import static PyObject * -PyImport_Import(PyObject *module_name) { - static PyObject *silly_list=0, *__builtins___str=0, *__import___str; - static PyObject *standard_builtins=0; - PyObject *globals=0, *__import__=0, *__builtins__=0, *r=0; - - if (!( silly_list )) { - if (!( __import___str=PyString_FromString("__import__"))) - return NULL; - if (!( __builtins___str=PyString_FromString("__builtins__"))) - return NULL; - if (!( silly_list=Py_BuildValue("[s]","__doc__"))) - return NULL; - } - - if ((globals=PyEval_GetGlobals())) { - Py_INCREF(globals); - if (!( __builtins__=PyObject_GetItem(globals,__builtins___str))) - goto err; - } - else { - PyErr_Clear(); - - if (!( standard_builtins || - (standard_builtins=PyImport_ImportModule("__builtin__")))) - return NULL; - - __builtins__=standard_builtins; - Py_INCREF(__builtins__); - if (!( globals = Py_BuildValue("{sO}", "__builtins__", __builtins__))) - goto err; - } - - if (PyDict_Check(__builtins__)) { - if (!( __import__=PyObject_GetItem(__builtins__,__import___str))) goto err; - } - else { - if (!( __import__=PyObject_GetAttr(__builtins__,__import___str))) goto err; - } +PyImport_Import(PyObject *module_name) +{ + static PyObject *silly_list=0, *__builtins___str=0, *__import___str; + static PyObject *standard_builtins=0; + PyObject *globals=0, *__import__=0, *__builtins__=0, *r=0; + + if (!( silly_list )) { + if (!( __import___str=PyString_FromString("__import__"))) + return NULL; + if (!( __builtins___str=PyString_FromString("__builtins__"))) + return NULL; + if (!( silly_list=Py_BuildValue("[s]","__doc__"))) + return NULL; + } - if (!( r=PyObject_CallFunction(__import__,"OOOO", - module_name, globals, globals, silly_list))) - goto err; + if ((globals=PyEval_GetGlobals())) { + Py_INCREF(globals); + __builtins__=PyObject_GetItem(globals,__builtins___str); + if (!__builtins__) + goto err; + } + else { + PyErr_Clear(); + + if (!(standard_builtins || + (standard_builtins=PyImport_ImportModule("__builtin__")))) + return NULL; + + __builtins__=standard_builtins; + Py_INCREF(__builtins__); + globals = Py_BuildValue("{sO}", "__builtins__", __builtins__); + if (!globals) + goto err; + } - Py_DECREF(globals); - Py_DECREF(__builtins__); - Py_DECREF(__import__); + if (PyDict_Check(__builtins__)) { + __import__=PyObject_GetItem(__builtins__,__import___str); + if (!__import__) goto err; + } + else { + __import__=PyObject_GetAttr(__builtins__,__import___str); + if (!__import__) goto err; + } + + r=PyObject_CallFunction(__import__,"OOOO", + module_name, globals, globals, silly_list); + if (!r) + goto err; + + Py_DECREF(globals); + Py_DECREF(__builtins__); + Py_DECREF(__import__); - return r; -err: - Py_XDECREF(globals); - Py_XDECREF(__builtins__); - Py_XDECREF(__import__); - return NULL; + return r; + err: + Py_XDECREF(globals); + Py_XDECREF(__builtins__); + Py_XDECREF(__import__); + return NULL; } static PyObject * -whichmodule(PyObject *global, PyObject *global_name) { - int i, j; - PyObject *module = 0, *modules_dict = 0, - *global_name_attr = 0, *name = 0; +whichmodule(PyObject *global, PyObject *global_name) +{ + int i, j; + PyObject *module = 0, *modules_dict = 0, + *global_name_attr = 0, *name = 0; - module = PyObject_GetAttrString(global, "__module__"); - if (module) return module; - PyErr_Clear(); + module = PyObject_GetAttrString(global, "__module__"); + if (module) return module; + PyErr_Clear(); - if (!( modules_dict = PySys_GetObject("modules"))) - return NULL; + if (!( modules_dict = PySys_GetObject("modules"))) + return NULL; - i = 0; - while ((j = PyDict_Next(modules_dict, &i, &name, &module))) { + i = 0; + while ((j = PyDict_Next(modules_dict, &i, &name, &module))) { - if (PyObject_Compare(name, __main___str)==0) continue; + if (PyObject_Compare(name, __main___str)==0) continue; - if (!( global_name_attr = PyObject_GetAttr(module, global_name))) { - PyErr_Clear(); - continue; - } + global_name_attr = PyObject_GetAttr(module, global_name); + if (!global_name_attr) { + PyErr_Clear(); + continue; + } - if (global_name_attr != global) { - Py_DECREF(global_name_attr); - continue; - } + if (global_name_attr != global) { + Py_DECREF(global_name_attr); + continue; + } - Py_DECREF(global_name_attr); + Py_DECREF(global_name_attr); - break; - } + break; + } - /* The following implements the rule in pickle.py added in 1.5 - that used __main__ if no module is found. I don't actually - like this rule. jlf - */ - if (!j) { - j=1; - name=__main___str; - } + /* The following implements the rule in pickle.py added in 1.5 + that used __main__ if no module is found. I don't actually + like this rule. jlf + */ + if (!j) { + j=1; + name=__main___str; + } - Py_INCREF(name); - return name; + Py_INCREF(name); + return name; } static int fast_save_enter(Picklerobject *self, PyObject *obj) { - /* if fast_container < 0, we're doing an error exit. */ - if (++self->fast_container >= PY_CPICKLE_FAST_LIMIT) { - PyObject *key = NULL; - if (self->fast_memo == NULL) { - self->fast_memo = PyDict_New(); - if (self->fast_memo == NULL) { - self->fast_container = -1; - return 0; - } - } - key = PyLong_FromVoidPtr(obj); - if (key == NULL) - return 0; - if (PyDict_GetItem(self->fast_memo, key)) { - PyErr_Format(PyExc_ValueError, - "fast mode: can't pickle cyclic objects including object type %s at %p", - obj->ob_type->tp_name, obj); - self->fast_container = -1; - return 0; - } - if (PyDict_SetItem(self->fast_memo, key, Py_None) < 0) { - self->fast_container = -1; - return 0; + /* if fast_container < 0, we're doing an error exit. */ + if (++self->fast_container >= PY_CPICKLE_FAST_LIMIT) { + PyObject *key = NULL; + if (self->fast_memo == NULL) { + self->fast_memo = PyDict_New(); + if (self->fast_memo == NULL) { + self->fast_container = -1; + return 0; + } + } + key = PyLong_FromVoidPtr(obj); + if (key == NULL) + return 0; + if (PyDict_GetItem(self->fast_memo, key)) { + PyErr_Format(PyExc_ValueError, + "fast mode: can't pickle cyclic objects including object type %s at %p", + obj->ob_type->tp_name, obj); + self->fast_container = -1; + return 0; + } + if (PyDict_SetItem(self->fast_memo, key, Py_None) < 0) { + self->fast_container = -1; + return 0; + } } - } - return 1; + return 1; } int fast_save_leave(Picklerobject *self, PyObject *obj) { - if (self->fast_container-- >= PY_CPICKLE_FAST_LIMIT) { - PyObject *key = PyLong_FromVoidPtr(obj); - if (key == NULL) - return 0; - if (PyDict_DelItem(self->fast_memo, key) < 0) { - return 0; + if (self->fast_container-- >= PY_CPICKLE_FAST_LIMIT) { + PyObject *key = PyLong_FromVoidPtr(obj); + if (key == NULL) + return 0; + if (PyDict_DelItem(self->fast_memo, key) < 0) { + return 0; + } } - } - return 1; + return 1; } static int -save_none(Picklerobject *self, PyObject *args) { - static char none = NONE; - if ((*self->write_func)(self, &none, 1) < 0) - return -1; +save_none(Picklerobject *self, PyObject *args) +{ + static char none = NONE; + if ((*self->write_func)(self, &none, 1) < 0) + return -1; - return 0; + return 0; } static int -save_int(Picklerobject *self, PyObject *args) { - char c_str[32]; - long l = PyInt_AS_LONG((PyIntObject *)args); - int len = 0; +save_int(Picklerobject *self, PyObject *args) +{ + char c_str[32]; + long l = PyInt_AS_LONG((PyIntObject *)args); + int len = 0; - if (!self->bin + if (!self->bin #if SIZEOF_LONG > 4 - || l > 0x7fffffffL - || l < -0x80000000L + || l > 0x7fffffffL + || l < -0x80000000L #endif - ) { - /* Text-mode pickle, or long too big to fit in the 4-byte - * signed BININT format: store as a string. - */ - c_str[0] = INT; - PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%ld\n", l); - if ((*self->write_func)(self, c_str, strlen(c_str)) < 0) - return -1; - } - else { - /* Binary pickle and l fits in a signed 4-byte int. */ - c_str[1] = (int)( l & 0xff); - c_str[2] = (int)((l >> 8) & 0xff); - c_str[3] = (int)((l >> 16) & 0xff); - c_str[4] = (int)((l >> 24) & 0xff); - - if ((c_str[4] == 0) && (c_str[3] == 0)) { - if (c_str[2] == 0) { - c_str[0] = BININT1; - len = 2; - } - else { - c_str[0] = BININT2; - len = 3; - } - } - else { - c_str[0] = BININT; - len = 5; - } - - if ((*self->write_func)(self, c_str, len) < 0) - return -1; - } - - return 0; + ) { + /* Text-mode pickle, or long too big to fit in the 4-byte + * signed BININT format: store as a string. + */ + c_str[0] = INT; + PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%ld\n", l); + if ((*self->write_func)(self, c_str, strlen(c_str)) < 0) + return -1; + } + else { + /* Binary pickle and l fits in a signed 4-byte int. */ + c_str[1] = (int)( l & 0xff); + c_str[2] = (int)((l >> 8) & 0xff); + c_str[3] = (int)((l >> 16) & 0xff); + c_str[4] = (int)((l >> 24) & 0xff); + + if ((c_str[4] == 0) && (c_str[3] == 0)) { + if (c_str[2] == 0) { + c_str[0] = BININT1; + len = 2; + } + else { + c_str[0] = BININT2; + len = 3; + } + } + else { + c_str[0] = BININT; + len = 5; + } + + if ((*self->write_func)(self, c_str, len) < 0) + return -1; + } + + return 0; } static int -save_long(Picklerobject *self, PyObject *args) { - int size, res = -1; - PyObject *repr = 0; - - static char l = LONG; - - if (!( repr = PyObject_Repr(args))) - goto finally; +save_long(Picklerobject *self, PyObject *args) +{ + int size, res = -1; + PyObject *repr = 0; - if ((size = PyString_Size(repr)) < 0) - goto finally; + static char l = LONG; - if ((*self->write_func)(self, &l, 1) < 0) - goto finally; + if (!( repr = PyObject_Repr(args))) + goto finally; - if ((*self->write_func)(self, - PyString_AS_STRING((PyStringObject *)repr), size) < 0) - goto finally; + if ((size = PyString_Size(repr)) < 0) + goto finally; - if ((*self->write_func)(self, "\n", 1) < 0) - goto finally; + if ((*self->write_func)(self, &l, 1) < 0) + goto finally; - res = 0; + if ((*self->write_func)(self, + PyString_AS_STRING((PyStringObject *)repr), + size) < 0) + goto finally; -finally: - Py_XDECREF(repr); + if ((*self->write_func)(self, "\n", 1) < 0) + goto finally; - return res; -} + res = 0; + finally: + Py_XDECREF(repr); -static int -save_float(Picklerobject *self, PyObject *args) { - double x = PyFloat_AS_DOUBLE((PyFloatObject *)args); - - if (self->bin) { - int s, e; - double f; - long fhi, flo; - char str[9]; - unsigned char *p = (unsigned char *)str; - - *p = BINFLOAT; - p++; - - if (x < 0) { - s = 1; - x = -x; - } - else - s = 0; - - f = frexp(x, &e); - - /* Normalize f to be in the range [1.0, 2.0) */ - if (0.5 <= f && f < 1.0) { - f *= 2.0; - e--; - } - else if (f == 0.0) { - e = 0; - } - else { - PyErr_SetString(PyExc_SystemError, - "frexp() result out of range"); - return -1; - } - - if (e >= 1024) { - /* XXX 1024 itself is reserved for Inf/NaN */ - PyErr_SetString(PyExc_OverflowError, - "float too large to pack with d format"); - return -1; - } - else if (e < -1022) { - /* Gradual underflow */ - f = ldexp(f, 1022 + e); - e = 0; - } - else if (!(e == 0 && f == 0.0)) { - e += 1023; - f -= 1.0; /* Get rid of leading 1 */ - } - - /* fhi receives the high 28 bits; flo the low 24 bits (== 52 bits) */ - f *= 268435456.0; /* 2**28 */ - fhi = (long) floor(f); /* Truncate */ - f -= (double)fhi; - f *= 16777216.0; /* 2**24 */ - flo = (long) floor(f + 0.5); /* Round */ - - /* First byte */ - *p = (s<<7) | (e>>4); - p++; - - /* Second byte */ - *p = (unsigned char) (((e&0xF)<<4) | (fhi>>24)); - p++; - - /* Third byte */ - *p = (unsigned char) ((fhi>>16) & 0xFF); - p++; - - /* Fourth byte */ - *p = (unsigned char) ((fhi>>8) & 0xFF); - p++; - - /* Fifth byte */ - *p = (unsigned char) (fhi & 0xFF); - p++; - - /* Sixth byte */ - *p = (unsigned char) ((flo>>16) & 0xFF); - p++; - - /* Seventh byte */ - *p = (unsigned char) ((flo>>8) & 0xFF); - p++; - - /* Eighth byte */ - *p = (unsigned char) (flo & 0xFF); - - if ((*self->write_func)(self, str, 9) < 0) - return -1; - } - else { - char c_str[250]; - c_str[0] = FLOAT; - PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%.17g\n", x); - - if ((*self->write_func)(self, c_str, strlen(c_str)) < 0) - return -1; - } - - return 0; + return res; } static int -save_string(Picklerobject *self, PyObject *args, int doput) { - int size, len; - PyObject *repr=0; +save_float(Picklerobject *self, PyObject *args) +{ + double x = PyFloat_AS_DOUBLE((PyFloatObject *)args); + + if (self->bin) { + int s, e; + double f; + long fhi, flo; + char str[9]; + unsigned char *p = (unsigned char *)str; + + *p = BINFLOAT; + p++; + + if (x < 0) { + s = 1; + x = -x; + } + else + s = 0; + + f = frexp(x, &e); + + /* Normalize f to be in the range [1.0, 2.0) */ + if (0.5 <= f && f < 1.0) { + f *= 2.0; + e--; + } + else if (f == 0.0) { + e = 0; + } + else { + PyErr_SetString(PyExc_SystemError, + "frexp() result out of range"); + return -1; + } + + if (e >= 1024) { + /* XXX 1024 itself is reserved for Inf/NaN */ + PyErr_SetString(PyExc_OverflowError, + "float too large to pack with d format"); + return -1; + } + else if (e < -1022) { + /* Gradual underflow */ + f = ldexp(f, 1022 + e); + e = 0; + } + else if (!(e == 0 && f == 0.0)) { + e += 1023; + f -= 1.0; /* Get rid of leading 1 */ + } + + /* fhi receives the high 28 bits; + flo the low 24 bits (== 52 bits) */ + f *= 268435456.0; /* 2**28 */ + fhi = (long) floor(f); /* Truncate */ + f -= (double)fhi; + f *= 16777216.0; /* 2**24 */ + flo = (long) floor(f + 0.5); /* Round */ + + /* First byte */ + *p = (s<<7) | (e>>4); + p++; + + /* Second byte */ + *p = (unsigned char) (((e&0xF)<<4) | (fhi>>24)); + p++; + + /* Third byte */ + *p = (unsigned char) ((fhi>>16) & 0xFF); + p++; + + /* Fourth byte */ + *p = (unsigned char) ((fhi>>8) & 0xFF); + p++; + + /* Fifth byte */ + *p = (unsigned char) (fhi & 0xFF); + p++; + + /* Sixth byte */ + *p = (unsigned char) ((flo>>16) & 0xFF); + p++; + + /* Seventh byte */ + *p = (unsigned char) ((flo>>8) & 0xFF); + p++; + + /* Eighth byte */ + *p = (unsigned char) (flo & 0xFF); + + if ((*self->write_func)(self, str, 9) < 0) + return -1; + } + else { + char c_str[250]; + c_str[0] = FLOAT; + PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%.17g\n", x); - if ((size = PyString_Size(args)) < 0) - return -1; + if ((*self->write_func)(self, c_str, strlen(c_str)) < 0) + return -1; + } - if (!self->bin) { - char *repr_str; + return 0; +} - static char string = STRING; - if (!( repr = PyObject_Repr(args))) - return -1; +static int +save_string(Picklerobject *self, PyObject *args, int doput) +{ + int size, len; + PyObject *repr=0; - if ((len = PyString_Size(repr)) < 0) - goto err; - repr_str = PyString_AS_STRING((PyStringObject *)repr); + if ((size = PyString_Size(args)) < 0) + return -1; - if ((*self->write_func)(self, &string, 1) < 0) - goto err; + if (!self->bin) { + char *repr_str; - if ((*self->write_func)(self, repr_str, len) < 0) - goto err; + static char string = STRING; - if ((*self->write_func)(self, "\n", 1) < 0) - goto err; + if (!( repr = PyObject_Repr(args))) + return -1; - Py_XDECREF(repr); - } - else { - int i; - char c_str[5]; + if ((len = PyString_Size(repr)) < 0) + goto err; + repr_str = PyString_AS_STRING((PyStringObject *)repr); - if ((size = PyString_Size(args)) < 0) - return -1; + if ((*self->write_func)(self, &string, 1) < 0) + goto err; - if (size < 256) { - c_str[0] = SHORT_BINSTRING; - c_str[1] = size; - len = 2; - } - else { - c_str[0] = BINSTRING; - for (i = 1; i < 5; i++) - c_str[i] = (int)(size >> ((i - 1) * 8)); - len = 5; - } + if ((*self->write_func)(self, repr_str, len) < 0) + goto err; - if ((*self->write_func)(self, c_str, len) < 0) - return -1; + if ((*self->write_func)(self, "\n", 1) < 0) + goto err; - if (size > 128 && Pdata_Check(self->file)) { - if (write_other(self, NULL, 0) < 0) return -1; - PDATA_APPEND(self->file, args, -1); - } - else { - if ((*self->write_func)(self, - PyString_AS_STRING((PyStringObject *)args), size) < 0) - return -1; - } - } + Py_XDECREF(repr); + } + else { + int i; + char c_str[5]; + + if ((size = PyString_Size(args)) < 0) + return -1; + + if (size < 256) { + c_str[0] = SHORT_BINSTRING; + c_str[1] = size; + len = 2; + } + else { + c_str[0] = BINSTRING; + for (i = 1; i < 5; i++) + c_str[i] = (int)(size >> ((i - 1) * 8)); + len = 5; + } + + if ((*self->write_func)(self, c_str, len) < 0) + return -1; + + if (size > 128 && Pdata_Check(self->file)) { + if (write_other(self, NULL, 0) < 0) return -1; + PDATA_APPEND(self->file, args, -1); + } + else { + if ((*self->write_func)(self, + PyString_AS_STRING((PyStringObject *)args), size) < 0) + return -1; + } + } - if (doput) - if (put(self, args) < 0) - return -1; + if (doput) + if (put(self, args) < 0) + return -1; - return 0; + return 0; -err: - Py_XDECREF(repr); - return -1; + err: + Py_XDECREF(repr); + return -1; } @@ -1215,1050 +1256,1071 @@ err: static PyObject * modified_EncodeRawUnicodeEscape(const Py_UNICODE *s, int size) { - PyObject *repr; - char *p; - char *q; - - static const char *hexdigit = "0123456789ABCDEF"; + PyObject *repr; + char *p; + char *q; + + static const char *hexdigit = "0123456789ABCDEF"; + + repr = PyString_FromStringAndSize(NULL, 6 * size); + if (repr == NULL) + return NULL; + if (size == 0) + return repr; + + p = q = PyString_AS_STRING(repr); + while (size-- > 0) { + Py_UNICODE ch = *s++; + /* Map 16-bit characters to '\uxxxx' */ + if (ch >= 256 || ch == '\\' || ch == '\n') { + *p++ = '\\'; + *p++ = 'u'; + *p++ = hexdigit[(ch >> 12) & 0xf]; + *p++ = hexdigit[(ch >> 8) & 0xf]; + *p++ = hexdigit[(ch >> 4) & 0xf]; + *p++ = hexdigit[ch & 15]; + } + /* Copy everything else as-is */ + else + *p++ = (char) ch; + } + *p = '\0'; + if (_PyString_Resize(&repr, p - q)) + goto onError; - repr = PyString_FromStringAndSize(NULL, 6 * size); - if (repr == NULL) - return NULL; - if (size == 0) return repr; - p = q = PyString_AS_STRING(repr); - while (size-- > 0) { - Py_UNICODE ch = *s++; - /* Map 16-bit characters to '\uxxxx' */ - if (ch >= 256 || ch == '\\' || ch == '\n') { - *p++ = '\\'; - *p++ = 'u'; - *p++ = hexdigit[(ch >> 12) & 0xf]; - *p++ = hexdigit[(ch >> 8) & 0xf]; - *p++ = hexdigit[(ch >> 4) & 0xf]; - *p++ = hexdigit[ch & 15]; - } - /* Copy everything else as-is */ - else - *p++ = (char) ch; - } - *p = '\0'; - if (_PyString_Resize(&repr, p - q)) - goto onError; - - return repr; - - onError: - Py_DECREF(repr); - return NULL; + onError: + Py_DECREF(repr); + return NULL; } static int -save_unicode(Picklerobject *self, PyObject *args, int doput) { - int size, len; - PyObject *repr=0; - - if (!PyUnicode_Check(args)) - return -1; - - if (!self->bin) { - char *repr_str; - static char string = UNICODE; - - if (!( repr = modified_EncodeRawUnicodeEscape( - PyUnicode_AS_UNICODE(args), PyUnicode_GET_SIZE(args)))) - return -1; - - if ((len = PyString_Size(repr)) < 0) - goto err; - repr_str = PyString_AS_STRING((PyStringObject *)repr); - - if ((*self->write_func)(self, &string, 1) < 0) - goto err; - - if ((*self->write_func)(self, repr_str, len) < 0) - goto err; +save_unicode(Picklerobject *self, PyObject *args, int doput) +{ + int size, len; + PyObject *repr=0; - if ((*self->write_func)(self, "\n", 1) < 0) - goto err; + if (!PyUnicode_Check(args)) + return -1; - Py_XDECREF(repr); - } - else { - int i; - char c_str[5]; + if (!self->bin) { + char *repr_str; + static char string = UNICODE; - if (!( repr = PyUnicode_AsUTF8String(args))) - return -1; + repr = modified_EncodeRawUnicodeEscape( + PyUnicode_AS_UNICODE(args), PyUnicode_GET_SIZE(args)); + if (!repr) + return -1; - if ((size = PyString_Size(repr)) < 0) - goto err; + if ((len = PyString_Size(repr)) < 0) + goto err; + repr_str = PyString_AS_STRING((PyStringObject *)repr); - c_str[0] = BINUNICODE; - for (i = 1; i < 5; i++) - c_str[i] = (int)(size >> ((i - 1) * 8)); - len = 5; + if ((*self->write_func)(self, &string, 1) < 0) + goto err; - if ((*self->write_func)(self, c_str, len) < 0) - goto err; + if ((*self->write_func)(self, repr_str, len) < 0) + goto err; - if (size > 128 && Pdata_Check(self->file)) { - if (write_other(self, NULL, 0) < 0) - goto err; - PDATA_APPEND(self->file, repr, -1); - } - else { - if ((*self->write_func)(self, PyString_AS_STRING(repr), size) < 0) - goto err; - } + if ((*self->write_func)(self, "\n", 1) < 0) + goto err; - Py_DECREF(repr); - } + Py_XDECREF(repr); + } + else { + int i; + char c_str[5]; + + if (!( repr = PyUnicode_AsUTF8String(args))) + return -1; + + if ((size = PyString_Size(repr)) < 0) + goto err; + + c_str[0] = BINUNICODE; + for (i = 1; i < 5; i++) + c_str[i] = (int)(size >> ((i - 1) * 8)); + len = 5; + + if ((*self->write_func)(self, c_str, len) < 0) + goto err; + + if (size > 128 && Pdata_Check(self->file)) { + if (write_other(self, NULL, 0) < 0) + goto err; + PDATA_APPEND(self->file, repr, -1); + } + else { + if ((*self->write_func)(self, PyString_AS_STRING(repr), + size) < 0) + goto err; + } + + Py_DECREF(repr); + } - if (doput) - if (put(self, args) < 0) - return -1; + if (doput) + if (put(self, args) < 0) + return -1; - return 0; + return 0; -err: - Py_XDECREF(repr); - return -1; + err: + Py_XDECREF(repr); + return -1; } #endif static int -save_tuple(Picklerobject *self, PyObject *args) { - PyObject *element = 0, *py_tuple_id = 0; - int len, i, res = -1; - - static char tuple = TUPLE; - - if ((*self->write_func)(self, &MARKv, 1) < 0) - goto finally; - - if ((len = PyTuple_Size(args)) < 0) - goto finally; - - for (i = 0; i < len; i++) { - if (!( element = PyTuple_GET_ITEM((PyTupleObject *)args, i))) - goto finally; +save_tuple(Picklerobject *self, PyObject *args) +{ + PyObject *element = 0, *py_tuple_id = 0; + int len, i, res = -1; - if (save(self, element, 0) < 0) - goto finally; - } + static char tuple = TUPLE; - if (!( py_tuple_id = PyLong_FromVoidPtr(args))) - goto finally; + if ((*self->write_func)(self, &MARKv, 1) < 0) + goto finally; - if (len) { - if (PyDict_GetItem(self->memo, py_tuple_id)) { - if (self->bin) { - static char pop_mark = POP_MARK; + if ((len = PyTuple_Size(args)) < 0) + goto finally; - if ((*self->write_func)(self, &pop_mark, 1) < 0) - goto finally; - } - else { - static char pop = POP; + for (i = 0; i < len; i++) { + if (!( element = PyTuple_GET_ITEM((PyTupleObject *)args, i))) + goto finally; - for (i = 0; i <= len; i++) { - if ((*self->write_func)(self, &pop, 1) < 0) - goto finally; - } - } + if (save(self, element, 0) < 0) + goto finally; + } - if (get(self, py_tuple_id) < 0) - goto finally; + if (!( py_tuple_id = PyLong_FromVoidPtr(args))) + goto finally; - res = 0; - goto finally; - } - } + if (len) { + if (PyDict_GetItem(self->memo, py_tuple_id)) { + if (self->bin) { + static char pop_mark = POP_MARK; + + if ((*self->write_func)(self, &pop_mark, 1) < 0) + goto finally; + } + else { + static char pop = POP; + + for (i = 0; i <= len; i++) { + if ((*self->write_func)(self, &pop, 1) < 0) + goto finally; + } + } + + if (get(self, py_tuple_id) < 0) + goto finally; + + res = 0; + goto finally; + } + } - if ((*self->write_func)(self, &tuple, 1) < 0) { - goto finally; - } + if ((*self->write_func)(self, &tuple, 1) < 0) { + goto finally; + } - if (put(self, args) < 0) - goto finally; + if (put(self, args) < 0) + goto finally; - res = 0; + res = 0; -finally: - Py_XDECREF(py_tuple_id); + finally: + Py_XDECREF(py_tuple_id); - return res; + return res; } static int -save_empty_tuple(Picklerobject *self, PyObject *args) { - static char tuple = EMPTY_TUPLE; +save_empty_tuple(Picklerobject *self, PyObject *args) +{ + static char tuple = EMPTY_TUPLE; - return (*self->write_func)(self, &tuple, 1); + return (*self->write_func)(self, &tuple, 1); } static int -save_list(Picklerobject *self, PyObject *args) { - PyObject *element = 0; - int s_len, len, i, using_appends, res = -1; - char s[3]; +save_list(Picklerobject *self, PyObject *args) +{ + PyObject *element = 0; + int s_len, len, i, using_appends, res = -1; + char s[3]; - static char append = APPEND, appends = APPENDS; + static char append = APPEND, appends = APPENDS; - if (self->fast && !fast_save_enter(self, args)) - goto finally; + if (self->fast && !fast_save_enter(self, args)) + goto finally; - if (self->bin) { - s[0] = EMPTY_LIST; - s_len = 1; - } - else { - s[0] = MARK; - s[1] = LIST; - s_len = 2; - } + if (self->bin) { + s[0] = EMPTY_LIST; + s_len = 1; + } + else { + s[0] = MARK; + s[1] = LIST; + s_len = 2; + } - if ((len = PyList_Size(args)) < 0) - goto finally; + if ((len = PyList_Size(args)) < 0) + goto finally; - if ((*self->write_func)(self, s, s_len) < 0) - goto finally; + if ((*self->write_func)(self, s, s_len) < 0) + goto finally; - if (len == 0) { - if (put(self, args) < 0) - goto finally; - } - else { - if (put2(self, args) < 0) - goto finally; - } + if (len == 0) { + if (put(self, args) < 0) + goto finally; + } + else { + if (put2(self, args) < 0) + goto finally; + } - if ((using_appends = (self->bin && (len > 1)))) - if ((*self->write_func)(self, &MARKv, 1) < 0) - goto finally; + if ((using_appends = (self->bin && (len > 1)))) + if ((*self->write_func)(self, &MARKv, 1) < 0) + goto finally; - for (i = 0; i < len; i++) { - if (!( element = PyList_GET_ITEM((PyListObject *)args, i))) - goto finally; + for (i = 0; i < len; i++) { + if (!( element = PyList_GET_ITEM((PyListObject *)args, i))) + goto finally; - if (save(self, element, 0) < 0) - goto finally; + if (save(self, element, 0) < 0) + goto finally; - if (!using_appends) { - if ((*self->write_func)(self, &append, 1) < 0) - goto finally; - } - } + if (!using_appends) { + if ((*self->write_func)(self, &append, 1) < 0) + goto finally; + } + } - if (using_appends) { - if ((*self->write_func)(self, &appends, 1) < 0) - goto finally; - } + if (using_appends) { + if ((*self->write_func)(self, &appends, 1) < 0) + goto finally; + } - res = 0; + res = 0; -finally: - if (self->fast && !fast_save_leave(self, args)) - res = -1; + finally: + if (self->fast && !fast_save_leave(self, args)) + res = -1; - return res; + return res; } static int -save_dict(Picklerobject *self, PyObject *args) { - PyObject *key = 0, *value = 0; - int i, len, res = -1, using_setitems; - char s[3]; +save_dict(Picklerobject *self, PyObject *args) +{ + PyObject *key = 0, *value = 0; + int i, len, res = -1, using_setitems; + char s[3]; - static char setitem = SETITEM, setitems = SETITEMS; + static char setitem = SETITEM, setitems = SETITEMS; - if (self->fast && !fast_save_enter(self, args)) - goto finally; + if (self->fast && !fast_save_enter(self, args)) + goto finally; - if (self->bin) { - s[0] = EMPTY_DICT; - len = 1; - } - else { - s[0] = MARK; - s[1] = DICT; - len = 2; - } + if (self->bin) { + s[0] = EMPTY_DICT; + len = 1; + } + else { + s[0] = MARK; + s[1] = DICT; + len = 2; + } - if ((*self->write_func)(self, s, len) < 0) - goto finally; + if ((*self->write_func)(self, s, len) < 0) + goto finally; - if ((len = PyDict_Size(args)) < 0) - goto finally; + if ((len = PyDict_Size(args)) < 0) + goto finally; - if (len == 0) { - if (put(self, args) < 0) - goto finally; - } - else { - if (put2(self, args) < 0) - goto finally; - } + if (len == 0) { + if (put(self, args) < 0) + goto finally; + } + else { + if (put2(self, args) < 0) + goto finally; + } - if ((using_setitems = (self->bin && (PyDict_Size(args) > 1)))) - if ((*self->write_func)(self, &MARKv, 1) < 0) - goto finally; + if ((using_setitems = (self->bin && (PyDict_Size(args) > 1)))) + if ((*self->write_func)(self, &MARKv, 1) < 0) + goto finally; - i = 0; - while (PyDict_Next(args, &i, &key, &value)) { - if (save(self, key, 0) < 0) - goto finally; + i = 0; + while (PyDict_Next(args, &i, &key, &value)) { + if (save(self, key, 0) < 0) + goto finally; - if (save(self, value, 0) < 0) - goto finally; + if (save(self, value, 0) < 0) + goto finally; - if (!using_setitems) { - if ((*self->write_func)(self, &setitem, 1) < 0) - goto finally; - } - } + if (!using_setitems) { + if ((*self->write_func)(self, &setitem, 1) < 0) + goto finally; + } + } - if (using_setitems) { - if ((*self->write_func)(self, &setitems, 1) < 0) - goto finally; - } + if (using_setitems) { + if ((*self->write_func)(self, &setitems, 1) < 0) + goto finally; + } - res = 0; + res = 0; -finally: - if (self->fast && !fast_save_leave(self, args)) - res = -1; + finally: + if (self->fast && !fast_save_leave(self, args)) + res = -1; - return res; + return res; } static int -save_inst(Picklerobject *self, PyObject *args) { - PyObject *class = 0, *module = 0, *name = 0, *state = 0, - *getinitargs_func = 0, *getstate_func = 0, *class_args = 0; - char *module_str, *name_str; - int module_size, name_size, res = -1; - - static char inst = INST, obj = OBJ, build = BUILD; - - if (self->fast && !fast_save_enter(self, args)) - goto finally; - - if ((*self->write_func)(self, &MARKv, 1) < 0) - goto finally; - - if (!( class = PyObject_GetAttr(args, __class___str))) - goto finally; - - if (self->bin) { - if (save(self, class, 0) < 0) - goto finally; - } - - if ((getinitargs_func = PyObject_GetAttr(args, __getinitargs___str))) { - PyObject *element = 0; - int i, len; - - if (!( class_args = - PyObject_Call(getinitargs_func, empty_tuple, NULL))) - goto finally; +save_inst(Picklerobject *self, PyObject *args) +{ + PyObject *class = 0, *module = 0, *name = 0, *state = 0, + *getinitargs_func = 0, *getstate_func = 0, *class_args = 0; + char *module_str, *name_str; + int module_size, name_size, res = -1; - if ((len = PyObject_Size(class_args)) < 0) - goto finally; + static char inst = INST, obj = OBJ, build = BUILD; - for (i = 0; i < len; i++) { - if (!( element = PySequence_GetItem(class_args, i))) - goto finally; + if (self->fast && !fast_save_enter(self, args)) + goto finally; - if (save(self, element, 0) < 0) { - Py_DECREF(element); - goto finally; - } + if ((*self->write_func)(self, &MARKv, 1) < 0) + goto finally; - Py_DECREF(element); - } - } - else { - PyErr_Clear(); - } + if (!( class = PyObject_GetAttr(args, __class___str))) + goto finally; - if (!self->bin) { - if (!( name = ((PyClassObject *)class)->cl_name )) { - PyErr_SetString(PicklingError, "class has no name"); - goto finally; - } + if (self->bin) { + if (save(self, class, 0) < 0) + goto finally; + } - if (!( module = whichmodule(class, name))) - goto finally; + if ((getinitargs_func = PyObject_GetAttr(args, __getinitargs___str))) { + PyObject *element = 0; + int i, len; + if (!( class_args = + PyObject_Call(getinitargs_func, empty_tuple, NULL))) + goto finally; - if ((module_size = PyString_Size(module)) < 0 || - (name_size = PyString_Size(name)) < 0) - goto finally; + if ((len = PyObject_Size(class_args)) < 0) + goto finally; - module_str = PyString_AS_STRING((PyStringObject *)module); - name_str = PyString_AS_STRING((PyStringObject *)name); + for (i = 0; i < len; i++) { + if (!( element = PySequence_GetItem(class_args, i))) + goto finally; - if ((*self->write_func)(self, &inst, 1) < 0) - goto finally; + if (save(self, element, 0) < 0) { + Py_DECREF(element); + goto finally; + } - if ((*self->write_func)(self, module_str, module_size) < 0) - goto finally; + Py_DECREF(element); + } + } + else { + PyErr_Clear(); + } - if ((*self->write_func)(self, "\n", 1) < 0) - goto finally; + if (!self->bin) { + if (!( name = ((PyClassObject *)class)->cl_name )) { + PyErr_SetString(PicklingError, "class has no name"); + goto finally; + } - if ((*self->write_func)(self, name_str, name_size) < 0) - goto finally; + if (!( module = whichmodule(class, name))) + goto finally; - if ((*self->write_func)(self, "\n", 1) < 0) - goto finally; - } - else if ((*self->write_func)(self, &obj, 1) < 0) { - goto finally; - } - if ((getstate_func = PyObject_GetAttr(args, __getstate___str))) { - if (!( state = PyObject_Call(getstate_func, empty_tuple, NULL))) - goto finally; - } - else { - PyErr_Clear(); + if ((module_size = PyString_Size(module)) < 0 || + (name_size = PyString_Size(name)) < 0) + goto finally; - if (!( state = PyObject_GetAttr(args, __dict___str))) { - PyErr_Clear(); - res = 0; - goto finally; - } - } + module_str = PyString_AS_STRING((PyStringObject *)module); + name_str = PyString_AS_STRING((PyStringObject *)name); - if (!PyDict_Check(state)) { - if (put2(self, args) < 0) - goto finally; - } - else { - if (put(self, args) < 0) - goto finally; - } + if ((*self->write_func)(self, &inst, 1) < 0) + goto finally; - if (save(self, state, 0) < 0) - goto finally; + if ((*self->write_func)(self, module_str, module_size) < 0) + goto finally; - if ((*self->write_func)(self, &build, 1) < 0) - goto finally; + if ((*self->write_func)(self, "\n", 1) < 0) + goto finally; - res = 0; + if ((*self->write_func)(self, name_str, name_size) < 0) + goto finally; -finally: - if (self->fast && !fast_save_leave(self, args)) - res = -1; + if ((*self->write_func)(self, "\n", 1) < 0) + goto finally; + } + else if ((*self->write_func)(self, &obj, 1) < 0) { + goto finally; + } - Py_XDECREF(module); - Py_XDECREF(class); - Py_XDECREF(state); - Py_XDECREF(getinitargs_func); - Py_XDECREF(getstate_func); - Py_XDECREF(class_args); + if ((getstate_func = PyObject_GetAttr(args, __getstate___str))) { + state = PyObject_Call(getstate_func, empty_tuple, NULL); + if (!state) + goto finally; + } + else { + PyErr_Clear(); + + if (!( state = PyObject_GetAttr(args, __dict___str))) { + PyErr_Clear(); + res = 0; + goto finally; + } + } - return res; -} + if (!PyDict_Check(state)) { + if (put2(self, args) < 0) + goto finally; + } + else { + if (put(self, args) < 0) + goto finally; + } + if (save(self, state, 0) < 0) + goto finally; -static int -save_global(Picklerobject *self, PyObject *args, PyObject *name) { - PyObject *global_name = 0, *module = 0, *mod = 0, *moddict = 0, *klass = 0; - char *name_str, *module_str; - int module_size, name_size, res = -1; - - static char global = GLOBAL; - - if (name) { - global_name = name; - Py_INCREF(global_name); - } - else { - if (!( global_name = PyObject_GetAttr(args, __name___str))) - goto finally; - } - - if (!( module = whichmodule(args, global_name))) - goto finally; - - if ((module_size = PyString_Size(module)) < 0 || - (name_size = PyString_Size(global_name)) < 0) - goto finally; - - module_str = PyString_AS_STRING((PyStringObject *)module); - name_str = PyString_AS_STRING((PyStringObject *)global_name); - - mod = PyImport_ImportModule(module_str); - if (mod == NULL) { - /* Py_ErrClear(); ?? */ - cPickle_ErrFormat(PicklingError, - "Can't pickle %s: it's not found as %s.%s", - "OSS", args, module, global_name); - goto finally; - } - moddict = PyModule_GetDict(mod); /* borrowed ref */ - klass = PyDict_GetItemString(moddict, name_str); /* borrowed ref */ - if (klass == NULL) { - cPickle_ErrFormat(PicklingError, - "Can't pickle %s: it's not found as %s.%s", - "OSS", args, module, global_name); - goto finally; - } - if (klass != args) { - cPickle_ErrFormat(PicklingError, - "Can't pickle %s: it's not the same object as %s.%s", - "OSS", args, module, global_name); - goto finally; - } - - if ((*self->write_func)(self, &global, 1) < 0) - goto finally; - - if ((*self->write_func)(self, module_str, module_size) < 0) - goto finally; - - if ((*self->write_func)(self, "\n", 1) < 0) - goto finally; - - if ((*self->write_func)(self, name_str, name_size) < 0) - goto finally; - - if ((*self->write_func)(self, "\n", 1) < 0) - goto finally; - - if (put(self, args) < 0) - goto finally; - - res = 0; - -finally: - Py_XDECREF(module); - Py_XDECREF(global_name); - Py_XDECREF(mod); - - return res; + if ((*self->write_func)(self, &build, 1) < 0) + goto finally; + + res = 0; + + finally: + if (self->fast && !fast_save_leave(self, args)) + res = -1; + + Py_XDECREF(module); + Py_XDECREF(class); + Py_XDECREF(state); + Py_XDECREF(getinitargs_func); + Py_XDECREF(getstate_func); + Py_XDECREF(class_args); + + return res; } + static int -save_pers(Picklerobject *self, PyObject *args, PyObject *f) { - PyObject *pid = 0; - int size, res = -1; +save_global(Picklerobject *self, PyObject *args, PyObject *name) +{ + PyObject *global_name = 0, *module = 0, *mod = 0, *moddict = 0, *klass = 0; + char *name_str, *module_str; + int module_size, name_size, res = -1; - static char persid = PERSID, binpersid = BINPERSID; + static char global = GLOBAL; - Py_INCREF(args); - ARG_TUP(self, args); - if (self->arg) { - pid = PyObject_Call(f, self->arg, NULL); - FREE_ARG_TUP(self); - } - if (! pid) return -1; + if (name) { + global_name = name; + Py_INCREF(global_name); + } + else { + if (!( global_name = PyObject_GetAttr(args, __name___str))) + goto finally; + } + + if (!( module = whichmodule(args, global_name))) + goto finally; - if (pid != Py_None) { - if (!self->bin) { - if (!PyString_Check(pid)) { - PyErr_SetString(PicklingError, - "persistent id must be string"); - goto finally; - } + if ((module_size = PyString_Size(module)) < 0 || + (name_size = PyString_Size(global_name)) < 0) + goto finally; + + module_str = PyString_AS_STRING((PyStringObject *)module); + name_str = PyString_AS_STRING((PyStringObject *)global_name); + + mod = PyImport_ImportModule(module_str); + if (mod == NULL) { + /* Py_ErrClear(); ?? */ + cPickle_ErrFormat(PicklingError, + "Can't pickle %s: it's not found as %s.%s", + "OSS", args, module, global_name); + goto finally; + } + /* borrowed ref */ + moddict = PyModule_GetDict(mod); + /* borrowed ref */ + klass = PyDict_GetItemString(moddict, name_str); + if (klass == NULL) { + cPickle_ErrFormat(PicklingError, + "Can't pickle %s: it's not found as %s.%s", + "OSS", args, module, global_name); + goto finally; + } + if (klass != args) { + cPickle_ErrFormat(PicklingError, + "Can't pickle %s: it's not the same object as %s.%s", + "OSS", args, module, global_name); + goto finally; + } - if ((*self->write_func)(self, &persid, 1) < 0) - goto finally; + if ((*self->write_func)(self, &global, 1) < 0) + goto finally; - if ((size = PyString_Size(pid)) < 0) - goto finally; + if ((*self->write_func)(self, module_str, module_size) < 0) + goto finally; - if ((*self->write_func)(self, - PyString_AS_STRING((PyStringObject *)pid), size) < 0) - goto finally; + if ((*self->write_func)(self, "\n", 1) < 0) + goto finally; - if ((*self->write_func)(self, "\n", 1) < 0) - goto finally; + if ((*self->write_func)(self, name_str, name_size) < 0) + goto finally; - res = 1; - goto finally; - } - else if (save(self, pid, 1) >= 0) { - if ((*self->write_func)(self, &binpersid, 1) < 0) - res = -1; - else - res = 1; - } + if ((*self->write_func)(self, "\n", 1) < 0) + goto finally; - goto finally; - } + if (put(self, args) < 0) + goto finally; - res = 0; + res = 0; -finally: - Py_XDECREF(pid); + finally: + Py_XDECREF(module); + Py_XDECREF(global_name); + Py_XDECREF(mod); - return res; + return res; } - static int -save_reduce(Picklerobject *self, PyObject *callable, - PyObject *tup, PyObject *state, PyObject *ob) { - static char reduce = REDUCE, build = BUILD; +save_pers(Picklerobject *self, PyObject *args, PyObject *f) +{ + PyObject *pid = 0; + int size, res = -1; + + static char persid = PERSID, binpersid = BINPERSID; - if (save(self, callable, 0) < 0) - return -1; + Py_INCREF(args); + ARG_TUP(self, args); + if (self->arg) { + pid = PyObject_Call(f, self->arg, NULL); + FREE_ARG_TUP(self); + } + if (! pid) return -1; + + if (pid != Py_None) { + if (!self->bin) { + if (!PyString_Check(pid)) { + PyErr_SetString(PicklingError, + "persistent id must be string"); + goto finally; + } + + if ((*self->write_func)(self, &persid, 1) < 0) + goto finally; + + if ((size = PyString_Size(pid)) < 0) + goto finally; + + if ((*self->write_func)(self, + PyString_AS_STRING((PyStringObject *)pid), size) < 0) + goto finally; + + if ((*self->write_func)(self, "\n", 1) < 0) + goto finally; + + res = 1; + goto finally; + } + else if (save(self, pid, 1) >= 0) { + if ((*self->write_func)(self, &binpersid, 1) < 0) + res = -1; + else + res = 1; + } - if (save(self, tup, 0) < 0) - return -1; + goto finally; + } - if ((*self->write_func)(self, &reduce, 1) < 0) - return -1; + res = 0; - if (ob != NULL) { - if (state && !PyDict_Check(state)) { - if (put2(self, ob) < 0) - return -1; - } - else { - if (put(self, ob) < 0) - return -1; - } - } + finally: + Py_XDECREF(pid); - if (state) { - if (save(self, state, 0) < 0) - return -1; + return res; +} - if ((*self->write_func)(self, &build, 1) < 0) - return -1; - } - return 0; +static int +save_reduce(Picklerobject *self, PyObject *callable, + PyObject *tup, PyObject *state, PyObject *ob) +{ + static char reduce = REDUCE, build = BUILD; + + if (save(self, callable, 0) < 0) + return -1; + + if (save(self, tup, 0) < 0) + return -1; + + if ((*self->write_func)(self, &reduce, 1) < 0) + return -1; + + if (ob != NULL) { + if (state && !PyDict_Check(state)) { + if (put2(self, ob) < 0) + return -1; + } + else { + if (put(self, ob) < 0) + return -1; + } + } + + if (state) { + if (save(self, state, 0) < 0) + return -1; + + if ((*self->write_func)(self, &build, 1) < 0) + return -1; + } + + return 0; } static int -save(Picklerobject *self, PyObject *args, int pers_save) { - PyTypeObject *type; - PyObject *py_ob_id = 0, *__reduce__ = 0, *t = 0, *arg_tup = 0, - *callable = 0, *state = 0; - int res = -1, tmp, size; - - if (!pers_save && self->pers_func) { - if ((tmp = save_pers(self, args, self->pers_func)) != 0) { - res = tmp; - goto finally; - } - } - - if (args == Py_None) { - res = save_none(self, args); - goto finally; - } - - type = args->ob_type; - - switch (type->tp_name[0]) { +save(Picklerobject *self, PyObject *args, int pers_save) +{ + PyTypeObject *type; + PyObject *py_ob_id = 0, *__reduce__ = 0, *t = 0, *arg_tup = 0, + *callable = 0, *state = 0; + int res = -1, tmp, size; + + if (!pers_save && self->pers_func) { + if ((tmp = save_pers(self, args, self->pers_func)) != 0) { + res = tmp; + goto finally; + } + } + + if (args == Py_None) { + res = save_none(self, args); + goto finally; + } + + type = args->ob_type; + + switch (type->tp_name[0]) { case 'i': - if (type == &PyInt_Type) { - res = save_int(self, args); - goto finally; - } - break; + if (type == &PyInt_Type) { + res = save_int(self, args); + goto finally; + } + break; case 'l': - if (type == &PyLong_Type) { - res = save_long(self, args); - goto finally; - } - break; + if (type == &PyLong_Type) { + res = save_long(self, args); + goto finally; + } + break; case 'f': - if (type == &PyFloat_Type) { - res = save_float(self, args); - goto finally; - } - break; + if (type == &PyFloat_Type) { + res = save_float(self, args); + goto finally; + } + break; case 't': - if (type == &PyTuple_Type && PyTuple_Size(args)==0) { - if (self->bin) res = save_empty_tuple(self, args); - else res = save_tuple(self, args); - goto finally; - } - break; + if (type == &PyTuple_Type && PyTuple_Size(args)==0) { + if (self->bin) res = save_empty_tuple(self, args); + else res = save_tuple(self, args); + goto finally; + } + break; case 's': - if ((type == &PyString_Type) && (PyString_GET_SIZE(args) < 2)) { - res = save_string(self, args, 0); - goto finally; - } + if ((type == &PyString_Type) && (PyString_GET_SIZE(args) < 2)) { + res = save_string(self, args, 0); + goto finally; + } #ifdef Py_USING_UNICODE case 'u': - if ((type == &PyUnicode_Type) && (PyString_GET_SIZE(args) < 2)) { - res = save_unicode(self, args, 0); - goto finally; - } + if ((type == &PyUnicode_Type) && (PyString_GET_SIZE(args) < 2)) { + res = save_unicode(self, args, 0); + goto finally; + } #endif - } + } - if (args->ob_refcnt > 1) { - if (!( py_ob_id = PyLong_FromVoidPtr(args))) - goto finally; + if (args->ob_refcnt > 1) { + if (!( py_ob_id = PyLong_FromVoidPtr(args))) + goto finally; - if (PyDict_GetItem(self->memo, py_ob_id)) { - if (get(self, py_ob_id) < 0) - goto finally; + if (PyDict_GetItem(self->memo, py_ob_id)) { + if (get(self, py_ob_id) < 0) + goto finally; - res = 0; - goto finally; - } - } + res = 0; + goto finally; + } + } - switch (type->tp_name[0]) { + switch (type->tp_name[0]) { case 's': - if (type == &PyString_Type) { - res = save_string(self, args, 1); - goto finally; - } - break; + if (type == &PyString_Type) { + res = save_string(self, args, 1); + goto finally; + } + break; #ifdef Py_USING_UNICODE case 'u': - if (type == &PyUnicode_Type) { - res = save_unicode(self, args, 1); - goto finally; - } - break; + if (type == &PyUnicode_Type) { + res = save_unicode(self, args, 1); + goto finally; + } + break; #endif case 't': - if (type == &PyTuple_Type) { - res = save_tuple(self, args); - goto finally; - } - if (type == &PyType_Type) { - res = save_global(self, args, NULL); - goto finally; - } - break; + if (type == &PyTuple_Type) { + res = save_tuple(self, args); + goto finally; + } + if (type == &PyType_Type) { + res = save_global(self, args, NULL); + goto finally; + } + break; case 'l': - if (type == &PyList_Type) { - res = save_list(self, args); - goto finally; - } - break; + if (type == &PyList_Type) { + res = save_list(self, args); + goto finally; + } + break; case 'd': - if (type == &PyDict_Type) { - res = save_dict(self, args); - goto finally; - } - break; + if (type == &PyDict_Type) { + res = save_dict(self, args); + goto finally; + } + break; case 'i': - if (type == &PyInstance_Type) { - res = save_inst(self, args); - goto finally; - } - break; + if (type == &PyInstance_Type) { + res = save_inst(self, args); + goto finally; + } + break; case 'c': - if (type == &PyClass_Type) { - res = save_global(self, args, NULL); - goto finally; - } - break; + if (type == &PyClass_Type) { + res = save_global(self, args, NULL); + goto finally; + } + break; case 'f': - if (type == &PyFunction_Type) { - res = save_global(self, args, NULL); - goto finally; - } - break; + if (type == &PyFunction_Type) { + res = save_global(self, args, NULL); + goto finally; + } + break; case 'b': - if (type == &PyCFunction_Type) { - res = save_global(self, args, NULL); - goto finally; - } - } - - if (PyType_IsSubtype(type, &PyType_Type)) { - res = save_global(self, args, NULL); - goto finally; - } - - if (!pers_save && self->inst_pers_func) { - if ((tmp = save_pers(self, args, self->inst_pers_func)) != 0) { - res = tmp; - goto finally; - } - } - - if ((__reduce__ = PyDict_GetItem(dispatch_table, (PyObject *)type))) { - Py_INCREF(__reduce__); - - Py_INCREF(args); - ARG_TUP(self, args); - if (self->arg) { - t = PyObject_Call(__reduce__, self->arg, NULL); - FREE_ARG_TUP(self); - } - if (! t) goto finally; - } - else { - PyErr_Clear(); - - if ((__reduce__ = PyObject_GetAttr(args, __reduce___str))) { - if (!( t = PyObject_Call(__reduce__, empty_tuple, NULL))) - goto finally; - } - else { - PyErr_Clear(); - } - } - - if (t) { - if (PyString_Check(t)) { - res = save_global(self, args, t); - goto finally; - } - - if (!PyTuple_Check(t)) { - cPickle_ErrFormat(PicklingError, "Value returned by %s must " - "be a tuple", "O", __reduce__); - goto finally; - } - - size = PyTuple_Size(t); - - if ((size != 3) && (size != 2)) { - cPickle_ErrFormat(PicklingError, "tuple returned by %s must " - "contain only two or three elements", "O", __reduce__); - goto finally; - } - - callable = PyTuple_GET_ITEM(t, 0); - - arg_tup = PyTuple_GET_ITEM(t, 1); - - if (size > 2) { - state = PyTuple_GET_ITEM(t, 2); - } - - if (!( PyTuple_Check(arg_tup) || arg_tup==Py_None )) { - cPickle_ErrFormat(PicklingError, "Second element of tuple " - "returned by %s must be a tuple", "O", __reduce__); - goto finally; - } - - res = save_reduce(self, callable, arg_tup, state, args); - goto finally; - } - - PyErr_SetObject(UnpickleableError, args); - -finally: - Py_XDECREF(py_ob_id); - Py_XDECREF(__reduce__); - Py_XDECREF(t); - - return res; + if (type == &PyCFunction_Type) { + res = save_global(self, args, NULL); + goto finally; + } + } + + if (PyType_IsSubtype(type, &PyType_Type)) { + res = save_global(self, args, NULL); + goto finally; + } + + if (!pers_save && self->inst_pers_func) { + if ((tmp = save_pers(self, args, self->inst_pers_func)) != 0) { + res = tmp; + goto finally; + } + } + + if ((__reduce__ = PyDict_GetItem(dispatch_table, (PyObject *)type))) { + Py_INCREF(__reduce__); + + Py_INCREF(args); + ARG_TUP(self, args); + if (self->arg) { + t = PyObject_Call(__reduce__, self->arg, NULL); + FREE_ARG_TUP(self); + } + if (! t) goto finally; + } + else { + PyErr_Clear(); + + if ((__reduce__ = PyObject_GetAttr(args, __reduce___str))) { + t = PyObject_Call(__reduce__, empty_tuple, NULL); + if (!t) + goto finally; + } + else { + PyErr_Clear(); + } + } + + if (t) { + if (PyString_Check(t)) { + res = save_global(self, args, t); + goto finally; + } + + if (!PyTuple_Check(t)) { + cPickle_ErrFormat(PicklingError, "Value returned by %s must " + "be a tuple", "O", __reduce__); + goto finally; + } + + size = PyTuple_Size(t); + + if ((size != 3) && (size != 2)) { + cPickle_ErrFormat(PicklingError, "tuple returned by %s must " + "contain only two or three elements", "O", __reduce__); + goto finally; + } + + callable = PyTuple_GET_ITEM(t, 0); + + arg_tup = PyTuple_GET_ITEM(t, 1); + + if (size > 2) { + state = PyTuple_GET_ITEM(t, 2); + } + + if (!( PyTuple_Check(arg_tup) || arg_tup==Py_None )) { + cPickle_ErrFormat(PicklingError, "Second element of tuple " + "returned by %s must be a tuple", "O", __reduce__); + goto finally; + } + + res = save_reduce(self, callable, arg_tup, state, args); + goto finally; + } + + PyErr_SetObject(UnpickleableError, args); + + finally: + Py_XDECREF(py_ob_id); + Py_XDECREF(__reduce__); + Py_XDECREF(t); + + return res; } static int -dump(Picklerobject *self, PyObject *args) { - static char stop = STOP; +dump(Picklerobject *self, PyObject *args) +{ + static char stop = STOP; - if (save(self, args, 0) < 0) - return -1; + if (save(self, args, 0) < 0) + return -1; - if ((*self->write_func)(self, &stop, 1) < 0) - return -1; + if ((*self->write_func)(self, &stop, 1) < 0) + return -1; - if ((*self->write_func)(self, NULL, 0) < 0) - return -1; + if ((*self->write_func)(self, NULL, 0) < 0) + return -1; - return 0; + return 0; } static PyObject * -Pickle_clear_memo(Picklerobject *self, PyObject *args) { - if (!PyArg_ParseTuple(args,":clear_memo")) - return NULL; - if (self->memo) - PyDict_Clear(self->memo); - Py_INCREF(Py_None); - return Py_None; +Pickle_clear_memo(Picklerobject *self, PyObject *args) +{ + if (!PyArg_ParseTuple(args,":clear_memo")) + return NULL; + if (self->memo) + PyDict_Clear(self->memo); + Py_INCREF(Py_None); + return Py_None; } static PyObject * -Pickle_getvalue(Picklerobject *self, PyObject *args) { - int l, i, rsize, ssize, clear=1, lm; - long ik; - PyObject *k, *r; - char *s, *p, *have_get; - Pdata *data; - - /* Can be called by Python code or C code */ - if (args && !PyArg_ParseTuple(args, "|i:getvalue", &clear)) - return NULL; - - /* Check to make sure we are based on a list */ - if (! Pdata_Check(self->file)) { - PyErr_SetString(PicklingError, - "Attempt to getvalue() a non-list-based pickler"); - return NULL; - } +Pickle_getvalue(Picklerobject *self, PyObject *args) +{ + int l, i, rsize, ssize, clear=1, lm; + long ik; + PyObject *k, *r; + char *s, *p, *have_get; + Pdata *data; + + /* Can be called by Python code or C code */ + if (args && !PyArg_ParseTuple(args, "|i:getvalue", &clear)) + return NULL; + + /* Check to make sure we are based on a list */ + if (! Pdata_Check(self->file)) { + PyErr_SetString(PicklingError, + "Attempt to getvalue() a non-list-based pickler"); + return NULL; + } - /* flush write buffer */ - if (write_other(self, NULL, 0) < 0) return NULL; - - data=(Pdata*)self->file; - l=data->length; - - /* set up an array to hold get/put status */ - if ((lm=PyDict_Size(self->memo)) < 0) return NULL; - lm++; - if (! (have_get=malloc((lm)*sizeof(char)))) return PyErr_NoMemory(); - memset(have_get,0,lm); - - /* Scan for gets. */ - for (rsize=0, i=l; --i >= 0; ) { - k=data->data[i]; - - if (PyString_Check(k)) { - rsize += PyString_GET_SIZE(k); - } - - else if (PyInt_Check(k)) { /* put */ - ik=PyInt_AS_LONG((PyIntObject*)k); - if (ik >= lm || ik==0) { - PyErr_SetString(PicklingError, - "Invalid get data"); - return NULL; - } - if (have_get[ik]) { /* with matching get */ - if (ik < 256) rsize += 2; - else rsize+=5; - } - } - - else if (! (PyTuple_Check(k) && - PyTuple_GET_SIZE(k) == 2 && - PyInt_Check((k=PyTuple_GET_ITEM(k,0)))) - ) { - PyErr_SetString(PicklingError, - "Unexpected data in internal list"); - return NULL; - } - - else { /* put */ - ik=PyInt_AS_LONG((PyIntObject*)k); - if (ik >= lm || ik==0) { - PyErr_SetString(PicklingError, - "Invalid get data"); - return NULL; - } - have_get[ik]=1; - if (ik < 256) rsize += 2; - else rsize+=5; - } - - } - - /* Now generate the result */ - if (!( r=PyString_FromStringAndSize(NULL,rsize))) goto err; - s=PyString_AS_STRING((PyStringObject*)r); - - for (i=0; i<l; i++) { - k=data->data[i]; - - if (PyString_Check(k)) { - ssize=PyString_GET_SIZE(k); - if (ssize) { - p=PyString_AS_STRING((PyStringObject*)k); - while (--ssize >= 0) *s++=*p++; - } - } - - else if (PyTuple_Check(k)) { /* get */ - ik=PyInt_AS_LONG((PyIntObject*)PyTuple_GET_ITEM(k,0)); - if (ik < 256) { - *s++ = BINGET; - *s++ = (int)(ik & 0xff); - } - else { - *s++ = LONG_BINGET; - *s++ = (int)(ik & 0xff); - *s++ = (int)((ik >> 8) & 0xff); - *s++ = (int)((ik >> 16) & 0xff); - *s++ = (int)((ik >> 24) & 0xff); - } - } - - else { /* put */ - ik=PyInt_AS_LONG((PyIntObject*)k); - - if (have_get[ik]) { /* with matching get */ - if (ik < 256) { - *s++ = BINPUT; - *s++ = (int)(ik & 0xff); - } - else { - *s++ = LONG_BINPUT; - *s++ = (int)(ik & 0xff); - *s++ = (int)((ik >> 8) & 0xff); - *s++ = (int)((ik >> 16) & 0xff); - *s++ = (int)((ik >> 24) & 0xff); - } - } - } - - } - - if (clear) { - PyDict_Clear(self->memo); - Pdata_clear(data,0); - } + /* flush write buffer */ + if (write_other(self, NULL, 0) < 0) return NULL; + + data=(Pdata*)self->file; + l=data->length; + + /* set up an array to hold get/put status */ + if ((lm=PyDict_Size(self->memo)) < 0) return NULL; + lm++; + if (! (have_get=malloc((lm)*sizeof(char)))) return PyErr_NoMemory(); + memset(have_get,0,lm); + + /* Scan for gets. */ + for (rsize=0, i=l; --i >= 0; ) { + k=data->data[i]; + + if (PyString_Check(k)) { + rsize += PyString_GET_SIZE(k); + } + + else if (PyInt_Check(k)) { /* put */ + ik=PyInt_AS_LONG((PyIntObject*)k); + if (ik >= lm || ik==0) { + PyErr_SetString(PicklingError, + "Invalid get data"); + return NULL; + } + if (have_get[ik]) { /* with matching get */ + if (ik < 256) rsize += 2; + else rsize+=5; + } + } + + else if (! (PyTuple_Check(k) && + PyTuple_GET_SIZE(k) == 2 && + PyInt_Check((k=PyTuple_GET_ITEM(k,0)))) + ) { + PyErr_SetString(PicklingError, + "Unexpected data in internal list"); + return NULL; + } + + else { /* put */ + ik=PyInt_AS_LONG((PyIntObject*)k); + if (ik >= lm || ik==0) { + PyErr_SetString(PicklingError, + "Invalid get data"); + return NULL; + } + have_get[ik]=1; + if (ik < 256) rsize += 2; + else rsize+=5; + } + + } + + /* Now generate the result */ + if (!( r=PyString_FromStringAndSize(NULL,rsize))) goto err; + s=PyString_AS_STRING((PyStringObject*)r); + + for (i=0; i<l; i++) { + k=data->data[i]; + + if (PyString_Check(k)) { + ssize=PyString_GET_SIZE(k); + if (ssize) { + p=PyString_AS_STRING((PyStringObject*)k); + while (--ssize >= 0) *s++=*p++; + } + } + + else if (PyTuple_Check(k)) { /* get */ + ik=PyInt_AS_LONG((PyIntObject*)PyTuple_GET_ITEM(k,0)); + if (ik < 256) { + *s++ = BINGET; + *s++ = (int)(ik & 0xff); + } + else { + *s++ = LONG_BINGET; + *s++ = (int)(ik & 0xff); + *s++ = (int)((ik >> 8) & 0xff); + *s++ = (int)((ik >> 16) & 0xff); + *s++ = (int)((ik >> 24) & 0xff); + } + } + + else { /* put */ + ik=PyInt_AS_LONG((PyIntObject*)k); + + if (have_get[ik]) { /* with matching get */ + if (ik < 256) { + *s++ = BINPUT; + *s++ = (int)(ik & 0xff); + } + else { + *s++ = LONG_BINPUT; + *s++ = (int)(ik & 0xff); + *s++ = (int)((ik >> 8) & 0xff); + *s++ = (int)((ik >> 16) & 0xff); + *s++ = (int)((ik >> 24) & 0xff); + } + } + } + + } + + if (clear) { + PyDict_Clear(self->memo); + Pdata_clear(data,0); + } - free(have_get); - return r; -err: - free(have_get); - return NULL; + free(have_get); + return r; + err: + free(have_get); + return NULL; } static PyObject * -Pickler_dump(Picklerobject *self, PyObject *args) { - PyObject *ob; - int get=0; +Pickler_dump(Picklerobject *self, PyObject *args) +{ + PyObject *ob; + int get=0; - if (!( PyArg_ParseTuple(args, "O|i:dump", &ob, &get))) - return NULL; + if (!( PyArg_ParseTuple(args, "O|i:dump", &ob, &get))) + return NULL; - if (dump(self, ob) < 0) - return NULL; + if (dump(self, ob) < 0) + return NULL; - if (get) return Pickle_getvalue(self, NULL); + if (get) return Pickle_getvalue(self, NULL); - /* XXX Why does dump() return self? */ - Py_INCREF(self); - return (PyObject*)self; + /* XXX Why does dump() return self? */ + Py_INCREF(self); + return (PyObject*)self; } -static struct PyMethodDef Pickler_methods[] = { +static struct PyMethodDef Pickler_methods[] = +{ {"dump", (PyCFunction)Pickler_dump, METH_VARARGS, "dump(object) --" "Write an object in pickle format to the object's pickle stream\n" @@ -2272,197 +2334,202 @@ static struct PyMethodDef Pickler_methods[] = { static Picklerobject * -newPicklerobject(PyObject *file, int bin) { - Picklerobject *self; - - if (!( self = PyObject_New(Picklerobject, &Picklertype))) - return NULL; - - self->fp = NULL; - self->write = NULL; - self->memo = NULL; - self->arg = NULL; - self->pers_func = NULL; - self->inst_pers_func = NULL; - self->write_buf = NULL; - self->bin = bin; - self->fast = 0; - self->fast_container = 0; - self->fast_memo = NULL; - self->buf_size = 0; - self->dispatch_table = NULL; - - if (file) - Py_INCREF(file); - else - file=Pdata_New(); - - if (!( self->file = file )) - goto err; - - if (!( self->memo = PyDict_New())) - goto err; - - if (PyFile_Check(file)) { - self->fp = PyFile_AsFile(file); - if (self->fp == NULL) { - PyErr_SetString(PyExc_ValueError, "I/O operation on closed file"); - goto err; - } - self->write_func = write_file; - } - else if (PycStringIO_OutputCheck(file)) { - self->write_func = write_cStringIO; - } - else if (file == Py_None) { - self->write_func = write_none; - } - else { - self->write_func = write_other; - - if (! Pdata_Check(file)) { - if (!( self->write = PyObject_GetAttr(file, write_str))) { - PyErr_Clear(); - PyErr_SetString(PyExc_TypeError, "argument must have 'write' " - "attribute"); - goto err; - } - } - - if (!( self->write_buf = - (char *)malloc(WRITE_BUF_SIZE * sizeof(char)))) { - PyErr_NoMemory(); - goto err; - } - } - - if (PyEval_GetRestricted()) { - /* Restricted execution, get private tables */ - PyObject *m; - - if (!( m=PyImport_Import(copy_reg_str))) goto err; - self->dispatch_table=PyObject_GetAttr(m, dispatch_table_str); - Py_DECREF(m); - if (!( self->dispatch_table )) goto err; - } - else { - self->dispatch_table=dispatch_table; - Py_INCREF(dispatch_table); - } - - return self; - -err: - Py_DECREF((PyObject *)self); - return NULL; +newPicklerobject(PyObject *file, int bin) +{ + Picklerobject *self; + + if (!( self = PyObject_New(Picklerobject, &Picklertype))) + return NULL; + + self->fp = NULL; + self->write = NULL; + self->memo = NULL; + self->arg = NULL; + self->pers_func = NULL; + self->inst_pers_func = NULL; + self->write_buf = NULL; + self->bin = bin; + self->fast = 0; + self->fast_container = 0; + self->fast_memo = NULL; + self->buf_size = 0; + self->dispatch_table = NULL; + + if (file) + Py_INCREF(file); + else + file=Pdata_New(); + + if (!( self->file = file )) + goto err; + + if (!( self->memo = PyDict_New())) + goto err; + + if (PyFile_Check(file)) { + self->fp = PyFile_AsFile(file); + if (self->fp == NULL) { + PyErr_SetString(PyExc_ValueError, "I/O operation on closed file"); + goto err; + } + self->write_func = write_file; + } + else if (PycStringIO_OutputCheck(file)) { + self->write_func = write_cStringIO; + } + else if (file == Py_None) { + self->write_func = write_none; + } + else { + self->write_func = write_other; + + if (! Pdata_Check(file)) { + self->write = PyObject_GetAttr(file, write_str); + if (!self->write) { + PyErr_Clear(); + PyErr_SetString(PyExc_TypeError, + "argument must have 'write' " + "attribute"); + goto err; + } + } + + if (!( self->write_buf = + (char *)malloc(WRITE_BUF_SIZE * sizeof(char)))) { + PyErr_NoMemory(); + goto err; + } + } + + if (PyEval_GetRestricted()) { + /* Restricted execution, get private tables */ + PyObject *m; + + if (!( m=PyImport_Import(copy_reg_str))) goto err; + self->dispatch_table=PyObject_GetAttr(m, dispatch_table_str); + Py_DECREF(m); + if (!( self->dispatch_table )) goto err; + } + else { + self->dispatch_table=dispatch_table; + Py_INCREF(dispatch_table); + } + + return self; + + err: + Py_DECREF((PyObject *)self); + return NULL; } static PyObject * -get_Pickler(PyObject *self, PyObject *args) { - PyObject *file = NULL; - int bin = 1; - - if (!PyArg_ParseTuple(args, "|i:Pickler", &bin)) { - PyErr_Clear(); - bin = 0; - if (!PyArg_ParseTuple(args, "O|i:Pickler", &file, &bin)) - return NULL; - } - return (PyObject *)newPicklerobject(file, bin); +get_Pickler(PyObject *self, PyObject *args) +{ + PyObject *file = NULL; + int bin = 1; + + if (!PyArg_ParseTuple(args, "|i:Pickler", &bin)) { + PyErr_Clear(); + bin = 0; + if (!PyArg_ParseTuple(args, "O|i:Pickler", &file, &bin)) + return NULL; + } + return (PyObject *)newPicklerobject(file, bin); } static void -Pickler_dealloc(Picklerobject *self) { - Py_XDECREF(self->write); - Py_XDECREF(self->memo); - Py_XDECREF(self->fast_memo); - Py_XDECREF(self->arg); - Py_XDECREF(self->file); - Py_XDECREF(self->pers_func); - Py_XDECREF(self->inst_pers_func); - Py_XDECREF(self->dispatch_table); - - if (self->write_buf) { - free(self->write_buf); - } +Pickler_dealloc(Picklerobject *self) +{ + Py_XDECREF(self->write); + Py_XDECREF(self->memo); + Py_XDECREF(self->fast_memo); + Py_XDECREF(self->arg); + Py_XDECREF(self->file); + Py_XDECREF(self->pers_func); + Py_XDECREF(self->inst_pers_func); + Py_XDECREF(self->dispatch_table); + + if (self->write_buf) { + free(self->write_buf); + } - PyObject_Del(self); + PyObject_Del(self); } static PyObject * Pickler_get_pers_func(Picklerobject *p) { - if (p->pers_func == NULL) - PyErr_SetString(PyExc_AttributeError, "persistent_id"); - else - Py_INCREF(p->pers_func); - return p->pers_func; + if (p->pers_func == NULL) + PyErr_SetString(PyExc_AttributeError, "persistent_id"); + else + Py_INCREF(p->pers_func); + return p->pers_func; } static int Pickler_set_pers_func(Picklerobject *p, PyObject *v) { - if (v == NULL) { - PyErr_SetString(PyExc_TypeError, - "attribute deletion is not supported"); - return -1; - } - Py_XDECREF(p->pers_func); - Py_INCREF(v); - p->pers_func = v; - return 0; + if (v == NULL) { + PyErr_SetString(PyExc_TypeError, + "attribute deletion is not supported"); + return -1; + } + Py_XDECREF(p->pers_func); + Py_INCREF(v); + p->pers_func = v; + return 0; } static int Pickler_set_inst_pers_func(Picklerobject *p, PyObject *v) { - if (v == NULL) { - PyErr_SetString(PyExc_TypeError, - "attribute deletion is not supported"); - return -1; - } - Py_XDECREF(p->inst_pers_func); - Py_INCREF(v); - p->inst_pers_func = v; - return 0; + if (v == NULL) { + PyErr_SetString(PyExc_TypeError, + "attribute deletion is not supported"); + return -1; + } + Py_XDECREF(p->inst_pers_func); + Py_INCREF(v); + p->inst_pers_func = v; + return 0; } static PyObject * Pickler_get_memo(Picklerobject *p) { - if (p->memo == NULL) - PyErr_SetString(PyExc_AttributeError, "memo"); - else - Py_INCREF(p->memo); - return p->memo; + if (p->memo == NULL) + PyErr_SetString(PyExc_AttributeError, "memo"); + else + Py_INCREF(p->memo); + return p->memo; } static int Pickler_set_memo(Picklerobject *p, PyObject *v) { - if (v == NULL) { - PyErr_SetString(PyExc_TypeError, - "attribute deletion is not supported"); - return -1; - } - if (!PyDict_Check(v)) { - PyErr_SetString(PyExc_TypeError, "memo must be a dictionary"); - return -1; - } - Py_XDECREF(p->memo); - Py_INCREF(v); - p->memo = v; - return 0; + if (v == NULL) { + PyErr_SetString(PyExc_TypeError, + "attribute deletion is not supported"); + return -1; + } + if (!PyDict_Check(v)) { + PyErr_SetString(PyExc_TypeError, "memo must be a dictionary"); + return -1; + } + Py_XDECREF(p->memo); + Py_INCREF(v); + p->memo = v; + return 0; } static PyObject * Pickler_get_error(Picklerobject *p) { - /* why is this an attribute on the Pickler? */ - Py_INCREF(PicklingError); - return PicklingError; + /* why is this an attribute on the Pickler? */ + Py_INCREF(PicklingError); + return PicklingError; } static PyMemberDef Pickler_members[] = { @@ -2518,1354 +2585,1422 @@ static PyTypeObject Picklertype = { }; static PyObject * -find_class(PyObject *py_module_name, PyObject *py_global_name, PyObject *fc) { - PyObject *global = 0, *module; +find_class(PyObject *py_module_name, PyObject *py_global_name, PyObject *fc) +{ + PyObject *global = 0, *module; + + if (fc) { + if (fc==Py_None) { + PyErr_SetString(UnpicklingError, + "Global and instance pickles are not supported."); + return NULL; + } + return PyObject_CallFunction(fc, "OO", py_module_name, + py_global_name); + } - if (fc) { - if (fc==Py_None) { - PyErr_SetString(UnpicklingError, - "Global and instance pickles are not supported."); - return NULL; - } - return PyObject_CallFunction(fc, "OO", py_module_name, py_global_name); - } - - module = PySys_GetObject("modules"); - if (module == NULL) - return NULL; - - module = PyDict_GetItem(module, py_module_name); - if (module == NULL) { - module = PyImport_Import(py_module_name); - if (!module) - return NULL; - global = PyObject_GetAttr(module, py_global_name); - Py_DECREF(module); - } - else - global = PyObject_GetAttr(module, py_global_name); - return global; + module = PySys_GetObject("modules"); + if (module == NULL) + return NULL; + + module = PyDict_GetItem(module, py_module_name); + if (module == NULL) { + module = PyImport_Import(py_module_name); + if (!module) + return NULL; + global = PyObject_GetAttr(module, py_global_name); + Py_DECREF(module); + } + else + global = PyObject_GetAttr(module, py_global_name); + return global; } static int -marker(Unpicklerobject *self) { - if (self->num_marks < 1) { - PyErr_SetString(UnpicklingError, "could not find MARK"); - return -1; - } +marker(Unpicklerobject *self) +{ + if (self->num_marks < 1) { + PyErr_SetString(UnpicklingError, "could not find MARK"); + return -1; + } - return self->marks[--self->num_marks]; + return self->marks[--self->num_marks]; } static int -load_none(Unpicklerobject *self) { - PDATA_APPEND(self->stack, Py_None, -1); - return 0; +load_none(Unpicklerobject *self) +{ + PDATA_APPEND(self->stack, Py_None, -1); + return 0; } static int -bad_readline(void) { - PyErr_SetString(UnpicklingError, "pickle data was truncated"); - return -1; +bad_readline(void) +{ + PyErr_SetString(UnpicklingError, "pickle data was truncated"); + return -1; } static int -load_int(Unpicklerobject *self) { - PyObject *py_int = 0; - char *endptr, *s; - int len, res = -1; - long l; - - if ((len = (*self->readline_func)(self, &s)) < 0) return -1; - if (len < 2) return bad_readline(); - if (!( s=pystrndup(s,len))) return -1; - - errno = 0; - l = strtol(s, &endptr, 0); +load_int(Unpicklerobject *self) +{ + PyObject *py_int = 0; + char *endptr, *s; + int len, res = -1; + long l; - if (errno || (*endptr != '\n') || (endptr[1] != '\0')) { - /* Hm, maybe we've got something long. Let's try reading - it as a Python long object. */ - errno = 0; - py_int = PyLong_FromString(s, NULL, 0); - if (py_int == NULL) { - PyErr_SetString(PyExc_ValueError, - "could not convert string to int"); - goto finally; - } - } - else { - if (!( py_int = PyInt_FromLong(l))) goto finally; - } + if ((len = (*self->readline_func)(self, &s)) < 0) return -1; + if (len < 2) return bad_readline(); + if (!( s=pystrndup(s,len))) return -1; + + errno = 0; + l = strtol(s, &endptr, 0); + + if (errno || (*endptr != '\n') || (endptr[1] != '\0')) { + /* Hm, maybe we've got something long. Let's try reading + it as a Python long object. */ + errno = 0; + py_int = PyLong_FromString(s, NULL, 0); + if (py_int == NULL) { + PyErr_SetString(PyExc_ValueError, + "could not convert string to int"); + goto finally; + } + } + else { + if (!( py_int = PyInt_FromLong(l))) goto finally; + } - free(s); - PDATA_PUSH(self->stack, py_int, -1); - return 0; + free(s); + PDATA_PUSH(self->stack, py_int, -1); + return 0; -finally: - free(s); + finally: + free(s); - return res; + return res; } static long -calc_binint(char *s, int x) { - unsigned char c; - int i; - long l; - - for (i = 0, l = 0L; i < x; i++) { - c = (unsigned char)s[i]; - l |= (long)c << (i * 8); - } +calc_binint(char *s, int x) +{ + unsigned char c; + int i; + long l; + + for (i = 0, l = 0L; i < x; i++) { + c = (unsigned char)s[i]; + l |= (long)c << (i * 8); + } #if SIZEOF_LONG > 4 - /* Unlike BININT1 and BININT2, BININT (more accurately BININT4) - * is signed, so on a box with longs bigger than 4 bytes we need - * to extend a BININT's sign bit to the full width. - */ - if (x == 4 && l & (1L << 31)) - l |= (~0L) << 32; + /* Unlike BININT1 and BININT2, BININT (more accurately BININT4) + * is signed, so on a box with longs bigger than 4 bytes we need + * to extend a BININT's sign bit to the full width. + */ + if (x == 4 && l & (1L << 31)) + l |= (~0L) << 32; #endif - return l; + return l; } static int -load_binintx(Unpicklerobject *self, char *s, int x) { - PyObject *py_int = 0; - long l; +load_binintx(Unpicklerobject *self, char *s, int x) +{ + PyObject *py_int = 0; + long l; - l = calc_binint(s, x); + l = calc_binint(s, x); - if (!( py_int = PyInt_FromLong(l))) - return -1; + if (!( py_int = PyInt_FromLong(l))) + return -1; - PDATA_PUSH(self->stack, py_int, -1); - return 0; + PDATA_PUSH(self->stack, py_int, -1); + return 0; } static int -load_binint(Unpicklerobject *self) { - char *s; +load_binint(Unpicklerobject *self) +{ + char *s; - if ((*self->read_func)(self, &s, 4) < 0) - return -1; + if ((*self->read_func)(self, &s, 4) < 0) + return -1; - return load_binintx(self, s, 4); + return load_binintx(self, s, 4); } static int -load_binint1(Unpicklerobject *self) { - char *s; +load_binint1(Unpicklerobject *self) +{ + char *s; - if ((*self->read_func)(self, &s, 1) < 0) - return -1; + if ((*self->read_func)(self, &s, 1) < 0) + return -1; - return load_binintx(self, s, 1); + return load_binintx(self, s, 1); } static int -load_binint2(Unpicklerobject *self) { - char *s; +load_binint2(Unpicklerobject *self) +{ + char *s; - if ((*self->read_func)(self, &s, 2) < 0) - return -1; + if ((*self->read_func)(self, &s, 2) < 0) + return -1; - return load_binintx(self, s, 2); + return load_binintx(self, s, 2); } static int -load_long(Unpicklerobject *self) { - PyObject *l = 0; - char *end, *s; - int len, res = -1; +load_long(Unpicklerobject *self) +{ + PyObject *l = 0; + char *end, *s; + int len, res = -1; - if ((len = (*self->readline_func)(self, &s)) < 0) return -1; - if (len < 2) return bad_readline(); - if (!( s=pystrndup(s,len))) return -1; + if ((len = (*self->readline_func)(self, &s)) < 0) return -1; + if (len < 2) return bad_readline(); + if (!( s=pystrndup(s,len))) return -1; - if (!( l = PyLong_FromString(s, &end, 0))) - goto finally; + if (!( l = PyLong_FromString(s, &end, 0))) + goto finally; - free(s); - PDATA_PUSH(self->stack, l, -1); - return 0; + free(s); + PDATA_PUSH(self->stack, l, -1); + return 0; -finally: - free(s); + finally: + free(s); - return res; + return res; } static int -load_float(Unpicklerobject *self) { - PyObject *py_float = 0; - char *endptr, *s; - int len, res = -1; - double d; +load_float(Unpicklerobject *self) +{ + PyObject *py_float = 0; + char *endptr, *s; + int len, res = -1; + double d; - if ((len = (*self->readline_func)(self, &s)) < 0) return -1; - if (len < 2) return bad_readline(); - if (!( s=pystrndup(s,len))) return -1; + if ((len = (*self->readline_func)(self, &s)) < 0) return -1; + if (len < 2) return bad_readline(); + if (!( s=pystrndup(s,len))) return -1; - errno = 0; - d = strtod(s, &endptr); + errno = 0; + d = strtod(s, &endptr); - if (errno || (endptr[0] != '\n') || (endptr[1] != '\0')) { - PyErr_SetString(PyExc_ValueError, - "could not convert string to float"); - goto finally; - } + if (errno || (endptr[0] != '\n') || (endptr[1] != '\0')) { + PyErr_SetString(PyExc_ValueError, + "could not convert string to float"); + goto finally; + } - if (!( py_float = PyFloat_FromDouble(d))) - goto finally; + if (!( py_float = PyFloat_FromDouble(d))) + goto finally; - free(s); - PDATA_PUSH(self->stack, py_float, -1); - return 0; + free(s); + PDATA_PUSH(self->stack, py_float, -1); + return 0; -finally: - free(s); + finally: + free(s); - return res; + return res; } static int -load_binfloat(Unpicklerobject *self) { - PyObject *py_float = 0; - int s, e; - long fhi, flo; - double x; - char *p; - - if ((*self->read_func)(self, &p, 8) < 0) - return -1; - - /* First byte */ - s = (*p>>7) & 1; - e = (*p & 0x7F) << 4; - p++; - - /* Second byte */ - e |= (*p>>4) & 0xF; - fhi = (*p & 0xF) << 24; - p++; - - /* Third byte */ - fhi |= (*p & 0xFF) << 16; - p++; - - /* Fourth byte */ - fhi |= (*p & 0xFF) << 8; - p++; - - /* Fifth byte */ - fhi |= *p & 0xFF; - p++; - - /* Sixth byte */ - flo = (*p & 0xFF) << 16; - p++; - - /* Seventh byte */ - flo |= (*p & 0xFF) << 8; - p++; - - /* Eighth byte */ - flo |= *p & 0xFF; - - x = (double)fhi + (double)flo / 16777216.0; /* 2**24 */ - x /= 268435456.0; /* 2**28 */ - - /* XXX This sadly ignores Inf/NaN */ - if (e == 0) - e = -1022; - else { - x += 1.0; - e -= 1023; - } - x = ldexp(x, e); +load_binfloat(Unpicklerobject *self) +{ + PyObject *py_float = 0; + int s, e; + long fhi, flo; + double x; + char *p; + + if ((*self->read_func)(self, &p, 8) < 0) + return -1; + + /* First byte */ + s = (*p>>7) & 1; + e = (*p & 0x7F) << 4; + p++; + + /* Second byte */ + e |= (*p>>4) & 0xF; + fhi = (*p & 0xF) << 24; + p++; + + /* Third byte */ + fhi |= (*p & 0xFF) << 16; + p++; + + /* Fourth byte */ + fhi |= (*p & 0xFF) << 8; + p++; + + /* Fifth byte */ + fhi |= *p & 0xFF; + p++; + + /* Sixth byte */ + flo = (*p & 0xFF) << 16; + p++; + + /* Seventh byte */ + flo |= (*p & 0xFF) << 8; + p++; + + /* Eighth byte */ + flo |= *p & 0xFF; + + x = (double)fhi + (double)flo / 16777216.0; /* 2**24 */ + x /= 268435456.0; /* 2**28 */ + + /* XXX This sadly ignores Inf/NaN */ + if (e == 0) + e = -1022; + else { + x += 1.0; + e -= 1023; + } + x = ldexp(x, e); - if (s) - x = -x; + if (s) + x = -x; - if (!( py_float = PyFloat_FromDouble(x))) return -1; + if (!( py_float = PyFloat_FromDouble(x))) return -1; - PDATA_PUSH(self->stack, py_float, -1); - return 0; + PDATA_PUSH(self->stack, py_float, -1); + return 0; } static int -load_string(Unpicklerobject *self) { - PyObject *str = 0; - int len, res = -1, nslash; - char *s, q, *p; - - static PyObject *eval_dict = 0; +load_string(Unpicklerobject *self) +{ + PyObject *str = 0; + int len, res = -1, nslash; + char *s, q, *p; - if ((len = (*self->readline_func)(self, &s)) < 0) return -1; - if (len < 2) return bad_readline(); - if (!( s=pystrndup(s,len))) return -1; + static PyObject *eval_dict = 0; - /* Check for unquoted quotes (evil strings) */ - q=*s; - if (q != '"' && q != '\'') goto insecure; - for (p=s+1, nslash=0; *p; p++) { - if (*p==q && nslash%2==0) break; - if (*p=='\\') nslash++; - else nslash=0; - } - if (*p == q) { - for (p++; *p; p++) - if (*(unsigned char *)p > ' ') - goto insecure; - } - else - goto insecure; - /********************************************/ + if ((len = (*self->readline_func)(self, &s)) < 0) return -1; + if (len < 2) return bad_readline(); + if (!( s=pystrndup(s,len))) return -1; + + /* Check for unquoted quotes (evil strings) */ + q=*s; + if (q != '"' && q != '\'') goto insecure; + for (p=s+1, nslash=0; *p; p++) { + if (*p==q && nslash%2==0) break; + if (*p=='\\') nslash++; + else nslash=0; + } + if (*p == q) { + for (p++; *p; p++) + if (*(unsigned char *)p > ' ') + goto insecure; + } + else + goto insecure; + /********************************************/ - if (!( eval_dict )) - if (!( eval_dict = Py_BuildValue("{s{}}", "__builtins__"))) - goto finally; + if (!( eval_dict )) + if (!( eval_dict = Py_BuildValue("{s{}}", "__builtins__"))) + goto finally; - if (!( str = PyRun_String(s, Py_eval_input, eval_dict, eval_dict))) - goto finally; + if (!( str = PyRun_String(s, Py_eval_input, eval_dict, eval_dict))) + goto finally; - free(s); - PDATA_PUSH(self->stack, str, -1); - return 0; + free(s); + PDATA_PUSH(self->stack, str, -1); + return 0; -finally: - free(s); + finally: + free(s); - return res; + return res; -insecure: - free(s); - PyErr_SetString(PyExc_ValueError,"insecure string pickle"); - return -1; + insecure: + free(s); + PyErr_SetString(PyExc_ValueError,"insecure string pickle"); + return -1; } static int -load_binstring(Unpicklerobject *self) { - PyObject *py_string = 0; - long l; - char *s; +load_binstring(Unpicklerobject *self) +{ + PyObject *py_string = 0; + long l; + char *s; - if ((*self->read_func)(self, &s, 4) < 0) return -1; + if ((*self->read_func)(self, &s, 4) < 0) return -1; - l = calc_binint(s, 4); + l = calc_binint(s, 4); - if ((*self->read_func)(self, &s, l) < 0) - return -1; + if ((*self->read_func)(self, &s, l) < 0) + return -1; - if (!( py_string = PyString_FromStringAndSize(s, l))) - return -1; + if (!( py_string = PyString_FromStringAndSize(s, l))) + return -1; - PDATA_PUSH(self->stack, py_string, -1); - return 0; + PDATA_PUSH(self->stack, py_string, -1); + return 0; } static int -load_short_binstring(Unpicklerobject *self) { - PyObject *py_string = 0; - unsigned char l; - char *s; +load_short_binstring(Unpicklerobject *self) +{ + PyObject *py_string = 0; + unsigned char l; + char *s; - if ((*self->read_func)(self, &s, 1) < 0) - return -1; + if ((*self->read_func)(self, &s, 1) < 0) + return -1; - l = (unsigned char)s[0]; + l = (unsigned char)s[0]; - if ((*self->read_func)(self, &s, l) < 0) return -1; + if ((*self->read_func)(self, &s, l) < 0) return -1; - if (!( py_string = PyString_FromStringAndSize(s, l))) return -1; + if (!( py_string = PyString_FromStringAndSize(s, l))) return -1; - PDATA_PUSH(self->stack, py_string, -1); - return 0; + PDATA_PUSH(self->stack, py_string, -1); + return 0; } #ifdef Py_USING_UNICODE static int -load_unicode(Unpicklerobject *self) { - PyObject *str = 0; - int len, res = -1; - char *s; +load_unicode(Unpicklerobject *self) +{ + PyObject *str = 0; + int len, res = -1; + char *s; - if ((len = (*self->readline_func)(self, &s)) < 0) return -1; - if (len < 1) return bad_readline(); + if ((len = (*self->readline_func)(self, &s)) < 0) return -1; + if (len < 1) return bad_readline(); - if (!( str = PyUnicode_DecodeRawUnicodeEscape(s, len - 1, NULL))) - goto finally; + if (!( str = PyUnicode_DecodeRawUnicodeEscape(s, len - 1, NULL))) + goto finally; - PDATA_PUSH(self->stack, str, -1); - return 0; + PDATA_PUSH(self->stack, str, -1); + return 0; -finally: - return res; + finally: + return res; } #endif #ifdef Py_USING_UNICODE static int -load_binunicode(Unpicklerobject *self) { - PyObject *unicode; - long l; - char *s; +load_binunicode(Unpicklerobject *self) +{ + PyObject *unicode; + long l; + char *s; - if ((*self->read_func)(self, &s, 4) < 0) return -1; + if ((*self->read_func)(self, &s, 4) < 0) return -1; - l = calc_binint(s, 4); + l = calc_binint(s, 4); - if ((*self->read_func)(self, &s, l) < 0) - return -1; + if ((*self->read_func)(self, &s, l) < 0) + return -1; - if (!( unicode = PyUnicode_DecodeUTF8(s, l, NULL))) - return -1; + if (!( unicode = PyUnicode_DecodeUTF8(s, l, NULL))) + return -1; - PDATA_PUSH(self->stack, unicode, -1); - return 0; + PDATA_PUSH(self->stack, unicode, -1); + return 0; } #endif static int -load_tuple(Unpicklerobject *self) { - PyObject *tup; - int i; +load_tuple(Unpicklerobject *self) +{ + PyObject *tup; + int i; - if ((i = marker(self)) < 0) return -1; - if (!( tup=Pdata_popTuple(self->stack, i))) return -1; - PDATA_PUSH(self->stack, tup, -1); - return 0; + if ((i = marker(self)) < 0) return -1; + if (!( tup=Pdata_popTuple(self->stack, i))) return -1; + PDATA_PUSH(self->stack, tup, -1); + return 0; } static int -load_empty_tuple(Unpicklerobject *self) { - PyObject *tup; +load_empty_tuple(Unpicklerobject *self) +{ + PyObject *tup; - if (!( tup=PyTuple_New(0))) return -1; - PDATA_PUSH(self->stack, tup, -1); - return 0; + if (!( tup=PyTuple_New(0))) return -1; + PDATA_PUSH(self->stack, tup, -1); + return 0; } static int -load_empty_list(Unpicklerobject *self) { - PyObject *list; +load_empty_list(Unpicklerobject *self) +{ + PyObject *list; - if (!( list=PyList_New(0))) return -1; - PDATA_PUSH(self->stack, list, -1); - return 0; + if (!( list=PyList_New(0))) return -1; + PDATA_PUSH(self->stack, list, -1); + return 0; } static int -load_empty_dict(Unpicklerobject *self) { - PyObject *dict; +load_empty_dict(Unpicklerobject *self) +{ + PyObject *dict; - if (!( dict=PyDict_New())) return -1; - PDATA_PUSH(self->stack, dict, -1); - return 0; + if (!( dict=PyDict_New())) return -1; + PDATA_PUSH(self->stack, dict, -1); + return 0; } static int -load_list(Unpicklerobject *self) { - PyObject *list = 0; - int i; +load_list(Unpicklerobject *self) +{ + PyObject *list = 0; + int i; - if ((i = marker(self)) < 0) return -1; - if (!( list=Pdata_popList(self->stack, i))) return -1; - PDATA_PUSH(self->stack, list, -1); - return 0; + if ((i = marker(self)) < 0) return -1; + if (!( list=Pdata_popList(self->stack, i))) return -1; + PDATA_PUSH(self->stack, list, -1); + return 0; } static int -load_dict(Unpicklerobject *self) { - PyObject *dict, *key, *value; - int i, j, k; +load_dict(Unpicklerobject *self) +{ + PyObject *dict, *key, *value; + int i, j, k; - if ((i = marker(self)) < 0) return -1; - j=self->stack->length; + if ((i = marker(self)) < 0) return -1; + j=self->stack->length; - if (!( dict = PyDict_New())) return -1; + if (!( dict = PyDict_New())) return -1; - for (k = i+1; k < j; k += 2) { - key =self->stack->data[k-1]; - value=self->stack->data[k ]; - if (PyDict_SetItem(dict, key, value) < 0) { - Py_DECREF(dict); - return -1; - } - } - Pdata_clear(self->stack, i); - PDATA_PUSH(self->stack, dict, -1); - return 0; + for (k = i+1; k < j; k += 2) { + key =self->stack->data[k-1]; + value=self->stack->data[k ]; + if (PyDict_SetItem(dict, key, value) < 0) { + Py_DECREF(dict); + return -1; + } + } + Pdata_clear(self->stack, i); + PDATA_PUSH(self->stack, dict, -1); + return 0; } static PyObject * -Instance_New(PyObject *cls, PyObject *args) { - int has_key; - PyObject *safe=0, *r=0; - - if (PyClass_Check(cls)) { - int l; - - if ((l=PyObject_Size(args)) < 0) goto err; - if (!( l )) { - PyObject *__getinitargs__; - - if (!( __getinitargs__=PyObject_GetAttr(cls, __getinitargs___str))) { - /* We have a class with no __getinitargs__, so bypass usual - construction */ - PyObject *inst; - - PyErr_Clear(); - if (!( inst=PyInstance_NewRaw(cls, NULL))) - goto err; - return inst; - } - Py_DECREF(__getinitargs__); - } - - if ((r=PyInstance_New(cls, args, NULL))) return r; - else goto err; - } - - /* Is safe_constructors always a dict? */ - has_key = cPickle_PyMapping_HasKey(safe_constructors, cls); - if (!has_key) - if (!(safe = PyObject_GetAttr(cls, __safe_for_unpickling___str)) || - !PyObject_IsTrue(safe)) { - cPickle_ErrFormat(UnpicklingError, - "%s is not safe for unpickling", "O", cls); - Py_XDECREF(safe); - return NULL; - } +Instance_New(PyObject *cls, PyObject *args) +{ + int has_key; + PyObject *safe=0, *r=0; + + if (PyClass_Check(cls)) { + int l; + + if ((l=PyObject_Size(args)) < 0) goto err; + if (!( l )) { + PyObject *__getinitargs__; + + __getinitargs__ = PyObject_GetAttr(cls, + __getinitargs___str); + if (!__getinitargs__) { + /* We have a class with no __getinitargs__, + so bypass usual construction */ + PyObject *inst; + + PyErr_Clear(); + if (!( inst=PyInstance_NewRaw(cls, NULL))) + goto err; + return inst; + } + Py_DECREF(__getinitargs__); + } + + if ((r=PyInstance_New(cls, args, NULL))) return r; + else goto err; + } + + /* Is safe_constructors always a dict? */ + has_key = cPickle_PyMapping_HasKey(safe_constructors, cls); + if (!has_key) { + safe = PyObject_GetAttr(cls, __safe_for_unpickling___str); + if (!safe || + !PyObject_IsTrue(safe)) { + cPickle_ErrFormat(UnpicklingError, + "%s is not safe for unpickling", + "O", cls); + Py_XDECREF(safe); + return NULL; + } + } - if (args==Py_None) { - /* Special case, call cls.__basicnew__() */ - PyObject *basicnew; + if (args==Py_None) { + /* Special case, call cls.__basicnew__() */ + PyObject *basicnew; - if (!( basicnew=PyObject_GetAttr(cls, __basicnew___str))) return NULL; - r=PyObject_CallObject(basicnew, NULL); - Py_DECREF(basicnew); - if (r) return r; - } + basicnew = PyObject_GetAttr(cls, __basicnew___str); + if (!basicnew) return NULL; + r=PyObject_CallObject(basicnew, NULL); + Py_DECREF(basicnew); + if (r) return r; + } - if ((r=PyObject_CallObject(cls, args))) return r; + if ((r=PyObject_CallObject(cls, args))) return r; -err: - { - PyObject *tp, *v, *tb; + err: + { + PyObject *tp, *v, *tb; - PyErr_Fetch(&tp, &v, &tb); - if ((r=Py_BuildValue("OOO",v,cls,args))) { - Py_XDECREF(v); - v=r; - } - PyErr_Restore(tp,v,tb); - } - return NULL; + PyErr_Fetch(&tp, &v, &tb); + if ((r=Py_BuildValue("OOO",v,cls,args))) { + Py_XDECREF(v); + v=r; + } + PyErr_Restore(tp,v,tb); + } + return NULL; } static int -load_obj(Unpicklerobject *self) { - PyObject *class, *tup, *obj=0; - int i; - - if ((i = marker(self)) < 0) return -1; - if (!( tup=Pdata_popTuple(self->stack, i+1))) return -1; - PDATA_POP(self->stack, class); - if (class) { - obj = Instance_New(class, tup); - Py_DECREF(class); - } - Py_DECREF(tup); +load_obj(Unpicklerobject *self) +{ + PyObject *class, *tup, *obj=0; + int i; + + if ((i = marker(self)) < 0) return -1; + if (!( tup=Pdata_popTuple(self->stack, i+1))) return -1; + PDATA_POP(self->stack, class); + if (class) { + obj = Instance_New(class, tup); + Py_DECREF(class); + } + Py_DECREF(tup); - if (! obj) return -1; - PDATA_PUSH(self->stack, obj, -1); - return 0; + if (! obj) return -1; + PDATA_PUSH(self->stack, obj, -1); + return 0; } static int -load_inst(Unpicklerobject *self) { - PyObject *tup, *class=0, *obj=0, *module_name, *class_name; - int i, len; - char *s; - - if ((i = marker(self)) < 0) return -1; +load_inst(Unpicklerobject *self) +{ + PyObject *tup, *class=0, *obj=0, *module_name, *class_name; + int i, len; + char *s; - if ((len = (*self->readline_func)(self, &s)) < 0) return -1; - if (len < 2) return bad_readline(); - if (!( module_name = PyString_FromStringAndSize(s, len - 1))) return -1; + if ((i = marker(self)) < 0) return -1; - if ((len = (*self->readline_func)(self, &s)) >= 0) { - if (len < 2) return bad_readline(); - if ((class_name = PyString_FromStringAndSize(s, len - 1))) { - class = find_class(module_name, class_name, self->find_class); - Py_DECREF(class_name); - } - } - Py_DECREF(module_name); + if ((len = (*self->readline_func)(self, &s)) < 0) return -1; + if (len < 2) return bad_readline(); + module_name = PyString_FromStringAndSize(s, len - 1); + if (!module_name) return -1; + + if ((len = (*self->readline_func)(self, &s)) >= 0) { + if (len < 2) return bad_readline(); + if ((class_name = PyString_FromStringAndSize(s, len - 1))) { + class = find_class(module_name, class_name, + self->find_class); + Py_DECREF(class_name); + } + } + Py_DECREF(module_name); - if (! class) return -1; + if (! class) return -1; - if ((tup=Pdata_popTuple(self->stack, i))) { - obj = Instance_New(class, tup); - Py_DECREF(tup); - } - Py_DECREF(class); + if ((tup=Pdata_popTuple(self->stack, i))) { + obj = Instance_New(class, tup); + Py_DECREF(tup); + } + Py_DECREF(class); - if (! obj) return -1; + if (! obj) return -1; - PDATA_PUSH(self->stack, obj, -1); - return 0; + PDATA_PUSH(self->stack, obj, -1); + return 0; } static int -load_global(Unpicklerobject *self) { - PyObject *class = 0, *module_name = 0, *class_name = 0; - int len; - char *s; - - if ((len = (*self->readline_func)(self, &s)) < 0) return -1; - if (len < 2) return bad_readline(); - if (!( module_name = PyString_FromStringAndSize(s, len - 1))) return -1; +load_global(Unpicklerobject *self) +{ + PyObject *class = 0, *module_name = 0, *class_name = 0; + int len; + char *s; - if ((len = (*self->readline_func)(self, &s)) >= 0) { - if (len < 2) return bad_readline(); - if ((class_name = PyString_FromStringAndSize(s, len - 1))) { - class = find_class(module_name, class_name, self->find_class); - Py_DECREF(class_name); - } - } - Py_DECREF(module_name); + if ((len = (*self->readline_func)(self, &s)) < 0) return -1; + if (len < 2) return bad_readline(); + module_name = PyString_FromStringAndSize(s, len - 1); + if (!module_name) return -1; + + if ((len = (*self->readline_func)(self, &s)) >= 0) { + if (len < 2) return bad_readline(); + if ((class_name = PyString_FromStringAndSize(s, len - 1))) { + class = find_class(module_name, class_name, + self->find_class); + Py_DECREF(class_name); + } + } + Py_DECREF(module_name); - if (! class) return -1; - PDATA_PUSH(self->stack, class, -1); - return 0; + if (! class) return -1; + PDATA_PUSH(self->stack, class, -1); + return 0; } static int -load_persid(Unpicklerobject *self) { - PyObject *pid = 0; - int len; - char *s; - - if (self->pers_func) { - if ((len = (*self->readline_func)(self, &s)) < 0) return -1; - if (len < 2) return bad_readline(); - - if (!( pid = PyString_FromStringAndSize(s, len - 1))) return -1; - - if (PyList_Check(self->pers_func)) { - if (PyList_Append(self->pers_func, pid) < 0) { - Py_DECREF(pid); - return -1; - } - } - else { - ARG_TUP(self, pid); - if (self->arg) { - pid = PyObject_Call(self->pers_func, self->arg, NULL); - FREE_ARG_TUP(self); - } - } - - if (! pid) return -1; - - PDATA_PUSH(self->stack, pid, -1); - return 0; - } - else { - PyErr_SetString(UnpicklingError, - "A load persistent id instruction was encountered,\n" - "but no persistent_load function was specified."); - return -1; - } +load_persid(Unpicklerobject *self) +{ + PyObject *pid = 0; + int len; + char *s; + + if (self->pers_func) { + if ((len = (*self->readline_func)(self, &s)) < 0) return -1; + if (len < 2) return bad_readline(); + + pid = PyString_FromStringAndSize(s, len - 1); + if (!pid) return -1; + + if (PyList_Check(self->pers_func)) { + if (PyList_Append(self->pers_func, pid) < 0) { + Py_DECREF(pid); + return -1; + } + } + else { + ARG_TUP(self, pid); + if (self->arg) { + pid = PyObject_Call(self->pers_func, self->arg, + NULL); + FREE_ARG_TUP(self); + } + } + + if (! pid) return -1; + + PDATA_PUSH(self->stack, pid, -1); + return 0; + } + else { + PyErr_SetString(UnpicklingError, + "A load persistent id instruction was encountered,\n" + "but no persistent_load function was specified."); + return -1; + } } static int -load_binpersid(Unpicklerobject *self) { - PyObject *pid = 0; - - if (self->pers_func) { - PDATA_POP(self->stack, pid); - if (! pid) return -1; - - if (PyList_Check(self->pers_func)) { - if (PyList_Append(self->pers_func, pid) < 0) { - Py_DECREF(pid); - return -1; - } - } - else { - ARG_TUP(self, pid); - if (self->arg) { - pid = PyObject_Call(self->pers_func, self->arg, NULL); - FREE_ARG_TUP(self); - } - if (! pid) return -1; - } - - PDATA_PUSH(self->stack, pid, -1); - return 0; - } - else { - PyErr_SetString(UnpicklingError, - "A load persistent id instruction was encountered,\n" - "but no persistent_load function was specified."); - return -1; - } +load_binpersid(Unpicklerobject *self) +{ + PyObject *pid = 0; + + if (self->pers_func) { + PDATA_POP(self->stack, pid); + if (! pid) return -1; + + if (PyList_Check(self->pers_func)) { + if (PyList_Append(self->pers_func, pid) < 0) { + Py_DECREF(pid); + return -1; + } + } + else { + ARG_TUP(self, pid); + if (self->arg) { + pid = PyObject_Call(self->pers_func, self->arg, + NULL); + FREE_ARG_TUP(self); + } + if (! pid) return -1; + } + + PDATA_PUSH(self->stack, pid, -1); + return 0; + } + else { + PyErr_SetString(UnpicklingError, + "A load persistent id instruction was encountered,\n" + "but no persistent_load function was specified."); + return -1; + } } static int -load_pop(Unpicklerobject *self) { - int len; - - if (!( (len=self->stack->length) > 0 )) return stackUnderflow(); - - /* Note that we split the (pickle.py) stack into two stacks, - an object stack and a mark stack. We have to be clever and - pop the right one. We do this by looking at the top of the - mark stack. - */ - - if ((self->num_marks > 0) && - (self->marks[self->num_marks - 1] == len)) - self->num_marks--; - else { - len--; - Py_DECREF(self->stack->data[len]); - self->stack->length=len; - } +load_pop(Unpicklerobject *self) +{ + int len; + + if (!( (len=self->stack->length) > 0 )) return stackUnderflow(); + + /* Note that we split the (pickle.py) stack into two stacks, + an object stack and a mark stack. We have to be clever and + pop the right one. We do this by looking at the top of the + mark stack. + */ + + if ((self->num_marks > 0) && + (self->marks[self->num_marks - 1] == len)) + self->num_marks--; + else { + len--; + Py_DECREF(self->stack->data[len]); + self->stack->length=len; + } - return 0; + return 0; } static int -load_pop_mark(Unpicklerobject *self) { - int i; +load_pop_mark(Unpicklerobject *self) +{ + int i; - if ((i = marker(self)) < 0) - return -1; + if ((i = marker(self)) < 0) + return -1; - Pdata_clear(self->stack, i); + Pdata_clear(self->stack, i); - return 0; + return 0; } static int -load_dup(Unpicklerobject *self) { - PyObject *last; - int len; +load_dup(Unpicklerobject *self) +{ + PyObject *last; + int len; - if ((len = self->stack->length) <= 0) return stackUnderflow(); - last=self->stack->data[len-1]; - Py_INCREF(last); - PDATA_PUSH(self->stack, last, -1); - return 0; + if ((len = self->stack->length) <= 0) return stackUnderflow(); + last=self->stack->data[len-1]; + Py_INCREF(last); + PDATA_PUSH(self->stack, last, -1); + return 0; } static int -load_get(Unpicklerobject *self) { - PyObject *py_str = 0, *value = 0; - int len; - char *s; - int rc; +load_get(Unpicklerobject *self) +{ + PyObject *py_str = 0, *value = 0; + int len; + char *s; + int rc; - if ((len = (*self->readline_func)(self, &s)) < 0) return -1; - if (len < 2) return bad_readline(); + if ((len = (*self->readline_func)(self, &s)) < 0) return -1; + if (len < 2) return bad_readline(); - if (!( py_str = PyString_FromStringAndSize(s, len - 1))) return -1; + if (!( py_str = PyString_FromStringAndSize(s, len - 1))) return -1; - value = PyDict_GetItem(self->memo, py_str); - if (! value) { - PyErr_SetObject(BadPickleGet, py_str); - rc = -1; - } else { - PDATA_APPEND(self->stack, value, -1); - rc = 0; - } + value = PyDict_GetItem(self->memo, py_str); + if (! value) { + PyErr_SetObject(BadPickleGet, py_str); + rc = -1; + } else { + PDATA_APPEND(self->stack, value, -1); + rc = 0; + } - Py_DECREF(py_str); - return rc; + Py_DECREF(py_str); + return rc; } static int -load_binget(Unpicklerobject *self) { - PyObject *py_key = 0, *value = 0; - unsigned char key; - char *s; - int rc; - - if ((*self->read_func)(self, &s, 1) < 0) return -1; - - key = (unsigned char)s[0]; - if (!( py_key = PyInt_FromLong((long)key))) return -1; - - value = PyDict_GetItem(self->memo, py_key); - if (! value) { - PyErr_SetObject(BadPickleGet, py_key); - rc = -1; - } else { - PDATA_APPEND(self->stack, value, -1); - rc = 0; - } +load_binget(Unpicklerobject *self) +{ + PyObject *py_key = 0, *value = 0; + unsigned char key; + char *s; + int rc; + + if ((*self->read_func)(self, &s, 1) < 0) return -1; + + key = (unsigned char)s[0]; + if (!( py_key = PyInt_FromLong((long)key))) return -1; + + value = PyDict_GetItem(self->memo, py_key); + if (! value) { + PyErr_SetObject(BadPickleGet, py_key); + rc = -1; + } else { + PDATA_APPEND(self->stack, value, -1); + rc = 0; + } - Py_DECREF(py_key); - return rc; + Py_DECREF(py_key); + return rc; } static int -load_long_binget(Unpicklerobject *self) { - PyObject *py_key = 0, *value = 0; - unsigned char c; - char *s; - long key; - int rc; - - if ((*self->read_func)(self, &s, 4) < 0) return -1; +load_long_binget(Unpicklerobject *self) +{ + PyObject *py_key = 0, *value = 0; + unsigned char c; + char *s; + long key; + int rc; + + if ((*self->read_func)(self, &s, 4) < 0) return -1; + + c = (unsigned char)s[0]; + key = (long)c; + c = (unsigned char)s[1]; + key |= (long)c << 8; + c = (unsigned char)s[2]; + key |= (long)c << 16; + c = (unsigned char)s[3]; + key |= (long)c << 24; + + if (!( py_key = PyInt_FromLong((long)key))) return -1; + + value = PyDict_GetItem(self->memo, py_key); + if (! value) { + PyErr_SetObject(BadPickleGet, py_key); + rc = -1; + } else { + PDATA_APPEND(self->stack, value, -1); + rc = 0; + } - c = (unsigned char)s[0]; - key = (long)c; - c = (unsigned char)s[1]; - key |= (long)c << 8; - c = (unsigned char)s[2]; - key |= (long)c << 16; - c = (unsigned char)s[3]; - key |= (long)c << 24; + Py_DECREF(py_key); + return rc; +} - if (!( py_key = PyInt_FromLong((long)key))) return -1; - value = PyDict_GetItem(self->memo, py_key); - if (! value) { - PyErr_SetObject(BadPickleGet, py_key); - rc = -1; - } else { - PDATA_APPEND(self->stack, value, -1); - rc = 0; - } +static int +load_put(Unpicklerobject *self) +{ + PyObject *py_str = 0, *value = 0; + int len, l; + char *s; - Py_DECREF(py_key); - return rc; + if ((l = (*self->readline_func)(self, &s)) < 0) return -1; + if (l < 2) return bad_readline(); + if (!( len=self->stack->length )) return stackUnderflow(); + if (!( py_str = PyString_FromStringAndSize(s, l - 1))) return -1; + value=self->stack->data[len-1]; + l=PyDict_SetItem(self->memo, py_str, value); + Py_DECREF(py_str); + return l; } static int -load_put(Unpicklerobject *self) { - PyObject *py_str = 0, *value = 0; - int len, l; - char *s; +load_binput(Unpicklerobject *self) +{ + PyObject *py_key = 0, *value = 0; + unsigned char key; + char *s; + int len; + + if ((*self->read_func)(self, &s, 1) < 0) return -1; + if (!( (len=self->stack->length) > 0 )) return stackUnderflow(); - if ((l = (*self->readline_func)(self, &s)) < 0) return -1; - if (l < 2) return bad_readline(); - if (!( len=self->stack->length )) return stackUnderflow(); - if (!( py_str = PyString_FromStringAndSize(s, l - 1))) return -1; - value=self->stack->data[len-1]; - l=PyDict_SetItem(self->memo, py_str, value); - Py_DECREF(py_str); - return l; + key = (unsigned char)s[0]; + + if (!( py_key = PyInt_FromLong((long)key))) return -1; + value=self->stack->data[len-1]; + len=PyDict_SetItem(self->memo, py_key, value); + Py_DECREF(py_key); + return len; } static int -load_binput(Unpicklerobject *self) { - PyObject *py_key = 0, *value = 0; - unsigned char key; - char *s; - int len; +load_long_binput(Unpicklerobject *self) +{ + PyObject *py_key = 0, *value = 0; + long key; + unsigned char c; + char *s; + int len; - if ((*self->read_func)(self, &s, 1) < 0) return -1; - if (!( (len=self->stack->length) > 0 )) return stackUnderflow(); + if ((*self->read_func)(self, &s, 4) < 0) return -1; + if (!( len=self->stack->length )) return stackUnderflow(); - key = (unsigned char)s[0]; + c = (unsigned char)s[0]; + key = (long)c; + c = (unsigned char)s[1]; + key |= (long)c << 8; + c = (unsigned char)s[2]; + key |= (long)c << 16; + c = (unsigned char)s[3]; + key |= (long)c << 24; - if (!( py_key = PyInt_FromLong((long)key))) return -1; - value=self->stack->data[len-1]; - len=PyDict_SetItem(self->memo, py_key, value); - Py_DECREF(py_key); - return len; + if (!( py_key = PyInt_FromLong(key))) return -1; + value=self->stack->data[len-1]; + len=PyDict_SetItem(self->memo, py_key, value); + Py_DECREF(py_key); + return len; } static int -load_long_binput(Unpicklerobject *self) { - PyObject *py_key = 0, *value = 0; - long key; - unsigned char c; - char *s; - int len; +do_append(Unpicklerobject *self, int x) +{ + PyObject *value = 0, *list = 0, *append_method = 0; + int len, i; - if ((*self->read_func)(self, &s, 4) < 0) return -1; - if (!( len=self->stack->length )) return stackUnderflow(); + len=self->stack->length; + if (!( len >= x && x > 0 )) return stackUnderflow(); + /* nothing to do */ + if (len==x) return 0; - c = (unsigned char)s[0]; - key = (long)c; - c = (unsigned char)s[1]; - key |= (long)c << 8; - c = (unsigned char)s[2]; - key |= (long)c << 16; - c = (unsigned char)s[3]; - key |= (long)c << 24; + list=self->stack->data[x-1]; - if (!( py_key = PyInt_FromLong(key))) return -1; - value=self->stack->data[len-1]; - len=PyDict_SetItem(self->memo, py_key, value); - Py_DECREF(py_key); - return len; -} + if (PyList_Check(list)) { + PyObject *slice; + int list_len; + slice=Pdata_popList(self->stack, x); + list_len = PyList_GET_SIZE(list); + i=PyList_SetSlice(list, list_len, list_len, slice); + Py_DECREF(slice); + return i; + } + else { + + if (!( append_method = PyObject_GetAttr(list, append_str))) + return -1; + + for (i = x; i < len; i++) { + PyObject *junk; + + value=self->stack->data[i]; + junk=0; + ARG_TUP(self, value); + if (self->arg) { + junk = PyObject_Call(append_method, self->arg, + NULL); + FREE_ARG_TUP(self); + } + if (! junk) { + Pdata_clear(self->stack, i+1); + self->stack->length=x; + Py_DECREF(append_method); + return -1; + } + Py_DECREF(junk); + } + self->stack->length=x; + Py_DECREF(append_method); + } -static int -do_append(Unpicklerobject *self, int x) { - PyObject *value = 0, *list = 0, *append_method = 0; - int len, i; - - if (!( (len=self->stack->length) >= x && x > 0 )) return stackUnderflow(); - if (len==x) return 0; /* nothing to do */ - - list=self->stack->data[x-1]; - - if (PyList_Check(list)) { - PyObject *slice; - int list_len; - - slice=Pdata_popList(self->stack, x); - list_len = PyList_GET_SIZE(list); - i=PyList_SetSlice(list, list_len, list_len, slice); - Py_DECREF(slice); - return i; - } - else { - - if (!( append_method = PyObject_GetAttr(list, append_str))) - return -1; - - for (i = x; i < len; i++) { - PyObject *junk; - - value=self->stack->data[i]; - junk=0; - ARG_TUP(self, value); - if (self->arg) { - junk = PyObject_Call(append_method, self->arg, NULL); - FREE_ARG_TUP(self); - } - if (! junk) { - Pdata_clear(self->stack, i+1); - self->stack->length=x; - Py_DECREF(append_method); - return -1; - } - Py_DECREF(junk); - } - self->stack->length=x; - Py_DECREF(append_method); - } - - return 0; + return 0; } static int -load_append(Unpicklerobject *self) { - return do_append(self, self->stack->length - 1); +load_append(Unpicklerobject *self) +{ + return do_append(self, self->stack->length - 1); } static int -load_appends(Unpicklerobject *self) { - return do_append(self, marker(self)); +load_appends(Unpicklerobject *self) +{ + return do_append(self, marker(self)); } static int -do_setitems(Unpicklerobject *self, int x) { - PyObject *value = 0, *key = 0, *dict = 0; - int len, i, r=0; +do_setitems(Unpicklerobject *self, int x) +{ + PyObject *value = 0, *key = 0, *dict = 0; + int len, i, r=0; - if (!( (len=self->stack->length) >= x - && x > 0 )) return stackUnderflow(); + if (!( (len=self->stack->length) >= x + && x > 0 )) return stackUnderflow(); - dict=self->stack->data[x-1]; + dict=self->stack->data[x-1]; - for (i = x+1; i < len; i += 2) { - key =self->stack->data[i-1]; - value=self->stack->data[i ]; - if (PyObject_SetItem(dict, key, value) < 0) { - r=-1; - break; - } - } + for (i = x+1; i < len; i += 2) { + key =self->stack->data[i-1]; + value=self->stack->data[i ]; + if (PyObject_SetItem(dict, key, value) < 0) { + r=-1; + break; + } + } - Pdata_clear(self->stack, x); + Pdata_clear(self->stack, x); - return r; + return r; } static int -load_setitem(Unpicklerobject *self) { - return do_setitems(self, self->stack->length - 2); +load_setitem(Unpicklerobject *self) +{ + return do_setitems(self, self->stack->length - 2); } static int -load_setitems(Unpicklerobject *self) { - return do_setitems(self, marker(self)); +load_setitems(Unpicklerobject *self) +{ + return do_setitems(self, marker(self)); } static int -load_build(Unpicklerobject *self) { - PyObject *value = 0, *inst = 0, *instdict = 0, *d_key = 0, *d_value = 0, - *junk = 0, *__setstate__ = 0; - int i, r = 0; - - if (self->stack->length < 2) return stackUnderflow(); - PDATA_POP(self->stack, value); - if (! value) return -1; - inst=self->stack->data[self->stack->length-1]; - - if ((__setstate__ = PyObject_GetAttr(inst, __setstate___str))) { - ARG_TUP(self, value); - if (self->arg) { - junk = PyObject_Call(__setstate__, self->arg, NULL); - FREE_ARG_TUP(self); - } - Py_DECREF(__setstate__); - if (! junk) return -1; - Py_DECREF(junk); - return 0; - } - - PyErr_Clear(); - if ((instdict = PyObject_GetAttr(inst, __dict___str))) { - i = 0; - while (PyDict_Next(value, &i, &d_key, &d_value)) { - if (PyObject_SetItem(instdict, d_key, d_value) < 0) { - r=-1; - break; - } - } - Py_DECREF(instdict); - } - else r=-1; - - Py_XDECREF(value); - - return r; -} +load_build(Unpicklerobject *self) +{ + PyObject *value = 0, *inst = 0, *instdict = 0, *d_key = 0, *d_value = 0, + *junk = 0, *__setstate__ = 0; + int i, r = 0; + + if (self->stack->length < 2) return stackUnderflow(); + PDATA_POP(self->stack, value); + if (! value) return -1; + inst=self->stack->data[self->stack->length-1]; + + if ((__setstate__ = PyObject_GetAttr(inst, __setstate___str))) { + ARG_TUP(self, value); + if (self->arg) { + junk = PyObject_Call(__setstate__, self->arg, NULL); + FREE_ARG_TUP(self); + } + Py_DECREF(__setstate__); + if (! junk) return -1; + Py_DECREF(junk); + return 0; + } + PyErr_Clear(); + if ((instdict = PyObject_GetAttr(inst, __dict___str))) { + i = 0; + while (PyDict_Next(value, &i, &d_key, &d_value)) { + if (PyObject_SetItem(instdict, d_key, d_value) < 0) { + r=-1; + break; + } + } + Py_DECREF(instdict); + } + else r=-1; -static int -load_mark(Unpicklerobject *self) { - int s; + Py_XDECREF(value); + + return r; +} - /* Note that we split the (pickle.py) stack into two stacks, an - object stack and a mark stack. Here we push a mark onto the - mark stack. - */ - if ((self->num_marks + 1) >= self->marks_size) { - s=self->marks_size+20; - if (s <= self->num_marks) s=self->num_marks + 1; - if (self->marks == NULL) - self->marks=(int *)malloc(s * sizeof(int)); - else - self->marks=(int *)realloc(self->marks, s * sizeof(int)); - if (! self->marks) { - PyErr_NoMemory(); - return -1; - } - self->marks_size = s; - } +static int +load_mark(Unpicklerobject *self) +{ + int s; + + /* Note that we split the (pickle.py) stack into two stacks, an + object stack and a mark stack. Here we push a mark onto the + mark stack. + */ + + if ((self->num_marks + 1) >= self->marks_size) { + s=self->marks_size+20; + if (s <= self->num_marks) s=self->num_marks + 1; + if (self->marks == NULL) + self->marks=(int *)malloc(s * sizeof(int)); + else + self->marks=(int *)realloc(self->marks, + s * sizeof(int)); + if (! self->marks) { + PyErr_NoMemory(); + return -1; + } + self->marks_size = s; + } - self->marks[self->num_marks++] = self->stack->length; + self->marks[self->num_marks++] = self->stack->length; - return 0; + return 0; } static int -load_reduce(Unpicklerobject *self) { - PyObject *callable = 0, *arg_tup = 0, *ob = 0; - - PDATA_POP(self->stack, arg_tup); - if (! arg_tup) return -1; - PDATA_POP(self->stack, callable); - if (callable) { - ob = Instance_New(callable, arg_tup); - Py_DECREF(callable); - } - Py_DECREF(arg_tup); +load_reduce(Unpicklerobject *self) +{ + PyObject *callable = 0, *arg_tup = 0, *ob = 0; + + PDATA_POP(self->stack, arg_tup); + if (! arg_tup) return -1; + PDATA_POP(self->stack, callable); + if (callable) { + ob = Instance_New(callable, arg_tup); + Py_DECREF(callable); + } + Py_DECREF(arg_tup); - if (! ob) return -1; + if (! ob) return -1; - PDATA_PUSH(self->stack, ob, -1); - return 0; + PDATA_PUSH(self->stack, ob, -1); + return 0; } static PyObject * -load(Unpicklerobject *self) { - PyObject *err = 0, *val = 0; - char *s; - - self->num_marks = 0; - if (self->stack->length) Pdata_clear(self->stack, 0); - - while (1) { - if ((*self->read_func)(self, &s, 1) < 0) - break; - - switch (s[0]) { - case NONE: - if (load_none(self) < 0) - break; - continue; - - case BININT: - if (load_binint(self) < 0) - break; - continue; - - case BININT1: - if (load_binint1(self) < 0) - break; - continue; - - case BININT2: - if (load_binint2(self) < 0) - break; - continue; - - case INT: - if (load_int(self) < 0) - break; - continue; - - case LONG: - if (load_long(self) < 0) - break; - continue; - - case FLOAT: - if (load_float(self) < 0) - break; - continue; - - case BINFLOAT: - if (load_binfloat(self) < 0) - break; - continue; - - case BINSTRING: - if (load_binstring(self) < 0) - break; - continue; - - case SHORT_BINSTRING: - if (load_short_binstring(self) < 0) - break; - continue; - - case STRING: - if (load_string(self) < 0) - break; - continue; +load(Unpicklerobject *self) +{ + PyObject *err = 0, *val = 0; + char *s; + + self->num_marks = 0; + if (self->stack->length) Pdata_clear(self->stack, 0); + + while (1) { + if ((*self->read_func)(self, &s, 1) < 0) + break; + + switch (s[0]) { + case NONE: + if (load_none(self) < 0) + break; + continue; + + case BININT: + if (load_binint(self) < 0) + break; + continue; + + case BININT1: + if (load_binint1(self) < 0) + break; + continue; + + case BININT2: + if (load_binint2(self) < 0) + break; + continue; + + case INT: + if (load_int(self) < 0) + break; + continue; + + case LONG: + if (load_long(self) < 0) + break; + continue; + + case FLOAT: + if (load_float(self) < 0) + break; + continue; + + case BINFLOAT: + if (load_binfloat(self) < 0) + break; + continue; + + case BINSTRING: + if (load_binstring(self) < 0) + break; + continue; + + case SHORT_BINSTRING: + if (load_short_binstring(self) < 0) + break; + continue; + + case STRING: + if (load_string(self) < 0) + break; + continue; #ifdef Py_USING_UNICODE - case UNICODE: - if (load_unicode(self) < 0) - break; - continue; - - case BINUNICODE: - if (load_binunicode(self) < 0) - break; - continue; + case UNICODE: + if (load_unicode(self) < 0) + break; + continue; + + case BINUNICODE: + if (load_binunicode(self) < 0) + break; + continue; #endif - case EMPTY_TUPLE: - if (load_empty_tuple(self) < 0) - break; - continue; - - case TUPLE: - if (load_tuple(self) < 0) - break; - continue; - - case EMPTY_LIST: - if (load_empty_list(self) < 0) - break; - continue; - - case LIST: - if (load_list(self) < 0) - break; - continue; - - case EMPTY_DICT: - if (load_empty_dict(self) < 0) - break; - continue; - - case DICT: - if (load_dict(self) < 0) - break; - continue; - - case OBJ: - if (load_obj(self) < 0) - break; - continue; - - case INST: - if (load_inst(self) < 0) - break; - continue; - - case GLOBAL: - if (load_global(self) < 0) - break; - continue; - - case APPEND: - if (load_append(self) < 0) - break; - continue; - - case APPENDS: - if (load_appends(self) < 0) - break; - continue; - - case BUILD: - if (load_build(self) < 0) - break; - continue; - - case DUP: - if (load_dup(self) < 0) - break; - continue; - - case BINGET: - if (load_binget(self) < 0) - break; - continue; - - case LONG_BINGET: - if (load_long_binget(self) < 0) - break; - continue; - - case GET: - if (load_get(self) < 0) - break; - continue; - - case MARK: - if (load_mark(self) < 0) - break; - continue; - - case BINPUT: - if (load_binput(self) < 0) - break; - continue; - - case LONG_BINPUT: - if (load_long_binput(self) < 0) - break; - continue; - - case PUT: - if (load_put(self) < 0) - break; - continue; - - case POP: - if (load_pop(self) < 0) - break; - continue; - - case POP_MARK: - if (load_pop_mark(self) < 0) - break; - continue; - - case SETITEM: - if (load_setitem(self) < 0) - break; - continue; - - case SETITEMS: - if (load_setitems(self) < 0) - break; - continue; - - case STOP: - break; - - case PERSID: - if (load_persid(self) < 0) - break; - continue; - - case BINPERSID: - if (load_binpersid(self) < 0) - break; - continue; - - case REDUCE: - if (load_reduce(self) < 0) - break; - continue; - - case '\0': - /* end of file */ - PyErr_SetNone(PyExc_EOFError); - break; + case EMPTY_TUPLE: + if (load_empty_tuple(self) < 0) + break; + continue; + + case TUPLE: + if (load_tuple(self) < 0) + break; + continue; + + case EMPTY_LIST: + if (load_empty_list(self) < 0) + break; + continue; + + case LIST: + if (load_list(self) < 0) + break; + continue; + + case EMPTY_DICT: + if (load_empty_dict(self) < 0) + break; + continue; + + case DICT: + if (load_dict(self) < 0) + break; + continue; + + case OBJ: + if (load_obj(self) < 0) + break; + continue; + + case INST: + if (load_inst(self) < 0) + break; + continue; + + case GLOBAL: + if (load_global(self) < 0) + break; + continue; + + case APPEND: + if (load_append(self) < 0) + break; + continue; + + case APPENDS: + if (load_appends(self) < 0) + break; + continue; + + case BUILD: + if (load_build(self) < 0) + break; + continue; + + case DUP: + if (load_dup(self) < 0) + break; + continue; + + case BINGET: + if (load_binget(self) < 0) + break; + continue; + + case LONG_BINGET: + if (load_long_binget(self) < 0) + break; + continue; + + case GET: + if (load_get(self) < 0) + break; + continue; + + case MARK: + if (load_mark(self) < 0) + break; + continue; + + case BINPUT: + if (load_binput(self) < 0) + break; + continue; + + case LONG_BINPUT: + if (load_long_binput(self) < 0) + break; + continue; + + case PUT: + if (load_put(self) < 0) + break; + continue; + + case POP: + if (load_pop(self) < 0) + break; + continue; + + case POP_MARK: + if (load_pop_mark(self) < 0) + break; + continue; + + case SETITEM: + if (load_setitem(self) < 0) + break; + continue; + + case SETITEMS: + if (load_setitems(self) < 0) + break; + continue; + + case STOP: + break; + + case PERSID: + if (load_persid(self) < 0) + break; + continue; + + case BINPERSID: + if (load_binpersid(self) < 0) + break; + continue; + + case REDUCE: + if (load_reduce(self) < 0) + break; + continue; + + case '\0': + /* end of file */ + PyErr_SetNone(PyExc_EOFError); + break; - default: - cPickle_ErrFormat(UnpicklingError, "invalid load key, '%s'.", - "c", s[0]); - return NULL; - } - - break; - } + default: + cPickle_ErrFormat(UnpicklingError, + "invalid load key, '%s'.", + "c", s[0]); + return NULL; + } + + break; + } - if ((err = PyErr_Occurred())) { - if (err == PyExc_EOFError) { - PyErr_SetNone(PyExc_EOFError); - } - return NULL; - } + if ((err = PyErr_Occurred())) { + if (err == PyExc_EOFError) { + PyErr_SetNone(PyExc_EOFError); + } + return NULL; + } - PDATA_POP(self->stack, val); - return val; + PDATA_POP(self->stack, val); + return val; } @@ -3873,44 +4008,48 @@ load(Unpicklerobject *self) { find persistent references. */ static int -noload_obj(Unpicklerobject *self) { - int i; +noload_obj(Unpicklerobject *self) +{ + int i; - if ((i = marker(self)) < 0) return -1; - return Pdata_clear(self->stack, i+1); + if ((i = marker(self)) < 0) return -1; + return Pdata_clear(self->stack, i+1); } static int -noload_inst(Unpicklerobject *self) { - int i; - char *s; - - if ((i = marker(self)) < 0) return -1; - Pdata_clear(self->stack, i); - if ((*self->readline_func)(self, &s) < 0) return -1; - if ((*self->readline_func)(self, &s) < 0) return -1; - PDATA_APPEND(self->stack, Py_None,-1); - return 0; +noload_inst(Unpicklerobject *self) +{ + int i; + char *s; + + if ((i = marker(self)) < 0) return -1; + Pdata_clear(self->stack, i); + if ((*self->readline_func)(self, &s) < 0) return -1; + if ((*self->readline_func)(self, &s) < 0) return -1; + PDATA_APPEND(self->stack, Py_None,-1); + return 0; } static int -noload_global(Unpicklerobject *self) { - char *s; +noload_global(Unpicklerobject *self) +{ + char *s; - if ((*self->readline_func)(self, &s) < 0) return -1; - if ((*self->readline_func)(self, &s) < 0) return -1; - PDATA_APPEND(self->stack, Py_None,-1); - return 0; + if ((*self->readline_func)(self, &s) < 0) return -1; + if ((*self->readline_func)(self, &s) < 0) return -1; + PDATA_APPEND(self->stack, Py_None,-1); + return 0; } static int -noload_reduce(Unpicklerobject *self) { +noload_reduce(Unpicklerobject *self) +{ - if (self->stack->length < 2) return stackUnderflow(); - Pdata_clear(self->stack, self->stack->length-2); - PDATA_APPEND(self->stack, Py_None,-1); - return 0; + if (self->stack->length < 2) return stackUnderflow(); + Pdata_clear(self->stack, self->stack->length-2); + PDATA_APPEND(self->stack, Py_None,-1); + return 0; } static int @@ -3923,258 +4062,262 @@ noload_build(Unpicklerobject *self) { static PyObject * -noload(Unpicklerobject *self) { - PyObject *err = 0, *val = 0; - char *s; - - self->num_marks = 0; - Pdata_clear(self->stack, 0); - - while (1) { - if ((*self->read_func)(self, &s, 1) < 0) - break; - - switch (s[0]) { - case NONE: - if (load_none(self) < 0) - break; - continue; - - case BININT: - if (load_binint(self) < 0) - break; - continue; - - case BININT1: - if (load_binint1(self) < 0) - break; - continue; - - case BININT2: - if (load_binint2(self) < 0) - break; - continue; - - case INT: - if (load_int(self) < 0) - break; - continue; - - case LONG: - if (load_long(self) < 0) - break; - continue; - - case FLOAT: - if (load_float(self) < 0) - break; - continue; - - case BINFLOAT: - if (load_binfloat(self) < 0) - break; - continue; - - case BINSTRING: - if (load_binstring(self) < 0) - break; - continue; - - case SHORT_BINSTRING: - if (load_short_binstring(self) < 0) - break; - continue; - - case STRING: - if (load_string(self) < 0) - break; - continue; +noload(Unpicklerobject *self) +{ + PyObject *err = 0, *val = 0; + char *s; + + self->num_marks = 0; + Pdata_clear(self->stack, 0); + + while (1) { + if ((*self->read_func)(self, &s, 1) < 0) + break; + + switch (s[0]) { + case NONE: + if (load_none(self) < 0) + break; + continue; + + case BININT: + if (load_binint(self) < 0) + break; + continue; + + case BININT1: + if (load_binint1(self) < 0) + break; + continue; + + case BININT2: + if (load_binint2(self) < 0) + break; + continue; + + case INT: + if (load_int(self) < 0) + break; + continue; + + case LONG: + if (load_long(self) < 0) + break; + continue; + + case FLOAT: + if (load_float(self) < 0) + break; + continue; + + case BINFLOAT: + if (load_binfloat(self) < 0) + break; + continue; + + case BINSTRING: + if (load_binstring(self) < 0) + break; + continue; + + case SHORT_BINSTRING: + if (load_short_binstring(self) < 0) + break; + continue; + + case STRING: + if (load_string(self) < 0) + break; + continue; #ifdef Py_USING_UNICODE - case UNICODE: - if (load_unicode(self) < 0) - break; - continue; - - case BINUNICODE: - if (load_binunicode(self) < 0) - break; - continue; + case UNICODE: + if (load_unicode(self) < 0) + break; + continue; + + case BINUNICODE: + if (load_binunicode(self) < 0) + break; + continue; #endif - case EMPTY_TUPLE: - if (load_empty_tuple(self) < 0) - break; - continue; - - case TUPLE: - if (load_tuple(self) < 0) - break; - continue; - - case EMPTY_LIST: - if (load_empty_list(self) < 0) - break; - continue; - - case LIST: - if (load_list(self) < 0) - break; - continue; - - case EMPTY_DICT: - if (load_empty_dict(self) < 0) - break; - continue; - - case DICT: - if (load_dict(self) < 0) - break; - continue; - - case OBJ: - if (noload_obj(self) < 0) - break; - continue; - - case INST: - if (noload_inst(self) < 0) - break; - continue; - - case GLOBAL: - if (noload_global(self) < 0) - break; - continue; - - case APPEND: - if (load_append(self) < 0) - break; - continue; - - case APPENDS: - if (load_appends(self) < 0) - break; - continue; - - case BUILD: - if (noload_build(self) < 0) - break; - continue; - - case DUP: - if (load_dup(self) < 0) - break; - continue; - - case BINGET: - if (load_binget(self) < 0) - break; - continue; - - case LONG_BINGET: - if (load_long_binget(self) < 0) - break; - continue; - - case GET: - if (load_get(self) < 0) - break; - continue; - - case MARK: - if (load_mark(self) < 0) - break; - continue; - - case BINPUT: - if (load_binput(self) < 0) - break; - continue; - - case LONG_BINPUT: - if (load_long_binput(self) < 0) - break; - continue; - - case PUT: - if (load_put(self) < 0) - break; - continue; - - case POP: - if (load_pop(self) < 0) - break; - continue; - - case POP_MARK: - if (load_pop_mark(self) < 0) - break; - continue; - - case SETITEM: - if (load_setitem(self) < 0) - break; - continue; - - case SETITEMS: - if (load_setitems(self) < 0) - break; - continue; - - case STOP: - break; - - case PERSID: - if (load_persid(self) < 0) - break; - continue; - - case BINPERSID: - if (load_binpersid(self) < 0) - break; - continue; - - case REDUCE: - if (noload_reduce(self) < 0) - break; - continue; - - default: - cPickle_ErrFormat(UnpicklingError, "invalid load key, '%s'.", - "c", s[0]); - return NULL; - } - - break; - } - - if ((err = PyErr_Occurred())) { - if (err == PyExc_EOFError) { - PyErr_SetNone(PyExc_EOFError); - } - return NULL; - } - - PDATA_POP(self->stack, val); - return val; + case EMPTY_TUPLE: + if (load_empty_tuple(self) < 0) + break; + continue; + + case TUPLE: + if (load_tuple(self) < 0) + break; + continue; + + case EMPTY_LIST: + if (load_empty_list(self) < 0) + break; + continue; + + case LIST: + if (load_list(self) < 0) + break; + continue; + + case EMPTY_DICT: + if (load_empty_dict(self) < 0) + break; + continue; + + case DICT: + if (load_dict(self) < 0) + break; + continue; + + case OBJ: + if (noload_obj(self) < 0) + break; + continue; + + case INST: + if (noload_inst(self) < 0) + break; + continue; + + case GLOBAL: + if (noload_global(self) < 0) + break; + continue; + + case APPEND: + if (load_append(self) < 0) + break; + continue; + + case APPENDS: + if (load_appends(self) < 0) + break; + continue; + + case BUILD: + if (noload_build(self) < 0) + break; + continue; + + case DUP: + if (load_dup(self) < 0) + break; + continue; + + case BINGET: + if (load_binget(self) < 0) + break; + continue; + + case LONG_BINGET: + if (load_long_binget(self) < 0) + break; + continue; + + case GET: + if (load_get(self) < 0) + break; + continue; + + case MARK: + if (load_mark(self) < 0) + break; + continue; + + case BINPUT: + if (load_binput(self) < 0) + break; + continue; + + case LONG_BINPUT: + if (load_long_binput(self) < 0) + break; + continue; + + case PUT: + if (load_put(self) < 0) + break; + continue; + + case POP: + if (load_pop(self) < 0) + break; + continue; + + case POP_MARK: + if (load_pop_mark(self) < 0) + break; + continue; + + case SETITEM: + if (load_setitem(self) < 0) + break; + continue; + + case SETITEMS: + if (load_setitems(self) < 0) + break; + continue; + + case STOP: + break; + + case PERSID: + if (load_persid(self) < 0) + break; + continue; + + case BINPERSID: + if (load_binpersid(self) < 0) + break; + continue; + + case REDUCE: + if (noload_reduce(self) < 0) + break; + continue; + + default: + cPickle_ErrFormat(UnpicklingError, + "invalid load key, '%s'.", + "c", s[0]); + return NULL; + } + + break; + } + + if ((err = PyErr_Occurred())) { + if (err == PyExc_EOFError) { + PyErr_SetNone(PyExc_EOFError); + } + return NULL; + } + + PDATA_POP(self->stack, val); + return val; } static PyObject * -Unpickler_load(Unpicklerobject *self, PyObject *args) { - if (!( PyArg_ParseTuple(args, ":load"))) - return NULL; +Unpickler_load(Unpicklerobject *self, PyObject *args) +{ + if (!( PyArg_ParseTuple(args, ":load"))) + return NULL; - return load(self); + return load(self); } static PyObject * -Unpickler_noload(Unpicklerobject *self, PyObject *args) { - if (!( PyArg_ParseTuple(args, ":noload"))) - return NULL; +Unpickler_noload(Unpicklerobject *self, PyObject *args) +{ + if (!( PyArg_ParseTuple(args, ":noload"))) + return NULL; - return noload(self); + return noload(self); } @@ -4195,292 +4338,305 @@ static struct PyMethodDef Unpickler_methods[] = { static Unpicklerobject * -newUnpicklerobject(PyObject *f) { - Unpicklerobject *self; - - if (!( self = PyObject_New(Unpicklerobject, &Unpicklertype))) - return NULL; - - self->file = NULL; - self->arg = NULL; - self->stack = (Pdata*)Pdata_New(); - self->pers_func = NULL; - self->last_string = NULL; - self->marks = NULL; - self->num_marks = 0; - self->marks_size = 0; - self->buf_size = 0; - self->read = NULL; - self->readline = NULL; - self->safe_constructors = NULL; - self->find_class = NULL; - - if (!( self->memo = PyDict_New())) - goto err; - - Py_INCREF(f); - self->file = f; - - /* Set read, readline based on type of f */ - if (PyFile_Check(f)) { - self->fp = PyFile_AsFile(f); - if (self->fp == NULL) { - PyErr_SetString(PyExc_ValueError, "I/O operation on closed file"); - goto err; - } - self->read_func = read_file; - self->readline_func = readline_file; - } - else if (PycStringIO_InputCheck(f)) { - self->fp = NULL; - self->read_func = read_cStringIO; - self->readline_func = readline_cStringIO; - } - else { - - self->fp = NULL; - self->read_func = read_other; - self->readline_func = readline_other; - - if (!( (self->readline = PyObject_GetAttr(f, readline_str)) && - (self->read = PyObject_GetAttr(f, read_str)))) { - PyErr_Clear(); - PyErr_SetString( PyExc_TypeError, "argument must have 'read' and " - "'readline' attributes" ); - goto err; - } - } - - if (PyEval_GetRestricted()) { - /* Restricted execution, get private tables */ - PyObject *m; - - if (!( m=PyImport_Import(copy_reg_str))) goto err; - self->safe_constructors=PyObject_GetAttr(m, safe_constructors_str); - Py_DECREF(m); - if (!( self->safe_constructors )) goto err; - } - else { - self->safe_constructors=safe_constructors; - Py_INCREF(safe_constructors); - } - - return self; - -err: - Py_DECREF((PyObject *)self); - return NULL; +newUnpicklerobject(PyObject *f) +{ + Unpicklerobject *self; + + if (!( self = PyObject_New(Unpicklerobject, &Unpicklertype))) + return NULL; + + self->file = NULL; + self->arg = NULL; + self->stack = (Pdata*)Pdata_New(); + self->pers_func = NULL; + self->last_string = NULL; + self->marks = NULL; + self->num_marks = 0; + self->marks_size = 0; + self->buf_size = 0; + self->read = NULL; + self->readline = NULL; + self->safe_constructors = NULL; + self->find_class = NULL; + + if (!( self->memo = PyDict_New())) + goto err; + + Py_INCREF(f); + self->file = f; + + /* Set read, readline based on type of f */ + if (PyFile_Check(f)) { + self->fp = PyFile_AsFile(f); + if (self->fp == NULL) { + PyErr_SetString(PyExc_ValueError, + "I/O operation on closed file"); + goto err; + } + self->read_func = read_file; + self->readline_func = readline_file; + } + else if (PycStringIO_InputCheck(f)) { + self->fp = NULL; + self->read_func = read_cStringIO; + self->readline_func = readline_cStringIO; + } + else { + + self->fp = NULL; + self->read_func = read_other; + self->readline_func = readline_other; + + if (!( (self->readline = PyObject_GetAttr(f, readline_str)) && + (self->read = PyObject_GetAttr(f, read_str)))) { + PyErr_Clear(); + PyErr_SetString( PyExc_TypeError, + "argument must have 'read' and " + "'readline' attributes" ); + goto err; + } + } + + if (PyEval_GetRestricted()) { + /* Restricted execution, get private tables */ + PyObject *m; + + if (!( m=PyImport_Import(copy_reg_str))) goto err; + self->safe_constructors=PyObject_GetAttr(m, + safe_constructors_str); + Py_DECREF(m); + if (!( self->safe_constructors )) goto err; + } + else { + self->safe_constructors=safe_constructors; + Py_INCREF(safe_constructors); + } + + return self; + + err: + Py_DECREF((PyObject *)self); + return NULL; } static PyObject * -get_Unpickler(PyObject *self, PyObject *args) { - PyObject *file; +get_Unpickler(PyObject *self, PyObject *args) +{ + PyObject *file; - if (!( PyArg_ParseTuple(args, "O:Unpickler", &file))) - return NULL; - return (PyObject *)newUnpicklerobject(file); + if (!( PyArg_ParseTuple(args, "O:Unpickler", &file))) + return NULL; + return (PyObject *)newUnpicklerobject(file); } static void -Unpickler_dealloc(Unpicklerobject *self) { - Py_XDECREF(self->readline); - Py_XDECREF(self->read); - Py_XDECREF(self->file); - Py_XDECREF(self->memo); - Py_XDECREF(self->stack); - Py_XDECREF(self->pers_func); - Py_XDECREF(self->arg); - Py_XDECREF(self->last_string); - Py_XDECREF(self->safe_constructors); - - if (self->marks) { - free(self->marks); - } +Unpickler_dealloc(Unpicklerobject *self) +{ + Py_XDECREF(self->readline); + Py_XDECREF(self->read); + Py_XDECREF(self->file); + Py_XDECREF(self->memo); + Py_XDECREF(self->stack); + Py_XDECREF(self->pers_func); + Py_XDECREF(self->arg); + Py_XDECREF(self->last_string); + Py_XDECREF(self->safe_constructors); + + if (self->marks) { + free(self->marks); + } - if (self->buf_size) { - free(self->buf); - } + if (self->buf_size) { + free(self->buf); + } - PyObject_Del(self); + PyObject_Del(self); } static PyObject * -Unpickler_getattr(Unpicklerobject *self, char *name) { - if (!strcmp(name, "persistent_load")) { - if (!self->pers_func) { - PyErr_SetString(PyExc_AttributeError, name); - return NULL; - } - - Py_INCREF(self->pers_func); - return self->pers_func; - } +Unpickler_getattr(Unpicklerobject *self, char *name) +{ + if (!strcmp(name, "persistent_load")) { + if (!self->pers_func) { + PyErr_SetString(PyExc_AttributeError, name); + return NULL; + } + + Py_INCREF(self->pers_func); + return self->pers_func; + } - if (!strcmp(name, "find_global")) { - if (!self->find_class) { - PyErr_SetString(PyExc_AttributeError, name); - return NULL; - } + if (!strcmp(name, "find_global")) { + if (!self->find_class) { + PyErr_SetString(PyExc_AttributeError, name); + return NULL; + } - Py_INCREF(self->find_class); - return self->find_class; - } + Py_INCREF(self->find_class); + return self->find_class; + } - if (!strcmp(name, "memo")) { - if (!self->memo) { - PyErr_SetString(PyExc_AttributeError, name); - return NULL; - } + if (!strcmp(name, "memo")) { + if (!self->memo) { + PyErr_SetString(PyExc_AttributeError, name); + return NULL; + } - Py_INCREF(self->memo); - return self->memo; - } + Py_INCREF(self->memo); + return self->memo; + } - if (!strcmp(name, "UnpicklingError")) { - Py_INCREF(UnpicklingError); - return UnpicklingError; - } + if (!strcmp(name, "UnpicklingError")) { + Py_INCREF(UnpicklingError); + return UnpicklingError; + } - return Py_FindMethod(Unpickler_methods, (PyObject *)self, name); + return Py_FindMethod(Unpickler_methods, (PyObject *)self, name); } static int -Unpickler_setattr(Unpicklerobject *self, char *name, PyObject *value) { - - if (!strcmp(name, "persistent_load")) { - Py_XDECREF(self->pers_func); - self->pers_func = value; - Py_XINCREF(value); - return 0; - } - - if (!strcmp(name, "find_global")) { - Py_XDECREF(self->find_class); - self->find_class = value; - Py_XINCREF(value); - return 0; - } - - if (! value) { - PyErr_SetString(PyExc_TypeError, - "attribute deletion is not supported"); - return -1; - } - - if (strcmp(name, "memo") == 0) { - if (!PyDict_Check(value)) { - PyErr_SetString(PyExc_TypeError, "memo must be a dictionary"); - return -1; - } - Py_XDECREF(self->memo); - self->memo = value; - Py_INCREF(value); - return 0; - } - - PyErr_SetString(PyExc_AttributeError, name); - return -1; +Unpickler_setattr(Unpicklerobject *self, char *name, PyObject *value) +{ + + if (!strcmp(name, "persistent_load")) { + Py_XDECREF(self->pers_func); + self->pers_func = value; + Py_XINCREF(value); + return 0; + } + + if (!strcmp(name, "find_global")) { + Py_XDECREF(self->find_class); + self->find_class = value; + Py_XINCREF(value); + return 0; + } + + if (! value) { + PyErr_SetString(PyExc_TypeError, + "attribute deletion is not supported"); + return -1; + } + + if (strcmp(name, "memo") == 0) { + if (!PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "memo must be a dictionary"); + return -1; + } + Py_XDECREF(self->memo); + self->memo = value; + Py_INCREF(value); + return 0; + } + + PyErr_SetString(PyExc_AttributeError, name); + return -1; } static PyObject * -cpm_dump(PyObject *self, PyObject *args) { - PyObject *ob, *file, *res = NULL; - Picklerobject *pickler = 0; - int bin = 0; +cpm_dump(PyObject *self, PyObject *args) +{ + PyObject *ob, *file, *res = NULL; + Picklerobject *pickler = 0; + int bin = 0; - if (!( PyArg_ParseTuple(args, "OO|i", &ob, &file, &bin))) - goto finally; + if (!( PyArg_ParseTuple(args, "OO|i", &ob, &file, &bin))) + goto finally; - if (!( pickler = newPicklerobject(file, bin))) - goto finally; + if (!( pickler = newPicklerobject(file, bin))) + goto finally; - if (dump(pickler, ob) < 0) - goto finally; + if (dump(pickler, ob) < 0) + goto finally; - Py_INCREF(Py_None); - res = Py_None; + Py_INCREF(Py_None); + res = Py_None; -finally: - Py_XDECREF(pickler); + finally: + Py_XDECREF(pickler); - return res; + return res; } static PyObject * -cpm_dumps(PyObject *self, PyObject *args) { - PyObject *ob, *file = 0, *res = NULL; - Picklerobject *pickler = 0; - int bin = 0; +cpm_dumps(PyObject *self, PyObject *args) +{ + PyObject *ob, *file = 0, *res = NULL; + Picklerobject *pickler = 0; + int bin = 0; - if (!( PyArg_ParseTuple(args, "O|i:dumps", &ob, &bin))) - goto finally; + if (!( PyArg_ParseTuple(args, "O|i:dumps", &ob, &bin))) + goto finally; - if (!( file = PycStringIO->NewOutput(128))) - goto finally; + if (!( file = PycStringIO->NewOutput(128))) + goto finally; - if (!( pickler = newPicklerobject(file, bin))) - goto finally; + if (!( pickler = newPicklerobject(file, bin))) + goto finally; - if (dump(pickler, ob) < 0) - goto finally; + if (dump(pickler, ob) < 0) + goto finally; - res = PycStringIO->cgetvalue(file); + res = PycStringIO->cgetvalue(file); -finally: - Py_XDECREF(pickler); - Py_XDECREF(file); + finally: + Py_XDECREF(pickler); + Py_XDECREF(file); - return res; + return res; } static PyObject * -cpm_load(PyObject *self, PyObject *args) { - Unpicklerobject *unpickler = 0; - PyObject *ob, *res = NULL; +cpm_load(PyObject *self, PyObject *args) +{ + Unpicklerobject *unpickler = 0; + PyObject *ob, *res = NULL; - if (!( PyArg_ParseTuple(args, "O:load", &ob))) - goto finally; + if (!( PyArg_ParseTuple(args, "O:load", &ob))) + goto finally; - if (!( unpickler = newUnpicklerobject(ob))) - goto finally; + if (!( unpickler = newUnpicklerobject(ob))) + goto finally; - res = load(unpickler); + res = load(unpickler); -finally: - Py_XDECREF(unpickler); + finally: + Py_XDECREF(unpickler); - return res; + return res; } static PyObject * -cpm_loads(PyObject *self, PyObject *args) { - PyObject *ob, *file = 0, *res = NULL; - Unpicklerobject *unpickler = 0; +cpm_loads(PyObject *self, PyObject *args) +{ + PyObject *ob, *file = 0, *res = NULL; + Unpicklerobject *unpickler = 0; - if (!( PyArg_ParseTuple(args, "S:loads", &ob))) - goto finally; + if (!( PyArg_ParseTuple(args, "S:loads", &ob))) + goto finally; - if (!( file = PycStringIO->NewInput(ob))) - goto finally; + if (!( file = PycStringIO->NewInput(ob))) + goto finally; - if (!( unpickler = newUnpicklerobject(file))) - goto finally; + if (!( unpickler = newUnpicklerobject(file))) + goto finally; - res = load(unpickler); + res = load(unpickler); -finally: - Py_XDECREF(file); - Py_XDECREF(unpickler); + finally: + Py_XDECREF(file); + Py_XDECREF(unpickler); - return res; + return res; } @@ -4546,170 +4702,173 @@ static struct PyMethodDef cPickle_methods[] = { }; static int -init_stuff(PyObject *module_dict) { - PyObject *copy_reg, *t, *r; +init_stuff(PyObject *module_dict) +{ + PyObject *copy_reg, *t, *r; #define INIT_STR(S) if (!( S ## _str=PyString_InternFromString(#S))) return -1; - INIT_STR(__class__); - INIT_STR(__getinitargs__); - INIT_STR(__dict__); - INIT_STR(__getstate__); - INIT_STR(__setstate__); - INIT_STR(__name__); - INIT_STR(__main__); - INIT_STR(__reduce__); - INIT_STR(write); - INIT_STR(__safe_for_unpickling__); - INIT_STR(append); - INIT_STR(read); - INIT_STR(readline); - INIT_STR(copy_reg); - INIT_STR(dispatch_table); - INIT_STR(safe_constructors); - INIT_STR(__basicnew__); - - if (!( copy_reg = PyImport_ImportModule("copy_reg"))) - return -1; - - /* These next few are special because we want to use different - ones in restricted mode. */ - - if (!( dispatch_table = PyObject_GetAttr(copy_reg, dispatch_table_str))) - return -1; - - if (!( safe_constructors = PyObject_GetAttr(copy_reg, - safe_constructors_str))) - return -1; - - Py_DECREF(copy_reg); - - /* Down to here ********************************** */ - - if (!( empty_tuple = PyTuple_New(0))) - return -1; - - /* Ugh */ - if (!( t=PyImport_ImportModule("__builtin__"))) return -1; - if (PyDict_SetItemString(module_dict, "__builtins__", t) < 0) - return -1; - - if (!( t=PyDict_New())) return -1; - if (!( r=PyRun_String( - "def __init__(self, *args): self.args=args\n\n" - "def __str__(self):\n" - " return self.args and ('%s' % self.args[0]) or '(what)'\n", - Py_file_input, - module_dict, t) )) return -1; - Py_DECREF(r); - - if (!( PickleError = PyErr_NewException("cPickle.PickleError", NULL, t))) - return -1; + INIT_STR(__class__); + INIT_STR(__getinitargs__); + INIT_STR(__dict__); + INIT_STR(__getstate__); + INIT_STR(__setstate__); + INIT_STR(__name__); + INIT_STR(__main__); + INIT_STR(__reduce__); + INIT_STR(write); + INIT_STR(__safe_for_unpickling__); + INIT_STR(append); + INIT_STR(read); + INIT_STR(readline); + INIT_STR(copy_reg); + INIT_STR(dispatch_table); + INIT_STR(safe_constructors); + INIT_STR(__basicnew__); + + if (!( copy_reg = PyImport_ImportModule("copy_reg"))) + return -1; + + /* These next few are special because we want to use different + ones in restricted mode. */ + dispatch_table = PyObject_GetAttr(copy_reg, dispatch_table_str); + if (!dispatch_table) + return -1; + + if (!( safe_constructors = PyObject_GetAttr(copy_reg, + safe_constructors_str))) + return -1; + + Py_DECREF(copy_reg); + + /* Down to here ********************************** */ + + if (!( empty_tuple = PyTuple_New(0))) + return -1; + + /* Ugh */ + if (!( t=PyImport_ImportModule("__builtin__"))) return -1; + if (PyDict_SetItemString(module_dict, "__builtins__", t) < 0) + return -1; + + if (!( t=PyDict_New())) return -1; + if (!( r=PyRun_String( + "def __init__(self, *args): self.args=args\n\n" + "def __str__(self):\n" + " return self.args and ('%s' % self.args[0]) or '(what)'\n", + Py_file_input, + module_dict, t) )) return -1; + Py_DECREF(r); + + PickleError = PyErr_NewException("cPickle.PickleError", NULL, t); + if (!PickleError) + return -1; + + Py_DECREF(t); + + PicklingError = PyErr_NewException("cPickle.PicklingError", + PickleError, NULL); + if (!PicklingError) + return -1; + + if (!( t=PyDict_New())) return -1; + if (!( r=PyRun_String( + "def __init__(self, *args): self.args=args\n\n" + "def __str__(self):\n" + " a=self.args\n" + " a=a and type(a[0]) or '(what)'\n" + " return 'Cannot pickle %s objects' % a\n" + , Py_file_input, + module_dict, t) )) return -1; + Py_DECREF(r); + + if (!( UnpickleableError = PyErr_NewException( + "cPickle.UnpickleableError", PicklingError, t))) + return -1; + + Py_DECREF(t); + + if (!( UnpicklingError = PyErr_NewException("cPickle.UnpicklingError", + PickleError, NULL))) + return -1; + + if (PyDict_SetItemString(module_dict, "PickleError", + PickleError) < 0) + return -1; + + if (PyDict_SetItemString(module_dict, "PicklingError", + PicklingError) < 0) + return -1; + + if (PyDict_SetItemString(module_dict, "UnpicklingError", + UnpicklingError) < 0) + return -1; + + if (PyDict_SetItemString(module_dict, "UnpickleableError", + UnpickleableError) < 0) + return -1; + + if (!( BadPickleGet = PyString_FromString("cPickle.BadPickleGet"))) + return -1; + + if (PyDict_SetItemString(module_dict, "BadPickleGet", + BadPickleGet) < 0) + return -1; + + PycString_IMPORT; - Py_DECREF(t); - - - if (!( PicklingError = PyErr_NewException("cPickle.PicklingError", - PickleError, NULL))) - return -1; - - if (!( t=PyDict_New())) return -1; - if (!( r=PyRun_String( - "def __init__(self, *args): self.args=args\n\n" - "def __str__(self):\n" - " a=self.args\n" - " a=a and type(a[0]) or '(what)'\n" - " return 'Cannot pickle %s objects' % a\n" - , Py_file_input, - module_dict, t) )) return -1; - Py_DECREF(r); - - if (!( UnpickleableError = PyErr_NewException( - "cPickle.UnpickleableError", PicklingError, t))) - return -1; - - Py_DECREF(t); - - if (!( UnpicklingError = PyErr_NewException("cPickle.UnpicklingError", - PickleError, NULL))) - return -1; - - if (PyDict_SetItemString(module_dict, "PickleError", - PickleError) < 0) - return -1; - - if (PyDict_SetItemString(module_dict, "PicklingError", - PicklingError) < 0) - return -1; - - if (PyDict_SetItemString(module_dict, "UnpicklingError", - UnpicklingError) < 0) - return -1; - - if (PyDict_SetItemString(module_dict, "UnpickleableError", - UnpickleableError) < 0) - return -1; - - if (!( BadPickleGet = PyString_FromString("cPickle.BadPickleGet"))) - return -1; - - if (PyDict_SetItemString(module_dict, "BadPickleGet", - BadPickleGet) < 0) - return -1; - - PycString_IMPORT; - - return 0; + return 0; } #ifndef DL_EXPORT /* declarations for DLL import/export */ #define DL_EXPORT(RTYPE) RTYPE #endif DL_EXPORT(void) -initcPickle(void) { - PyObject *m, *d, *di, *v, *k; - int i; - char *rev="1.71"; - PyObject *format_version; - PyObject *compatible_formats; - - Picklertype.ob_type = &PyType_Type; - Picklertype.tp_getattro = PyObject_GenericGetAttr; - Picklertype.tp_setattro = PyObject_GenericSetAttr; - Unpicklertype.ob_type = &PyType_Type; - PdataType.ob_type = &PyType_Type; - - /* Initialize some pieces. We need to do this before module creation, - so we're forced to use a temporary dictionary. :( - */ - di=PyDict_New(); - if (!di) return; - if (init_stuff(di) < 0) return; - - /* Create the module and add the functions */ - m = Py_InitModule4("cPickle", cPickle_methods, - cPickle_module_documentation, - (PyObject*)NULL,PYTHON_API_VERSION); - - /* Add some symbolic constants to the module */ - d = PyModule_GetDict(m); - PyDict_SetItemString(d,"__version__", v = PyString_FromString(rev)); - Py_XDECREF(v); - - /* Copy data from di. Waaa. */ - for (i=0; PyDict_Next(di, &i, &k, &v); ) { - if (PyObject_SetItem(d, k, v) < 0) { - Py_DECREF(di); - return; - } - } - Py_DECREF(di); - - format_version = PyString_FromString("1.3"); - compatible_formats = Py_BuildValue("[sss]", "1.0", "1.1", "1.2"); - - PyDict_SetItemString(d, "format_version", format_version); - PyDict_SetItemString(d, "compatible_formats", compatible_formats); - Py_XDECREF(format_version); - Py_XDECREF(compatible_formats); +initcPickle(void) +{ + PyObject *m, *d, *di, *v, *k; + int i; + char *rev="1.71"; + PyObject *format_version; + PyObject *compatible_formats; + + Picklertype.ob_type = &PyType_Type; + Picklertype.tp_getattro = PyObject_GenericGetAttr; + Picklertype.tp_setattro = PyObject_GenericSetAttr; + Unpicklertype.ob_type = &PyType_Type; + PdataType.ob_type = &PyType_Type; + + /* Initialize some pieces. We need to do this before module creation, + so we're forced to use a temporary dictionary. :( + */ + di=PyDict_New(); + if (!di) return; + if (init_stuff(di) < 0) return; + + /* Create the module and add the functions */ + m = Py_InitModule4("cPickle", cPickle_methods, + cPickle_module_documentation, + (PyObject*)NULL,PYTHON_API_VERSION); + + /* Add some symbolic constants to the module */ + d = PyModule_GetDict(m); + PyDict_SetItemString(d,"__version__", v = PyString_FromString(rev)); + Py_XDECREF(v); + + /* Copy data from di. Waaa. */ + for (i=0; PyDict_Next(di, &i, &k, &v); ) { + if (PyObject_SetItem(d, k, v) < 0) { + Py_DECREF(di); + return; + } + } + Py_DECREF(di); + + format_version = PyString_FromString("1.3"); + compatible_formats = Py_BuildValue("[sss]", "1.0", "1.1", "1.2"); + + PyDict_SetItemString(d, "format_version", format_version); + PyDict_SetItemString(d, "compatible_formats", compatible_formats); + Py_XDECREF(format_version); + Py_XDECREF(compatible_formats); } |