[Python-checkins] r56183 - python/branches/cpy_merge/Modules/_picklemodule.c
alexandre.vassalotti
python-checkins at python.org
Sat Jul 7 20:02:40 CEST 2007
Author: alexandre.vassalotti
Date: Sat Jul 7 20:02:39 2007
New Revision: 56183
Modified:
python/branches/cpy_merge/Modules/_picklemodule.c
Log:
Expanded tabs.
Modified: python/branches/cpy_merge/Modules/_picklemodule.c
==============================================================================
--- python/branches/cpy_merge/Modules/_picklemodule.c (original)
+++ python/branches/cpy_merge/Modules/_picklemodule.c Sat Jul 7 20:02:39 2007
@@ -3,7 +3,7 @@
#include "structmember.h"
PyDoc_STRVAR(cPickle_module_documentation,
- "C implementation and optimization of the Python pickle module.");
+"C implementation and optimization of the Python pickle module.");
#ifndef Py_eval_input
#include <graminit.h>
@@ -64,18 +64,18 @@
#define SETITEMS 'u'
/* Protocol 2. */
-#define PROTO '\x80' /* identify pickle protocol */
-#define NEWOBJ '\x81' /* build object by applying cls.__new__ to argtuple */
-#define EXT1 '\x82' /* push object from extension registry; 1-byte index */
-#define EXT2 '\x83' /* ditto, but 2-byte index */
-#define EXT4 '\x84' /* ditto, but 4-byte index */
-#define TUPLE1 '\x85' /* build 1-tuple from stack top */
-#define TUPLE2 '\x86' /* build 2-tuple from two topmost stack items */
-#define TUPLE3 '\x87' /* build 3-tuple from three topmost stack items */
-#define NEWTRUE '\x88' /* push True */
-#define NEWFALSE '\x89' /* push False */
-#define LONG1 '\x8a' /* push long from < 256 bytes */
-#define LONG4 '\x8b' /* push really big long */
+#define PROTO '\x80' /* identify pickle protocol */
+#define NEWOBJ '\x81' /* build object by applying cls.__new__ to argtuple */
+#define EXT1 '\x82' /* push object from extension registry; 1-byte index */
+#define EXT2 '\x83' /* ditto, but 2-byte index */
+#define EXT4 '\x84' /* ditto, but 4-byte index */
+#define TUPLE1 '\x85' /* build 1-tuple from stack top */
+#define TUPLE2 '\x86' /* build 2-tuple from two topmost stack items */
+#define TUPLE3 '\x87' /* build 3-tuple from three topmost stack items */
+#define NEWTRUE '\x88' /* push True */
+#define NEWFALSE '\x89' /* push False */
+#define LONG1 '\x8a' /* push long from < 256 bytes */
+#define LONG4 '\x8b' /* push really big long */
/* There aren't opcodes -- they're ways to pickle bools before protocol 2,
* so that unpicklers written before bools were introduced unpickle them
@@ -130,8 +130,8 @@
Internal Data type for pickle data. */
typedef struct {
- PyObject_HEAD int length; /* number of initial slots in data currently used */
- int size; /* number of slots in data allocated */
+ PyObject_HEAD int length; /* number of initial slots in data currently used */
+ int size; /* number of slots in data allocated */
PyObject **data;
} Pdata;
@@ -142,10 +142,10 @@
PyObject **p;
for (i = self->length, p = self->data; --i >= 0; p++) {
- Py_DECREF(*p);
+ Py_DECREF(*p);
}
if (self->data)
- free(self->data);
+ free(self->data);
PyObject_Del(self);
}
@@ -163,12 +163,12 @@
Pdata *self;
if (!(self = PyObject_New(Pdata, &PdataType)))
- return NULL;
+ return NULL;
self->size = 8;
self->length = 0;
self->data = malloc(self->size * sizeof(PyObject *));
if (self->data)
- return (PyObject *) self;
+ return (PyObject *) self;
Py_DECREF(self);
return PyErr_NoMemory();
}
@@ -190,12 +190,12 @@
PyObject **p;
if (clearto < 0)
- return stackUnderflow();
+ return stackUnderflow();
if (clearto >= self->length)
- return 0;
+ return 0;
for (i = self->length, p = self->data + clearto; --i >= clearto; p++) {
- Py_CLEAR(*p);
+ Py_CLEAR(*p);
}
self->length = clearto;
@@ -210,16 +210,16 @@
PyObject **tmp;
bigger = self->size << 1;
- if (bigger <= 0) /* was 0, or new value overflows */
- goto nomemory;
+ if (bigger <= 0) /* was 0, or new value overflows */
+ goto nomemory;
if ((int) (size_t) bigger != bigger)
- goto nomemory;
+ goto nomemory;
nbytes = (size_t) bigger *sizeof(PyObject *);
if (nbytes / sizeof(PyObject *) != (size_t) bigger)
- goto nomemory;
+ goto nomemory;
tmp = realloc(self->data, nbytes);
if (tmp == NULL)
- goto nomemory;
+ goto nomemory;
self->data = tmp;
self->size = bigger;
return 0;
@@ -233,13 +233,13 @@
* must be an lvalue holding PyObject*. On stack underflow, UnpicklingError
* is raised and V is set to NULL. D and V may be evaluated several times.
*/
-#define PDATA_POP(D, V) { \
- if ((D)->length) \
- (V) = (D)->data[--((D)->length)]; \
- else { \
- PyErr_SetString(UnpicklingError, "bad pickle data"); \
- (V) = NULL; \
- } \
+#define PDATA_POP(D, V) { \
+ if ((D)->length) \
+ (V) = (D)->data[--((D)->length)]; \
+ else { \
+ PyErr_SetString(UnpicklingError, "bad pickle data"); \
+ (V) = NULL; \
+ } \
}
/* PDATA_PUSH and PDATA_APPEND both push rvalue PyObject* O on to Pdata*
@@ -251,22 +251,22 @@
*/
/* Push O on stack D, giving ownership of O to the stack. */
-#define PDATA_PUSH(D, O, ER) { \
- if (((Pdata*)(D))->length == ((Pdata*)(D))->size && \
- Pdata_grow((Pdata*)(D)) < 0) { \
- Py_DECREF(O); \
- return ER; \
- } \
- ((Pdata*)(D))->data[((Pdata*)(D))->length++] = (O); \
+#define PDATA_PUSH(D, O, ER) { \
+ if (((Pdata*)(D))->length == ((Pdata*)(D))->size && \
+ Pdata_grow((Pdata*)(D)) < 0) { \
+ Py_DECREF(O); \
+ return ER; \
+ } \
+ ((Pdata*)(D))->data[((Pdata*)(D))->length++] = (O); \
}
/* Push O on stack D, pushing a new reference. */
-#define PDATA_APPEND(D, O, ER) { \
- if (((Pdata*)(D))->length == ((Pdata*)(D))->size && \
- Pdata_grow((Pdata*)(D)) < 0) \
- return ER; \
- Py_INCREF(O); \
- ((Pdata*)(D))->data[((Pdata*)(D))->length++] = (O); \
+#define PDATA_APPEND(D, O, ER) { \
+ if (((Pdata*)(D))->length == ((Pdata*)(D))->size && \
+ Pdata_grow((Pdata*)(D)) < 0) \
+ return ER; \
+ Py_INCREF(O); \
+ ((Pdata*)(D))->data[((Pdata*)(D))->length++] = (O); \
}
@@ -279,9 +279,9 @@
l = self->length - start;
r = PyTuple_New(l);
if (r == NULL)
- return NULL;
+ return NULL;
for (i = start, j = 0; j < l; i++, j++)
- PyTuple_SET_ITEM(r, j, self->data[i]);
+ PyTuple_SET_ITEM(r, j, self->data[i]);
self->length = start;
return r;
@@ -295,9 +295,9 @@
l = self->length - start;
if (!(r = PyList_New(l)))
- return NULL;
+ return NULL;
for (i = start, j = 0; j < l; i++, j++)
- PyList_SET_ITEM(r, j, self->data[i]);
+ PyList_SET_ITEM(r, j, self->data[i]);
self->length = start;
return r;
@@ -337,13 +337,13 @@
/* bool, true if proto > 0 */
int bin;
- int fast; /* Fast mode doesn't save in memo, don't use if circ ref */
+ int fast; /* Fast mode doesn't save in memo, don't use if circ ref */
int nesting;
int (*write_func) (struct Picklerobject *, const char *, Py_ssize_t);
char *write_buf;
int buf_size;
PyObject *dispatch_table;
- int fast_container; /* count nested container dumps */
+ int fast_container; /* count nested container dumps */
PyObject *fast_memo;
} Picklerobject;
@@ -389,29 +389,29 @@
va_start(va, format);
if (format)
- args = Py_VaBuildValue(format, va);
+ args = Py_VaBuildValue(format, va);
va_end(va);
if (format && !args)
- return NULL;
+ return NULL;
if (stringformat && !(retval = PyString_FromString(stringformat)))
- return NULL;
+ 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;
- }
+ 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;
+ retval = args;
else {
- PyErr_SetObject(ErrType, Py_None);
- return NULL;
+ PyErr_SetObject(ErrType, Py_None);
+ return NULL;
}
PyErr_SetObject(ErrType, retval);
Py_DECREF(retval);
@@ -424,19 +424,19 @@
size_t nbyteswritten;
if (s == NULL) {
- return 0;
+ return 0;
}
if (n > INT_MAX) {
- /* String too large */
- return -1;
+ /* String too large */
+ return -1;
}
Py_BEGIN_ALLOW_THREADS
- nbyteswritten = fwrite(s, sizeof(char), n, self->fp);
+ nbyteswritten = fwrite(s, sizeof(char), n, self->fp);
Py_END_ALLOW_THREADS if (nbyteswritten != (size_t) n) {
- PyErr_SetFromErrno(PyExc_IOError);
- return -1;
+ PyErr_SetFromErrno(PyExc_IOError);
+ return -1;
}
return (int) n;
@@ -446,11 +446,11 @@
write_cStringIO(Picklerobject * self, const char *s, Py_ssize_t n)
{
if (s == NULL) {
- return 0;
+ return 0;
}
if (PycStringIO->cwrite((PyObject *) self->file, s, n) != n) {
- return -1;
+ return -1;
}
return (int) n;
@@ -460,9 +460,9 @@
write_none(Picklerobject * self, const char *s, Py_ssize_t n)
{
if (s == NULL)
- return 0;
+ return 0;
if (n > INT_MAX)
- return -1;
+ return -1;
return (int) n;
}
@@ -473,46 +473,46 @@
int n;
if (_n > INT_MAX)
- return -1;
+ return -1;
n = (int) _n;
if (s == NULL) {
- if (!(self->buf_size))
- return 0;
- py_str = PyString_FromStringAndSize(self->write_buf, self->buf_size);
- if (!py_str)
- return -1;
+ 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->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;
+ /* 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);
+ PDATA_PUSH(self->file, py_str, -1);
self->buf_size = 0;
return n;
@@ -525,36 +525,36 @@
size_t nbytesread;
if (self->buf_size == 0) {
- int size;
+ int size;
- size = ((n < 32) ? 32 : n);
- if (!(self->buf = (char *) malloc(size))) {
- PyErr_NoMemory();
- return -1;
- }
+ size = ((n < 32) ? 32 : n);
+ if (!(self->buf = (char *) malloc(size))) {
+ PyErr_NoMemory();
+ return -1;
+ }
- self->buf_size = size;
+ self->buf_size = size;
}
else if (n > self->buf_size) {
- char *newbuf = (char *) realloc(self->buf, n);
- if (!newbuf) {
- PyErr_NoMemory();
- return -1;
- }
- self->buf = newbuf;
- self->buf_size = n;
+ char *newbuf = (char *) realloc(self->buf, n);
+ if (!newbuf) {
+ PyErr_NoMemory();
+ return -1;
+ }
+ self->buf = newbuf;
+ self->buf_size = n;
}
Py_BEGIN_ALLOW_THREADS
- nbytesread = fread(self->buf, sizeof(char), n, self->fp);
+ 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;
- }
+ if (feof(self->fp)) {
+ PyErr_SetNone(PyExc_EOFError);
+ return -1;
+ }
- PyErr_SetFromErrno(PyExc_IOError);
- return -1;
+ PyErr_SetFromErrno(PyExc_IOError);
+ return -1;
}
*s = self->buf;
@@ -569,36 +569,36 @@
int i;
if (self->buf_size == 0) {
- if (!(self->buf = (char *) malloc(40))) {
- PyErr_NoMemory();
- return -1;
- }
- self->buf_size = 40;
+ if (!(self->buf = (char *) malloc(40))) {
+ PyErr_NoMemory();
+ return -1;
+ }
+ self->buf_size = 40;
}
i = 0;
while (1) {
- int bigger;
- char *newbuf;
- 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;
- }
- }
- bigger = self->buf_size << 1;
- if (bigger <= 0) { /* overflow */
- PyErr_NoMemory();
- return -1;
- }
- newbuf = (char *) realloc(self->buf, bigger);
- if (!newbuf) {
- PyErr_NoMemory();
- return -1;
- }
- self->buf = newbuf;
- self->buf_size = bigger;
+ int bigger;
+ char *newbuf;
+ 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;
+ }
+ }
+ bigger = self->buf_size << 1;
+ if (bigger <= 0) { /* overflow */
+ PyErr_NoMemory();
+ return -1;
+ }
+ newbuf = (char *) realloc(self->buf, bigger);
+ if (!newbuf) {
+ PyErr_NoMemory();
+ return -1;
+ }
+ self->buf = newbuf;
+ self->buf_size = bigger;
}
}
@@ -609,8 +609,8 @@
char *ptr;
if (PycStringIO->cread((PyObject *) self->file, &ptr, n) != n) {
- PyErr_SetNone(PyExc_EOFError);
- return -1;
+ PyErr_SetNone(PyExc_EOFError);
+ return -1;
}
*s = ptr;
@@ -626,7 +626,7 @@
char *ptr;
if ((n = PycStringIO->creadline((PyObject *) self->file, &ptr)) < 0) {
- return -1;
+ return -1;
}
*s = ptr;
@@ -641,21 +641,21 @@
PyObject *bytes, *str = 0;
if (!(bytes = PyInt_FromSsize_t(n)))
- return -1;
+ return -1;
ARG_TUP(self, bytes);
if (self->arg) {
- str = PyObject_Call(self->read, self->arg, NULL);
- FREE_ARG_TUP(self);
+ str = PyObject_Call(self->read, self->arg, NULL);
+ FREE_ARG_TUP(self);
}
if (!str)
- return -1;
+ return -1;
Py_XDECREF(self->last_string);
self->last_string = str;
if (!(*s = PyString_AsString(str)))
- return -1;
+ return -1;
return n;
}
@@ -667,17 +667,17 @@
Py_ssize_t str_size;
if (!(str = PyObject_CallObject(self->readline, empty_tuple))) {
- return -1;
+ return -1;
}
if ((str_size = PyString_Size(str)) < 0)
- return -1;
+ return -1;
Py_XDECREF(self->last_string);
self->last_string = str;
if (!(*s = PyString_AsString(str)))
- return -1;
+ return -1;
return str_size;
}
@@ -691,7 +691,7 @@
{
char *r = (char *) malloc(n + 1);
if (r == NULL)
- return (char *) PyErr_NoMemory();
+ return (char *) PyErr_NoMemory();
memcpy(r, s, n);
r[n] = 0;
return r;
@@ -707,50 +707,50 @@
size_t len;
if (!(mv = PyDict_GetItem(self->memo, id))) {
- PyErr_SetObject(PyExc_KeyError, id);
- return -1;
+ PyErr_SetObject(PyExc_KeyError, id);
+ return -1;
}
if (!(value = PyTuple_GetItem(mv, 0)))
- return -1;
+ return -1;
if (!(PyInt_Check(value))) {
- PyErr_SetString(PicklingError, "no int where int expected in memo");
- return -1;
+ PyErr_SetString(PicklingError, "no int where int expected in memo");
+ return -1;
}
c_value = PyInt_AsLong(value);
if (c_value == -1 && PyErr_Occurred())
- return -1;
+ return -1;
if (!self->bin) {
- s[0] = GET;
- PyOS_snprintf(s + 1, sizeof(s) - 1, "%ld\n", c_value);
- len = strlen(s);
+ 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;
+ 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 (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 -1;
return 0;
}
@@ -760,7 +760,7 @@
put(Picklerobject * self, PyObject * ob)
{
if (ob->ob_refcnt < 2 || self->fast)
- return 0;
+ return 0;
return put2(self, ob);
}
@@ -776,10 +776,10 @@
PyObject *py_ob_id = 0, *memo_len = 0, *t = 0;
if (self->fast)
- return 0;
+ return 0;
if ((p = PyDict_Size(self->memo)) < 0)
- goto finally;
+ goto finally;
/* Make sure memo keys are positive! */
/* XXX Why?
@@ -790,13 +790,13 @@
p++;
if (!(py_ob_id = PyLong_FromVoidPtr(ob)))
- goto finally;
+ goto finally;
if (!(memo_len = PyInt_FromLong(p)))
- goto finally;
+ goto finally;
if (!(t = PyTuple_New(2)))
- goto finally;
+ goto finally;
PyTuple_SET_ITEM(t, 0, memo_len);
Py_INCREF(memo_len);
@@ -804,38 +804,38 @@
Py_INCREF(ob);
if (PyDict_SetItem(self->memo, py_ob_id, t) < 0)
- goto finally;
+ 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);
+ 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;
+ 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 >= 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;
+ goto finally;
res = 0;
@@ -855,38 +855,38 @@
module = PyObject_GetAttrString(global, "__module__");
if (module)
- return module;
+ return module;
if (PyErr_ExceptionMatches(PyExc_AttributeError))
- PyErr_Clear();
+ PyErr_Clear();
else
- return NULL;
+ return NULL;
if (!(modules_dict = PySys_GetObject("modules")))
- return NULL;
+ return NULL;
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;
- global_name_attr = PyObject_GetAttr(module, global_name);
- if (!global_name_attr) {
- if (PyErr_ExceptionMatches(PyExc_AttributeError))
- PyErr_Clear();
- else
- return NULL;
- continue;
- }
-
- if (global_name_attr != global) {
- Py_DECREF(global_name_attr);
- continue;
- }
+ global_name_attr = PyObject_GetAttr(module, global_name);
+ if (!global_name_attr) {
+ if (PyErr_ExceptionMatches(PyExc_AttributeError))
+ PyErr_Clear();
+ else
+ return NULL;
+ 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
@@ -894,8 +894,8 @@
* like this rule. jlf
*/
if (!j) {
- j = 1;
- name = __main___str;
+ j = 1;
+ name = __main___str;
}
Py_INCREF(name);
@@ -908,32 +908,32 @@
{
/* 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)) {
- Py_DECREF(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) {
- Py_DECREF(key);
- self->fast_container = -1;
- return 0;
- }
- Py_DECREF(key);
+ 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)) {
+ Py_DECREF(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) {
+ Py_DECREF(key);
+ self->fast_container = -1;
+ return 0;
+ }
+ Py_DECREF(key);
}
return 1;
}
@@ -942,14 +942,14 @@
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) {
- Py_DECREF(key);
- return 0;
- }
- Py_DECREF(key);
+ PyObject *key = PyLong_FromVoidPtr(obj);
+ if (key == NULL)
+ return 0;
+ if (PyDict_DelItem(self->fast_memo, key) < 0) {
+ Py_DECREF(key);
+ return 0;
+ }
+ Py_DECREF(key);
}
return 1;
}
@@ -959,7 +959,7 @@
{
static char none = NONE;
if (self->write_func(self, &none, 1) < 0)
- return -1;
+ return -1;
return 0;
}
@@ -972,12 +972,12 @@
long l = args == Py_True;
if (self->proto >= 2) {
- char opcode = l ? NEWTRUE : NEWFALSE;
- if (self->write_func(self, &opcode, 1) < 0)
- return -1;
+ char opcode = l ? NEWTRUE : NEWFALSE;
+ if (self->write_func(self, &opcode, 1) < 0)
+ return -1;
}
else if (self->write_func(self, buf[l], len[l]) < 0)
- return -1;
+ return -1;
return 0;
}
@@ -989,41 +989,41 @@
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;
+ ) {
+ /* 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;
- }
+ /* 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;
+ if (self->write_func(self, c_str, len) < 0)
+ return -1;
}
return 0;
@@ -1040,114 +1040,114 @@
static char l = LONG;
if (val == -1 && PyErr_Occurred()) {
- /* out of range for int pickling */
- PyErr_Clear();
+ /* out of range for int pickling */
+ PyErr_Clear();
}
else
- return save_int(self, val);
+ return save_int(self, val);
if (self->proto >= 2) {
- /* Linear-time pickling. */
- size_t nbits;
- size_t nbytes;
- unsigned char *pdata;
- char c_str[5];
- int i;
- int sign = _PyLong_Sign(args);
-
- if (sign == 0) {
- /* It's 0 -- an empty bytestring. */
- c_str[0] = LONG1;
- c_str[1] = 0;
- i = self->write_func(self, c_str, 2);
- if (i < 0)
- goto finally;
- res = 0;
- goto finally;
- }
- nbits = _PyLong_NumBits(args);
- if (nbits == (size_t) - 1 && PyErr_Occurred())
- goto finally;
- /* How many bytes do we need? There are nbits >> 3 full
- * bytes of data, and nbits & 7 leftover bits. If there
- * are any leftover bits, then we clearly need another
- * byte. Wnat's not so obvious is that we *probably*
- * need another byte even if there aren't any leftovers:
- * the most-significant bit of the most-significant byte
- * acts like a sign bit, and it's usually got a sense
- * opposite of the one we need. The exception is longs
- * of the form -(2**(8*j-1)) for j > 0. Such a long is
- * its own 256's-complement, so has the right sign bit
- * even without the extra byte. That's a pain to check
- * for in advance, though, so we always grab an extra
- * byte at the start, and cut it back later if possible.
- */
- nbytes = (nbits >> 3) + 1;
- if (nbytes > INT_MAX) {
- PyErr_SetString(PyExc_OverflowError, "long too large "
- "to pickle");
- goto finally;
- }
- repr = PyString_FromStringAndSize(NULL, (int) nbytes);
- if (repr == NULL)
- goto finally;
- pdata = (unsigned char *) PyString_AS_STRING(repr);
- i = _PyLong_AsByteArray((PyLongObject *) args,
- pdata, nbytes,
- 1 /* little endian */ , 1 /* signed */ );
- if (i < 0)
- goto finally;
- /* If the long is negative, this may be a byte more than
- * needed. This is so iff the MSB is all redundant sign
- * bits.
- */
- if (sign < 0 && nbytes > 1 && pdata[nbytes - 1] == 0xff &&
- (pdata[nbytes - 2] & 0x80) != 0)
- --nbytes;
-
- if (nbytes < 256) {
- c_str[0] = LONG1;
- c_str[1] = (char) nbytes;
- size = 2;
- }
- else {
- c_str[0] = LONG4;
- size = (int) nbytes;
- for (i = 1; i < 5; i++) {
- c_str[i] = (char) (size & 0xff);
- size >>= 8;
- }
- size = 5;
- }
- i = self->write_func(self, c_str, size);
- if (i < 0)
- goto finally;
- i = self->write_func(self, (char *) pdata, (int) nbytes);
- if (i < 0)
- goto finally;
- res = 0;
- goto finally;
+ /* Linear-time pickling. */
+ size_t nbits;
+ size_t nbytes;
+ unsigned char *pdata;
+ char c_str[5];
+ int i;
+ int sign = _PyLong_Sign(args);
+
+ if (sign == 0) {
+ /* It's 0 -- an empty bytestring. */
+ c_str[0] = LONG1;
+ c_str[1] = 0;
+ i = self->write_func(self, c_str, 2);
+ if (i < 0)
+ goto finally;
+ res = 0;
+ goto finally;
+ }
+ nbits = _PyLong_NumBits(args);
+ if (nbits == (size_t) - 1 && PyErr_Occurred())
+ goto finally;
+ /* How many bytes do we need? There are nbits >> 3 full
+ * bytes of data, and nbits & 7 leftover bits. If there
+ * are any leftover bits, then we clearly need another
+ * byte. Wnat's not so obvious is that we *probably*
+ * need another byte even if there aren't any leftovers:
+ * the most-significant bit of the most-significant byte
+ * acts like a sign bit, and it's usually got a sense
+ * opposite of the one we need. The exception is longs
+ * of the form -(2**(8*j-1)) for j > 0. Such a long is
+ * its own 256's-complement, so has the right sign bit
+ * even without the extra byte. That's a pain to check
+ * for in advance, though, so we always grab an extra
+ * byte at the start, and cut it back later if possible.
+ */
+ nbytes = (nbits >> 3) + 1;
+ if (nbytes > INT_MAX) {
+ PyErr_SetString(PyExc_OverflowError, "long too large "
+ "to pickle");
+ goto finally;
+ }
+ repr = PyString_FromStringAndSize(NULL, (int) nbytes);
+ if (repr == NULL)
+ goto finally;
+ pdata = (unsigned char *) PyString_AS_STRING(repr);
+ i = _PyLong_AsByteArray((PyLongObject *) args,
+ pdata, nbytes,
+ 1 /* little endian */ , 1 /* signed */ );
+ if (i < 0)
+ goto finally;
+ /* If the long is negative, this may be a byte more than
+ * needed. This is so iff the MSB is all redundant sign
+ * bits.
+ */
+ if (sign < 0 && nbytes > 1 && pdata[nbytes - 1] == 0xff &&
+ (pdata[nbytes - 2] & 0x80) != 0)
+ --nbytes;
+
+ if (nbytes < 256) {
+ c_str[0] = LONG1;
+ c_str[1] = (char) nbytes;
+ size = 2;
+ }
+ else {
+ c_str[0] = LONG4;
+ size = (int) nbytes;
+ for (i = 1; i < 5; i++) {
+ c_str[i] = (char) (size & 0xff);
+ size >>= 8;
+ }
+ size = 5;
+ }
+ i = self->write_func(self, c_str, size);
+ if (i < 0)
+ goto finally;
+ i = self->write_func(self, (char *) pdata, (int) nbytes);
+ if (i < 0)
+ goto finally;
+ res = 0;
+ goto finally;
}
/* proto < 2: write the repr and newline. This is quadratic-time
* (in the number of digits), in both directions.
*/
if (!(repr = PyObject_Repr(args)))
- goto finally;
+ goto finally;
if ((size = PyString_Size(repr)) < 0)
- goto finally;
+ goto finally;
if (self->write_func(self, &l, 1) < 0)
- goto finally;
+ goto finally;
if (self->write_func(self,
- PyString_AS_STRING((PyStringObject *) repr),
- size) < 0)
- goto finally;
+ PyString_AS_STRING((PyStringObject *) repr),
+ size) < 0)
+ goto finally;
if (self->write_func(self, "\n", 1) < 0)
- goto finally;
+ goto finally;
res = 0;
@@ -1163,22 +1163,22 @@
double x = PyFloat_AS_DOUBLE((PyFloatObject *) args);
if (self->bin) {
- char str[9];
- str[0] = BINFLOAT;
- if (_PyFloat_Pack8(x, (unsigned char *) &str[1], 0) < 0)
- return -1;
- if (self->write_func(self, str, 9) < 0)
- return -1;
+ char str[9];
+ str[0] = BINFLOAT;
+ if (_PyFloat_Pack8(x, (unsigned char *) &str[1], 0) < 0)
+ return -1;
+ if (self->write_func(self, str, 9) < 0)
+ return -1;
}
else {
- char c_str[250];
- c_str[0] = FLOAT;
- PyOS_ascii_formatd(c_str + 1, sizeof(c_str) - 2, "%.17g", x);
- /* Extend the formatted string with a newline character */
- strcat(c_str, "\n");
+ char c_str[250];
+ c_str[0] = FLOAT;
+ PyOS_ascii_formatd(c_str + 1, sizeof(c_str) - 2, "%.17g", x);
+ /* Extend the formatted string with a newline character */
+ strcat(c_str, "\n");
- if (self->write_func(self, c_str, strlen(c_str)) < 0)
- return -1;
+ if (self->write_func(self, c_str, strlen(c_str)) < 0)
+ return -1;
}
return 0;
@@ -1192,71 +1192,71 @@
PyObject *repr = 0;
if ((size = PyString_Size(args)) < 0)
- return -1;
+ return -1;
if (!self->bin) {
- char *repr_str;
+ char *repr_str;
- static char string = STRING;
+ static char string = STRING;
- if (!(repr = PyObject_Repr(args)))
- return -1;
+ if (!(repr = PyObject_Repr(args)))
+ return -1;
- if ((len = PyString_Size(repr)) < 0)
- goto err;
- repr_str = PyString_AS_STRING((PyStringObject *) repr);
+ 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, &string, 1) < 0)
+ goto err;
- if (self->write_func(self, repr_str, len) < 0)
- goto err;
+ if (self->write_func(self, repr_str, len) < 0)
+ goto err;
- if (self->write_func(self, "\n", 1) < 0)
- goto err;
+ if (self->write_func(self, "\n", 1) < 0)
+ goto err;
- Py_XDECREF(repr);
+ Py_XDECREF(repr);
}
else {
- int i;
- char c_str[5];
+ int i;
+ char c_str[5];
- if ((size = PyString_Size(args)) < 0)
- return -1;
+ if ((size = PyString_Size(args)) < 0)
+ return -1;
- if (size < 256) {
- c_str[0] = SHORT_BINSTRING;
- c_str[1] = size;
- len = 2;
- }
- else if (size <= INT_MAX) {
- c_str[0] = BINSTRING;
- for (i = 1; i < 5; i++)
- c_str[i] = (int) (size >> ((i - 1) * 8));
- len = 5;
- }
- else
- return -1; /* string too large */
-
- 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 (size < 256) {
+ c_str[0] = SHORT_BINSTRING;
+ c_str[1] = size;
+ len = 2;
+ }
+ else if (size <= INT_MAX) {
+ c_str[0] = BINSTRING;
+ for (i = 1; i < 5; i++)
+ c_str[i] = (int) (size >> ((i - 1) * 8));
+ len = 5;
+ }
+ else
+ return -1; /* string too large */
+
+ 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 (put(self, args) < 0)
+ return -1;
return 0;
@@ -1280,25 +1280,25 @@
repr = PyString_FromStringAndSize(NULL, 6 * size);
if (repr == NULL)
- return NULL;
+ return NULL;
if (size == 0)
- return repr;
+ 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;
+ 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';
_PyString_Resize(&repr, p - q);
@@ -1313,69 +1313,69 @@
PyObject *repr = 0;
if (!PyUnicode_Check(args))
- return -1;
+ return -1;
if (!self->bin) {
- char *repr_str;
- static char string = UNICODE;
+ char *repr_str;
+ static char string = UNICODE;
- repr =
- modified_EncodeRawUnicodeEscape(PyUnicode_AS_UNICODE(args),
- PyUnicode_GET_SIZE(args));
- if (!repr)
- return -1;
+ repr =
+ modified_EncodeRawUnicodeEscape(PyUnicode_AS_UNICODE(args),
+ PyUnicode_GET_SIZE(args));
+ if (!repr)
+ return -1;
- if ((len = PyString_Size(repr)) < 0)
- goto err;
- repr_str = PyString_AS_STRING((PyStringObject *) repr);
+ 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, &string, 1) < 0)
+ goto err;
- if (self->write_func(self, repr_str, len) < 0)
- goto err;
+ if (self->write_func(self, repr_str, len) < 0)
+ goto err;
- if (self->write_func(self, "\n", 1) < 0)
- goto err;
+ if (self->write_func(self, "\n", 1) < 0)
+ goto err;
- Py_XDECREF(repr);
+ Py_XDECREF(repr);
}
else {
- int i;
- char c_str[5];
+ int i;
+ char c_str[5];
- if (!(repr = PyUnicode_AsUTF8String(args)))
- return -1;
+ if (!(repr = PyUnicode_AsUTF8String(args)))
+ return -1;
- if ((size = PyString_Size(repr)) < 0)
- goto err;
- if (size > INT_MAX)
- return -1; /* string too large */
-
- 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;
- }
+ if ((size = PyString_Size(repr)) < 0)
+ goto err;
+ if (size > INT_MAX)
+ return -1; /* string too large */
+
+ 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);
+ Py_DECREF(repr);
}
if (doput)
- if (put(self, args) < 0)
- return -1;
+ if (put(self, args) < 0)
+ return -1;
return 0;
@@ -1390,17 +1390,17 @@
store_tuple_elements(Picklerobject * self, PyObject * t, int len)
{
int i;
- int res = -1; /* guilty until proved innocent */
+ int res = -1; /* guilty until proved innocent */
assert(PyTuple_Size(t) == len);
for (i = 0; i < len; i++) {
- PyObject *element = PyTuple_GET_ITEM(t, i);
+ PyObject *element = PyTuple_GET_ITEM(t, i);
- if (element == NULL)
- goto finally;
- if (save(self, element, 0) < 0)
- goto finally;
+ if (element == NULL)
+ goto finally;
+ if (save(self, element, 0) < 0)
+ goto finally;
}
res = 0;
@@ -1427,24 +1427,24 @@
static char len2opcode[] = { EMPTY_TUPLE, TUPLE1, TUPLE2, TUPLE3 };
if ((len = PyTuple_Size(args)) < 0)
- goto finally;
+ goto finally;
if (len == 0) {
- char c_str[2];
+ char c_str[2];
- if (self->proto) {
- c_str[0] = EMPTY_TUPLE;
- len = 1;
- }
- else {
- c_str[0] = MARK;
- c_str[1] = TUPLE;
- len = 2;
- }
- if (self->write_func(self, c_str, len) >= 0)
- res = 0;
- /* Don't memoize an empty tuple. */
- goto finally;
+ if (self->proto) {
+ c_str[0] = EMPTY_TUPLE;
+ len = 1;
+ }
+ else {
+ c_str[0] = MARK;
+ c_str[1] = TUPLE;
+ len = 2;
+ }
+ if (self->write_func(self, c_str, len) >= 0)
+ res = 0;
+ /* Don't memoize an empty tuple. */
+ goto finally;
}
/* A non-empty tuple. */
@@ -1456,65 +1456,65 @@
*/
py_tuple_id = PyLong_FromVoidPtr(args);
if (py_tuple_id == NULL)
- goto finally;
+ goto finally;
if (len <= 3 && self->proto >= 2) {
- /* Use TUPLE{1,2,3} opcodes. */
- if (store_tuple_elements(self, args, len) < 0)
- goto finally;
- if (PyDict_GetItem(self->memo, py_tuple_id)) {
- /* pop the len elements */
- for (i = 0; i < len; ++i)
- if (self->write_func(self, &pop, 1) < 0)
- goto finally;
- /* fetch from memo */
- if (get(self, py_tuple_id) < 0)
- goto finally;
- res = 0;
- goto finally;
- }
- /* Not recursive. */
- if (self->write_func(self, len2opcode + len, 1) < 0)
- goto finally;
- goto memoize;
+ /* Use TUPLE{1,2,3} opcodes. */
+ if (store_tuple_elements(self, args, len) < 0)
+ goto finally;
+ if (PyDict_GetItem(self->memo, py_tuple_id)) {
+ /* pop the len elements */
+ for (i = 0; i < len; ++i)
+ if (self->write_func(self, &pop, 1) < 0)
+ goto finally;
+ /* fetch from memo */
+ if (get(self, py_tuple_id) < 0)
+ goto finally;
+ res = 0;
+ goto finally;
+ }
+ /* Not recursive. */
+ if (self->write_func(self, len2opcode + len, 1) < 0)
+ goto finally;
+ goto memoize;
}
/* proto < 2 and len > 0, or proto >= 2 and len > 3.
* Generate MARK elt1 elt2 ... TUPLE
*/
if (self->write_func(self, &MARKv, 1) < 0)
- goto finally;
+ goto finally;
if (store_tuple_elements(self, args, len) < 0)
- goto finally;
+ goto finally;
if (PyDict_GetItem(self->memo, py_tuple_id)) {
- /* pop the stack stuff we pushed */
- if (self->bin) {
- if (self->write_func(self, &pop_mark, 1) < 0)
- goto finally;
- }
- else {
- /* Note that we pop one more than len, to remove
- * the MARK too.
- */
- for (i = 0; i <= len; i++)
- if (self->write_func(self, &pop, 1) < 0)
- goto finally;
- }
- /* fetch from memo */
- if (get(self, py_tuple_id) >= 0)
- res = 0;
- goto finally;
+ /* pop the stack stuff we pushed */
+ if (self->bin) {
+ if (self->write_func(self, &pop_mark, 1) < 0)
+ goto finally;
+ }
+ else {
+ /* Note that we pop one more than len, to remove
+ * the MARK too.
+ */
+ for (i = 0; i <= len; i++)
+ if (self->write_func(self, &pop, 1) < 0)
+ goto finally;
+ }
+ /* fetch from memo */
+ if (get(self, py_tuple_id) >= 0)
+ res = 0;
+ goto finally;
}
/* Not recursive. */
if (self->write_func(self, &tuple, 1) < 0)
- goto finally;
+ goto finally;
memoize:
if (put(self, args) >= 0)
- res = 0;
+ res = 0;
finally:
Py_XDECREF(py_tuple_id);
@@ -1540,64 +1540,64 @@
assert(iter != NULL);
if (self->proto == 0) {
- /* APPENDS isn't available; do one at a time. */
- for (;;) {
- obj = PyIter_Next(iter);
- if (obj == NULL) {
- if (PyErr_Occurred())
- return -1;
- break;
- }
- i = save(self, obj, 0);
- Py_DECREF(obj);
- if (i < 0)
- return -1;
- if (self->write_func(self, &append, 1) < 0)
- return -1;
- }
- return 0;
+ /* APPENDS isn't available; do one at a time. */
+ for (;;) {
+ obj = PyIter_Next(iter);
+ if (obj == NULL) {
+ if (PyErr_Occurred())
+ return -1;
+ break;
+ }
+ i = save(self, obj, 0);
+ Py_DECREF(obj);
+ if (i < 0)
+ return -1;
+ if (self->write_func(self, &append, 1) < 0)
+ return -1;
+ }
+ return 0;
}
/* proto > 0: write in batches of BATCHSIZE. */
do {
- /* Get next group of (no more than) BATCHSIZE elements. */
- for (n = 0; n < BATCHSIZE; ++n) {
- obj = PyIter_Next(iter);
- if (obj == NULL) {
- if (PyErr_Occurred())
- goto BatchFailed;
- break;
- }
- slice[n] = obj;
- }
-
- if (n > 1) {
- /* Pump out MARK, slice[0:n], APPENDS. */
- if (self->write_func(self, &MARKv, 1) < 0)
- goto BatchFailed;
- for (i = 0; i < n; ++i) {
- if (save(self, slice[i], 0) < 0)
- goto BatchFailed;
- }
- if (self->write_func(self, &appends, 1) < 0)
- goto BatchFailed;
- }
- else if (n == 1) {
- if (save(self, slice[0], 0) < 0)
- goto BatchFailed;
- if (self->write_func(self, &append, 1) < 0)
- goto BatchFailed;
- }
-
- for (i = 0; i < n; ++i) {
- Py_DECREF(slice[i]);
- }
+ /* Get next group of (no more than) BATCHSIZE elements. */
+ for (n = 0; n < BATCHSIZE; ++n) {
+ obj = PyIter_Next(iter);
+ if (obj == NULL) {
+ if (PyErr_Occurred())
+ goto BatchFailed;
+ break;
+ }
+ slice[n] = obj;
+ }
+
+ if (n > 1) {
+ /* Pump out MARK, slice[0:n], APPENDS. */
+ if (self->write_func(self, &MARKv, 1) < 0)
+ goto BatchFailed;
+ for (i = 0; i < n; ++i) {
+ if (save(self, slice[i], 0) < 0)
+ goto BatchFailed;
+ }
+ if (self->write_func(self, &appends, 1) < 0)
+ goto BatchFailed;
+ }
+ else if (n == 1) {
+ if (save(self, slice[0], 0) < 0)
+ goto BatchFailed;
+ if (self->write_func(self, &append, 1) < 0)
+ goto BatchFailed;
+ }
+
+ for (i = 0; i < n; ++i) {
+ Py_DECREF(slice[i]);
+ }
} while (n == BATCHSIZE);
return 0;
BatchFailed:
while (--n >= 0) {
- Py_DECREF(slice[n]);
+ Py_DECREF(slice[n]);
}
return -1;
}
@@ -1611,45 +1611,45 @@
PyObject *iter;
if (self->fast && !fast_save_enter(self, args))
- goto finally;
+ goto finally;
/* Create an empty list. */
if (self->bin) {
- s[0] = EMPTY_LIST;
- len = 1;
+ s[0] = EMPTY_LIST;
+ len = 1;
}
else {
- s[0] = MARK;
- s[1] = LIST;
- len = 2;
+ s[0] = MARK;
+ s[1] = LIST;
+ len = 2;
}
if (self->write_func(self, s, len) < 0)
- goto finally;
+ goto finally;
/* Get list length, and bow out early if empty. */
if ((len = PyList_Size(args)) < 0)
- goto finally;
+ goto finally;
/* Memoize. */
if (len == 0) {
- if (put(self, args) >= 0)
- res = 0;
- goto finally;
+ if (put(self, args) >= 0)
+ res = 0;
+ goto finally;
}
if (put2(self, args) < 0)
- goto finally;
+ goto finally;
/* Materialize the list elements. */
iter = PyObject_GetIter(args);
if (iter == NULL)
- goto finally;
+ goto finally;
res = batch_list(self, iter);
Py_DECREF(iter);
finally:
if (self->fast && !fast_save_leave(self, args))
- res = -1;
+ res = -1;
return res;
}
@@ -1679,82 +1679,82 @@
assert(iter != NULL);
if (self->proto == 0) {
- /* SETITEMS isn't available; do one at a time. */
- for (;;) {
- p = PyIter_Next(iter);
- if (p == NULL) {
- if (PyErr_Occurred())
- return -1;
- break;
- }
- if (!PyTuple_Check(p) || PyTuple_Size(p) != 2) {
- PyErr_SetString(PyExc_TypeError, "dict items "
- "iterator must return 2-tuples");
- return -1;
- }
- i = save(self, PyTuple_GET_ITEM(p, 0), 0);
- if (i >= 0)
- i = save(self, PyTuple_GET_ITEM(p, 1), 0);
- Py_DECREF(p);
- if (i < 0)
- return -1;
- if (self->write_func(self, &setitem, 1) < 0)
- return -1;
- }
- return 0;
+ /* SETITEMS isn't available; do one at a time. */
+ for (;;) {
+ p = PyIter_Next(iter);
+ if (p == NULL) {
+ if (PyErr_Occurred())
+ return -1;
+ break;
+ }
+ if (!PyTuple_Check(p) || PyTuple_Size(p) != 2) {
+ PyErr_SetString(PyExc_TypeError, "dict items "
+ "iterator must return 2-tuples");
+ return -1;
+ }
+ i = save(self, PyTuple_GET_ITEM(p, 0), 0);
+ if (i >= 0)
+ i = save(self, PyTuple_GET_ITEM(p, 1), 0);
+ Py_DECREF(p);
+ if (i < 0)
+ return -1;
+ if (self->write_func(self, &setitem, 1) < 0)
+ return -1;
+ }
+ return 0;
}
/* proto > 0: write in batches of BATCHSIZE. */
do {
- /* Get next group of (no more than) BATCHSIZE elements. */
- for (n = 0; n < BATCHSIZE; ++n) {
- p = PyIter_Next(iter);
- if (p == NULL) {
- if (PyErr_Occurred())
- goto BatchFailed;
- break;
- }
- if (!PyTuple_Check(p) || PyTuple_Size(p) != 2) {
- PyErr_SetString(PyExc_TypeError, "dict items "
- "iterator must return 2-tuples");
- goto BatchFailed;
- }
- slice[n] = p;
- }
-
- if (n > 1) {
- /* Pump out MARK, slice[0:n], SETITEMS. */
- if (self->write_func(self, &MARKv, 1) < 0)
- goto BatchFailed;
- for (i = 0; i < n; ++i) {
- p = slice[i];
- if (save(self, PyTuple_GET_ITEM(p, 0), 0) < 0)
- goto BatchFailed;
- if (save(self, PyTuple_GET_ITEM(p, 1), 0) < 0)
- goto BatchFailed;
- }
- if (self->write_func(self, &setitems, 1) < 0)
- goto BatchFailed;
- }
- else if (n == 1) {
- p = slice[0];
- if (save(self, PyTuple_GET_ITEM(p, 0), 0) < 0)
- goto BatchFailed;
- if (save(self, PyTuple_GET_ITEM(p, 1), 0) < 0)
- goto BatchFailed;
- if (self->write_func(self, &setitem, 1) < 0)
- goto BatchFailed;
- }
-
- for (i = 0; i < n; ++i) {
- Py_DECREF(slice[i]);
- }
+ /* Get next group of (no more than) BATCHSIZE elements. */
+ for (n = 0; n < BATCHSIZE; ++n) {
+ p = PyIter_Next(iter);
+ if (p == NULL) {
+ if (PyErr_Occurred())
+ goto BatchFailed;
+ break;
+ }
+ if (!PyTuple_Check(p) || PyTuple_Size(p) != 2) {
+ PyErr_SetString(PyExc_TypeError, "dict items "
+ "iterator must return 2-tuples");
+ goto BatchFailed;
+ }
+ slice[n] = p;
+ }
+
+ if (n > 1) {
+ /* Pump out MARK, slice[0:n], SETITEMS. */
+ if (self->write_func(self, &MARKv, 1) < 0)
+ goto BatchFailed;
+ for (i = 0; i < n; ++i) {
+ p = slice[i];
+ if (save(self, PyTuple_GET_ITEM(p, 0), 0) < 0)
+ goto BatchFailed;
+ if (save(self, PyTuple_GET_ITEM(p, 1), 0) < 0)
+ goto BatchFailed;
+ }
+ if (self->write_func(self, &setitems, 1) < 0)
+ goto BatchFailed;
+ }
+ else if (n == 1) {
+ p = slice[0];
+ if (save(self, PyTuple_GET_ITEM(p, 0), 0) < 0)
+ goto BatchFailed;
+ if (save(self, PyTuple_GET_ITEM(p, 1), 0) < 0)
+ goto BatchFailed;
+ if (self->write_func(self, &setitem, 1) < 0)
+ goto BatchFailed;
+ }
+
+ for (i = 0; i < n; ++i) {
+ Py_DECREF(slice[i]);
+ }
} while (n == BATCHSIZE);
return 0;
BatchFailed:
while (--n >= 0) {
- Py_DECREF(slice[n]);
+ Py_DECREF(slice[n]);
}
return -1;
}
@@ -1768,48 +1768,48 @@
PyObject *items, *iter;
if (self->fast && !fast_save_enter(self, args))
- goto finally;
+ goto finally;
/* Create an empty dict. */
if (self->bin) {
- s[0] = EMPTY_DICT;
- len = 1;
+ s[0] = EMPTY_DICT;
+ len = 1;
}
else {
- s[0] = MARK;
- s[1] = DICT;
- len = 2;
+ s[0] = MARK;
+ s[1] = DICT;
+ len = 2;
}
if (self->write_func(self, s, len) < 0)
- goto finally;
+ goto finally;
/* Get dict size, and bow out early if empty. */
if ((len = PyDict_Size(args)) < 0)
- goto finally;
+ goto finally;
if (len == 0) {
- if (put(self, args) >= 0)
- res = 0;
- goto finally;
+ if (put(self, args) >= 0)
+ res = 0;
+ goto finally;
}
if (put2(self, args) < 0)
- goto finally;
+ goto finally;
/* Materialize the dict items. */
items = PyObject_CallMethod(args, "items", "()");
if (items == NULL)
- goto finally;
+ goto finally;
iter = PyObject_GetIter(items);
Py_DECREF(items);
if (iter == NULL)
- goto finally;
+ goto finally;
res = batch_dict(self, iter);
Py_DECREF(iter);
finally:
if (self->fast && !fast_save_leave(self, args))
- res = -1;
+ res = -1;
return res;
}
@@ -1825,20 +1825,20 @@
static char global = GLOBAL;
if (name) {
- global_name = name;
- Py_INCREF(global_name);
+ global_name = name;
+ Py_INCREF(global_name);
}
else {
- if (!(global_name = PyObject_GetAttr(args, __name___str)))
- goto finally;
+ if (!(global_name = PyObject_GetAttr(args, __name___str)))
+ goto finally;
}
if (!(module = whichmodule(args, global_name)))
- goto finally;
+ goto finally;
if ((module_size = PyString_Size(module)) < 0 ||
- (name_size = PyString_Size(global_name)) < 0)
- goto finally;
+ (name_size = PyString_Size(global_name)) < 0)
+ goto finally;
module_str = PyString_AS_STRING((PyStringObject *) module);
name_str = PyString_AS_STRING((PyStringObject *) global_name);
@@ -1847,101 +1847,101 @@
* but I don't know how to stop it. :-( */
mod = PyImport_ImportModule(module_str);
if (mod == NULL) {
- cPickle_ErrFormat(PicklingError,
- "Can't pickle %s: import of module %s "
- "failed", "OS", args, module);
- goto finally;
+ cPickle_ErrFormat(PicklingError,
+ "Can't pickle %s: import of module %s "
+ "failed", "OS", args, module);
+ goto finally;
}
klass = PyObject_GetAttrString(mod, name_str);
if (klass == NULL) {
- cPickle_ErrFormat(PicklingError,
- "Can't pickle %s: attribute lookup %s.%s "
- "failed", "OSS", args, module, global_name);
- goto finally;
+ cPickle_ErrFormat(PicklingError,
+ "Can't pickle %s: attribute lookup %s.%s "
+ "failed", "OSS", args, module, global_name);
+ goto finally;
}
if (klass != args) {
- Py_DECREF(klass);
- cPickle_ErrFormat(PicklingError,
- "Can't pickle %s: it's not the same object "
- "as %s.%s", "OSS", args, module, global_name);
- goto finally;
+ Py_DECREF(klass);
+ cPickle_ErrFormat(PicklingError,
+ "Can't pickle %s: it's not the same object "
+ "as %s.%s", "OSS", args, module, global_name);
+ goto finally;
}
Py_DECREF(klass);
if (self->proto >= 2) {
- /* See whether this is in the extension registry, and if
- * so generate an EXT opcode.
- */
- PyObject *py_code; /* extension code as Python object */
- long code; /* extension code as C value */
- char c_str[5];
- int n;
-
- PyTuple_SET_ITEM(two_tuple, 0, module);
- PyTuple_SET_ITEM(two_tuple, 1, global_name);
- py_code = PyDict_GetItem(extension_registry, two_tuple);
- if (py_code == NULL)
- goto gen_global; /* not registered */
-
- /* Verify py_code has the right type and value. */
- if (!PyInt_Check(py_code)) {
- cPickle_ErrFormat(PicklingError, "Can't pickle %s: "
- "extension code %s isn't an integer",
- "OO", args, py_code);
- goto finally;
- }
- code = PyInt_AS_LONG(py_code);
- if (code <= 0 || code > 0x7fffffffL) {
- cPickle_ErrFormat(PicklingError, "Can't pickle %s: "
- "extension code %ld is out of range",
- "Ol", args, code);
- goto finally;
- }
-
- /* Generate an EXT opcode. */
- if (code <= 0xff) {
- c_str[0] = EXT1;
- c_str[1] = (char) code;
- n = 2;
- }
- else if (code <= 0xffff) {
- c_str[0] = EXT2;
- c_str[1] = (char) (code & 0xff);
- c_str[2] = (char) ((code >> 8) & 0xff);
- n = 3;
- }
- else {
- c_str[0] = EXT4;
- c_str[1] = (char) (code & 0xff);
- c_str[2] = (char) ((code >> 8) & 0xff);
- c_str[3] = (char) ((code >> 16) & 0xff);
- c_str[4] = (char) ((code >> 24) & 0xff);
- n = 5;
- }
-
- if (self->write_func(self, c_str, n) >= 0)
- res = 0;
- goto finally; /* and don't memoize */
+ /* See whether this is in the extension registry, and if
+ * so generate an EXT opcode.
+ */
+ PyObject *py_code; /* extension code as Python object */
+ long code; /* extension code as C value */
+ char c_str[5];
+ int n;
+
+ PyTuple_SET_ITEM(two_tuple, 0, module);
+ PyTuple_SET_ITEM(two_tuple, 1, global_name);
+ py_code = PyDict_GetItem(extension_registry, two_tuple);
+ if (py_code == NULL)
+ goto gen_global; /* not registered */
+
+ /* Verify py_code has the right type and value. */
+ if (!PyInt_Check(py_code)) {
+ cPickle_ErrFormat(PicklingError, "Can't pickle %s: "
+ "extension code %s isn't an integer",
+ "OO", args, py_code);
+ goto finally;
+ }
+ code = PyInt_AS_LONG(py_code);
+ if (code <= 0 || code > 0x7fffffffL) {
+ cPickle_ErrFormat(PicklingError, "Can't pickle %s: "
+ "extension code %ld is out of range",
+ "Ol", args, code);
+ goto finally;
+ }
+
+ /* Generate an EXT opcode. */
+ if (code <= 0xff) {
+ c_str[0] = EXT1;
+ c_str[1] = (char) code;
+ n = 2;
+ }
+ else if (code <= 0xffff) {
+ c_str[0] = EXT2;
+ c_str[1] = (char) (code & 0xff);
+ c_str[2] = (char) ((code >> 8) & 0xff);
+ n = 3;
+ }
+ else {
+ c_str[0] = EXT4;
+ c_str[1] = (char) (code & 0xff);
+ c_str[2] = (char) ((code >> 8) & 0xff);
+ c_str[3] = (char) ((code >> 16) & 0xff);
+ c_str[4] = (char) ((code >> 24) & 0xff);
+ n = 5;
+ }
+
+ if (self->write_func(self, c_str, n) >= 0)
+ res = 0;
+ goto finally; /* and don't memoize */
}
gen_global:
if (self->write_func(self, &global, 1) < 0)
- goto finally;
+ goto finally;
if (self->write_func(self, module_str, module_size) < 0)
- goto finally;
+ goto finally;
if (self->write_func(self, "\n", 1) < 0)
- goto finally;
+ goto finally;
if (self->write_func(self, name_str, name_size) < 0)
- goto finally;
+ goto finally;
if (self->write_func(self, "\n", 1) < 0)
- goto finally;
+ goto finally;
if (put(self, args) < 0)
- goto finally;
+ goto finally;
res = 0;
@@ -1964,44 +1964,44 @@
Py_INCREF(args);
ARG_TUP(self, args);
if (self->arg) {
- pid = PyObject_Call(f, self->arg, NULL);
- FREE_ARG_TUP(self);
+ pid = PyObject_Call(f, self->arg, NULL);
+ FREE_ARG_TUP(self);
}
if (!pid)
- return -1;
+ 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 (!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;
+ }
- goto finally;
+ goto finally;
}
res = 0;
@@ -2031,129 +2031,129 @@
static char newobj = NEWOBJ;
if (!PyArg_UnpackTuple(args, "save_reduce", 2, 5,
- &callable, &argtup, &state, &listitems, &dictitems))
- return -1;
+ &callable, &argtup, &state, &listitems, &dictitems))
+ return -1;
if (!PyTuple_Check(argtup)) {
- PyErr_SetString(PicklingError, "args from reduce() should be a tuple");
- return -1;
+ PyErr_SetString(PicklingError, "args from reduce() should be a tuple");
+ return -1;
}
if (state == Py_None)
- state = NULL;
+ state = NULL;
if (listitems == Py_None)
- listitems = NULL;
+ listitems = NULL;
if (dictitems == Py_None)
- dictitems = NULL;
+ dictitems = NULL;
/* Protocol 2 special case: if callable's name is __newobj__, use
* NEWOBJ. This consumes a lot of code.
*/
if (use_newobj) {
- PyObject *temp = PyObject_GetAttr(callable, __name___str);
+ PyObject *temp = PyObject_GetAttr(callable, __name___str);
- if (temp == NULL) {
- if (PyErr_ExceptionMatches(PyExc_AttributeError))
- PyErr_Clear();
- else
- return -1;
- use_newobj = 0;
- }
- else {
- use_newobj = PyString_Check(temp) &&
- strcmp(PyString_AS_STRING(temp), "__newobj__") == 0;
- Py_DECREF(temp);
- }
+ if (temp == NULL) {
+ if (PyErr_ExceptionMatches(PyExc_AttributeError))
+ PyErr_Clear();
+ else
+ return -1;
+ use_newobj = 0;
+ }
+ else {
+ use_newobj = PyString_Check(temp) &&
+ strcmp(PyString_AS_STRING(temp), "__newobj__") == 0;
+ Py_DECREF(temp);
+ }
}
if (use_newobj) {
- PyObject *cls;
- PyObject *newargtup;
- int n, i;
-
- /* Sanity checks. */
- n = PyTuple_Size(argtup);
- if (n < 1) {
- PyErr_SetString(PicklingError, "__newobj__ arglist " "is empty");
- return -1;
- }
-
- cls = PyTuple_GET_ITEM(argtup, 0);
- if (!PyObject_HasAttrString(cls, "__new__")) {
- PyErr_SetString(PicklingError, "args[0] from "
- "__newobj__ args has no __new__");
- return -1;
- }
-
- /* XXX How could ob be NULL? */
- if (ob != NULL) {
- PyObject *ob_dot_class;
-
- ob_dot_class = PyObject_GetAttr(ob, __class___str);
- if (ob_dot_class == NULL) {
- if (PyErr_ExceptionMatches(PyExc_AttributeError))
- PyErr_Clear();
- else
- return -1;
- }
- i = ob_dot_class != cls; /* true iff a problem */
- Py_XDECREF(ob_dot_class);
- if (i) {
- PyErr_SetString(PicklingError, "args[0] from "
- "__newobj__ args has the wrong class");
- return -1;
- }
- }
-
- /* Save the class and its __new__ arguments. */
- if (save(self, cls, 0) < 0)
- return -1;
-
- newargtup = PyTuple_New(n - 1); /* argtup[1:] */
- if (newargtup == NULL)
- return -1;
- for (i = 1; i < n; ++i) {
- PyObject *temp = PyTuple_GET_ITEM(argtup, i);
- Py_INCREF(temp);
- PyTuple_SET_ITEM(newargtup, i - 1, temp);
- }
- i = save(self, newargtup, 0) < 0;
- Py_DECREF(newargtup);
- if (i < 0)
- return -1;
-
- /* Add NEWOBJ opcode. */
- if (self->write_func(self, &newobj, 1) < 0)
- return -1;
+ PyObject *cls;
+ PyObject *newargtup;
+ int n, i;
+
+ /* Sanity checks. */
+ n = PyTuple_Size(argtup);
+ if (n < 1) {
+ PyErr_SetString(PicklingError, "__newobj__ arglist " "is empty");
+ return -1;
+ }
+
+ cls = PyTuple_GET_ITEM(argtup, 0);
+ if (!PyObject_HasAttrString(cls, "__new__")) {
+ PyErr_SetString(PicklingError, "args[0] from "
+ "__newobj__ args has no __new__");
+ return -1;
+ }
+
+ /* XXX How could ob be NULL? */
+ if (ob != NULL) {
+ PyObject *ob_dot_class;
+
+ ob_dot_class = PyObject_GetAttr(ob, __class___str);
+ if (ob_dot_class == NULL) {
+ if (PyErr_ExceptionMatches(PyExc_AttributeError))
+ PyErr_Clear();
+ else
+ return -1;
+ }
+ i = ob_dot_class != cls; /* true iff a problem */
+ Py_XDECREF(ob_dot_class);
+ if (i) {
+ PyErr_SetString(PicklingError, "args[0] from "
+ "__newobj__ args has the wrong class");
+ return -1;
+ }
+ }
+
+ /* Save the class and its __new__ arguments. */
+ if (save(self, cls, 0) < 0)
+ return -1;
+
+ newargtup = PyTuple_New(n - 1); /* argtup[1:] */
+ if (newargtup == NULL)
+ return -1;
+ for (i = 1; i < n; ++i) {
+ PyObject *temp = PyTuple_GET_ITEM(argtup, i);
+ Py_INCREF(temp);
+ PyTuple_SET_ITEM(newargtup, i - 1, temp);
+ }
+ i = save(self, newargtup, 0) < 0;
+ Py_DECREF(newargtup);
+ if (i < 0)
+ return -1;
+
+ /* Add NEWOBJ opcode. */
+ if (self->write_func(self, &newobj, 1) < 0)
+ return -1;
}
else {
- /* Not using NEWOBJ. */
- if (save(self, callable, 0) < 0 ||
- save(self, argtup, 0) < 0 ||
- self->write_func(self, &reduce, 1) < 0)
- return -1;
+ /* Not using NEWOBJ. */
+ if (save(self, callable, 0) < 0 ||
+ save(self, argtup, 0) < 0 ||
+ self->write_func(self, &reduce, 1) < 0)
+ return -1;
}
/* Memoize. */
/* XXX How can ob be NULL? */
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 && !PyDict_Check(state)) {
+ if (put2(self, ob) < 0)
+ return -1;
+ }
+ else if (put(self, ob) < 0)
+ return -1;
}
if (listitems && batch_list(self, listitems) < 0)
- return -1;
+ return -1;
if (dictitems && batch_dict(self, dictitems) < 0)
- return -1;
+ return -1;
if (state) {
- if (save(self, state, 0) < 0 || self->write_func(self, &build, 1) < 0)
- return -1;
+ if (save(self, state, 0) < 0 || self->write_func(self, &build, 1) < 0)
+ return -1;
}
return 0;
@@ -2169,158 +2169,158 @@
int tmp, size;
if (self->nesting++ > Py_GetRecursionLimit()) {
- PyErr_SetString(PyExc_RuntimeError,
- "maximum recursion depth exceeded");
- goto finally;
+ PyErr_SetString(PyExc_RuntimeError,
+ "maximum recursion depth exceeded");
+ goto finally;
}
if (!pers_save && self->pers_func) {
- if ((tmp = save_pers(self, args, self->pers_func)) != 0) {
- res = tmp;
- goto finally;
- }
+ 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;
+ res = save_none(self, args);
+ goto finally;
}
type = args->ob_type;
switch (type->tp_name[0]) {
case 'b':
- if (args == Py_False || args == Py_True) {
- res = save_bool(self, args);
- goto finally;
- }
- break;
+ if (args == Py_False || args == Py_True) {
+ res = save_bool(self, args);
+ goto finally;
+ }
+ break;
case 'i':
- 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) {
- res = save_tuple(self, args);
- goto finally;
- }
- break;
+ if (type == &PyTuple_Type && PyTuple_Size(args) == 0) {
+ 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 (!(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;
-
- res = 0;
- goto finally;
- }
+ if (PyDict_GetItem(self->memo, py_ob_id)) {
+ if (get(self, py_ob_id) < 0)
+ goto finally;
+
+ res = 0;
+ goto finally;
+ }
}
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':
- break;
+ break;
case 'c':
- break;
+ break;
case 'f':
- if (type == &PyFunction_Type) {
- res = save_global(self, args, NULL);
- if (res && PyErr_ExceptionMatches(PickleError)) {
- /* fall back to reduce */
- PyErr_Clear();
- break;
- }
- goto finally;
- }
- break;
+ if (type == &PyFunction_Type) {
+ res = save_global(self, args, NULL);
+ if (res && PyErr_ExceptionMatches(PickleError)) {
+ /* fall back to reduce */
+ PyErr_Clear();
+ break;
+ }
+ goto finally;
+ }
+ break;
case 'b':
- if (type == &PyCFunction_Type) {
- res = save_global(self, args, NULL);
- goto finally;
- }
+ if (type == &PyCFunction_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 ((tmp = save_pers(self, args, self->inst_pers_func)) != 0) {
+ res = tmp;
+ goto finally;
+ }
}
if (PyType_IsSubtype(type, &PyType_Type)) {
- res = save_global(self, args, NULL);
- goto finally;
+ res = save_global(self, args, NULL);
+ goto finally;
}
/* Get a reduction callable, and call it. This may come from
@@ -2329,73 +2329,73 @@
*/
__reduce__ = PyDict_GetItem(dispatch_table, (PyObject *) type);
if (__reduce__ != NULL) {
- Py_INCREF(__reduce__);
- Py_INCREF(args);
- ARG_TUP(self, args);
- if (self->arg) {
- t = PyObject_Call(__reduce__, self->arg, NULL);
- FREE_ARG_TUP(self);
- }
+ Py_INCREF(__reduce__);
+ Py_INCREF(args);
+ ARG_TUP(self, args);
+ if (self->arg) {
+ t = PyObject_Call(__reduce__, self->arg, NULL);
+ FREE_ARG_TUP(self);
+ }
}
else {
- /* Check for a __reduce_ex__ method. */
- __reduce__ = PyObject_GetAttr(args, __reduce_ex___str);
- if (__reduce__ != NULL) {
- t = PyInt_FromLong(self->proto);
- if (t != NULL) {
- ARG_TUP(self, t);
- t = NULL;
- if (self->arg) {
- t = PyObject_Call(__reduce__, self->arg, NULL);
- FREE_ARG_TUP(self);
- }
- }
- }
- else {
- if (PyErr_ExceptionMatches(PyExc_AttributeError))
- PyErr_Clear();
- else
- goto finally;
- /* Check for a __reduce__ method. */
- __reduce__ = PyObject_GetAttr(args, __reduce___str);
- if (__reduce__ != NULL) {
- t = PyObject_Call(__reduce__, empty_tuple, NULL);
- }
- else {
- PyErr_SetObject(UnpickleableError, args);
- goto finally;
- }
- }
+ /* Check for a __reduce_ex__ method. */
+ __reduce__ = PyObject_GetAttr(args, __reduce_ex___str);
+ if (__reduce__ != NULL) {
+ t = PyInt_FromLong(self->proto);
+ if (t != NULL) {
+ ARG_TUP(self, t);
+ t = NULL;
+ if (self->arg) {
+ t = PyObject_Call(__reduce__, self->arg, NULL);
+ FREE_ARG_TUP(self);
+ }
+ }
+ }
+ else {
+ if (PyErr_ExceptionMatches(PyExc_AttributeError))
+ PyErr_Clear();
+ else
+ goto finally;
+ /* Check for a __reduce__ method. */
+ __reduce__ = PyObject_GetAttr(args, __reduce___str);
+ if (__reduce__ != NULL) {
+ t = PyObject_Call(__reduce__, empty_tuple, NULL);
+ }
+ else {
+ PyErr_SetObject(UnpickleableError, args);
+ goto finally;
+ }
+ }
}
if (t == NULL)
- goto finally;
+ goto finally;
if (PyString_Check(t)) {
- res = save_global(self, args, t);
- goto finally;
+ res = save_global(self, args, t);
+ goto finally;
}
if (!PyTuple_Check(t)) {
- cPickle_ErrFormat(PicklingError, "Value returned by "
- "%s must be string or tuple", "O", __reduce__);
- goto finally;
+ cPickle_ErrFormat(PicklingError, "Value returned by "
+ "%s must be string or tuple", "O", __reduce__);
+ goto finally;
}
size = PyTuple_Size(t);
if (size < 2 || size > 5) {
- cPickle_ErrFormat(PicklingError, "tuple returned by "
- "%s must contain 2 through 5 elements",
- "O", __reduce__);
- goto finally;
+ cPickle_ErrFormat(PicklingError, "tuple returned by "
+ "%s must contain 2 through 5 elements",
+ "O", __reduce__);
+ goto finally;
}
arg_tup = PyTuple_GET_ITEM(t, 1);
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;
+ cPickle_ErrFormat(PicklingError, "Second element of "
+ "tuple returned by %s must be a tuple",
+ "O", __reduce__);
+ goto finally;
}
res = save_reduce(self, t, args);
@@ -2416,23 +2416,23 @@
static char stop = STOP;
if (self->proto >= 2) {
- char bytes[2];
+ char bytes[2];
- bytes[0] = PROTO;
- assert(self->proto >= 0 && self->proto < 256);
- bytes[1] = (char) self->proto;
- if (self->write_func(self, bytes, 2) < 0)
- return -1;
+ bytes[0] = PROTO;
+ assert(self->proto >= 0 && self->proto < 256);
+ bytes[1] = (char) self->proto;
+ if (self->write_func(self, bytes, 2) < 0)
+ return -1;
}
if (save(self, args, 0) < 0)
- return -1;
+ return -1;
if (self->write_func(self, &stop, 1) < 0)
- return -1;
+ return -1;
if (self->write_func(self, NULL, 0) < 0)
- return -1;
+ return -1;
return 0;
}
@@ -2441,7 +2441,7 @@
Pickle_clear_memo(Picklerobject * self, PyObject * args)
{
if (self->memo)
- PyDict_Clear(self->memo);
+ PyDict_Clear(self->memo);
Py_INCREF(Py_None);
return Py_None;
}
@@ -2457,18 +2457,18 @@
/* Can be called by Python code or C code */
if (args && !PyArg_ParseTuple(args, "|i:getvalue", &clear))
- return NULL;
+ 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;
+ 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;
+ return NULL;
data = (Pdata *) self->file;
l = data->length;
@@ -2476,112 +2476,112 @@
/* set up an array to hold get/put status */
lm = PyDict_Size(self->memo);
if (lm < 0)
- return NULL;
+ return NULL;
lm++;
have_get = malloc(lm);
if (have_get == NULL)
- return PyErr_NoMemory();
+ return PyErr_NoMemory();
memset(have_get, 0, lm);
/* Scan for gets. */
for (rsize = 0, i = l; --i >= 0;) {
- k = data->data[i];
+ k = data->data[i];
- if (PyString_Check(k))
- rsize += PyString_GET_SIZE(k);
+ if (PyString_Check(k))
+ rsize += PyString_GET_SIZE(k);
- else if (PyInt_Check(k)) { /* put */
- ik = PyInt_AsLong(k);
- if (ik == -1 && PyErr_Occurred())
- goto err;
- if (ik >= lm || ik == 0) {
- PyErr_SetString(PicklingError, "Invalid get data");
- goto err;
- }
- if (have_get[ik]) /* with matching get */
- rsize += ik < 256 ? 2 : 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");
- goto err;
- }
-
- else { /* put */
- ik = PyInt_AsLong(k);
- if (ik == -1 && PyErr_Occurred())
- goto err;
- if (ik >= lm || ik == 0) {
- PyErr_SetString(PicklingError, "Invalid get data");
- return NULL;
- }
- have_get[ik] = 1;
- rsize += ik < 256 ? 2 : 5;
- }
+ else if (PyInt_Check(k)) { /* put */
+ ik = PyInt_AsLong(k);
+ if (ik == -1 && PyErr_Occurred())
+ goto err;
+ if (ik >= lm || ik == 0) {
+ PyErr_SetString(PicklingError, "Invalid get data");
+ goto err;
+ }
+ if (have_get[ik]) /* with matching get */
+ rsize += ik < 256 ? 2 : 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");
+ goto err;
+ }
+
+ else { /* put */
+ ik = PyInt_AsLong(k);
+ if (ik == -1 && PyErr_Occurred())
+ goto err;
+ if (ik >= lm || ik == 0) {
+ PyErr_SetString(PicklingError, "Invalid get data");
+ return NULL;
+ }
+ have_get[ik] = 1;
+ rsize += ik < 256 ? 2 : 5;
+ }
}
/* Now generate the result */
r = PyString_FromStringAndSize(NULL, rsize);
if (r == NULL)
- goto err;
+ goto err;
s = PyString_AS_STRING((PyStringObject *) r);
for (i = 0; i < l; i++) {
- k = data->data[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 = PyLong_AsLong(PyTuple_GET_ITEM(k, 0));
- if (ik == -1 && PyErr_Occurred())
- goto err;
- 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 = PyLong_AsLong(k);
- if (ik == -1 && PyErr_Occurred())
- goto err;
-
- 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 (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 = PyLong_AsLong(PyTuple_GET_ITEM(k, 0));
+ if (ik == -1 && PyErr_Occurred())
+ goto err;
+ 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 = PyLong_AsLong(k);
+ if (ik == -1 && PyErr_Occurred())
+ goto err;
+
+ 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);
+ PyDict_Clear(self->memo);
+ Pdata_clear(data, 0);
}
free(have_get);
@@ -2598,13 +2598,13 @@
int get = 0;
if (!(PyArg_ParseTuple(args, "O|i:dump", &ob, &get)))
- return NULL;
+ return NULL;
if (dump(self, ob) < 0)
- return NULL;
+ return NULL;
if (get)
- return Pickle_getvalue(self, NULL);
+ return Pickle_getvalue(self, NULL);
/* XXX Why does dump() return self? */
Py_INCREF(self);
@@ -2615,12 +2615,12 @@
static struct PyMethodDef Pickler_methods[] = {
{"dump", (PyCFunction) Pickler_dump, METH_VARARGS,
PyDoc_STR("dump(object) -- "
- "Write an object in pickle format to the object's pickle stream")},
+ "Write an object in pickle format to the object's pickle stream")},
{"clear_memo", (PyCFunction) Pickle_clear_memo, METH_NOARGS,
PyDoc_STR("clear_memo() -- Clear the picklers memo")},
{"getvalue", (PyCFunction) Pickle_getvalue, METH_VARARGS,
PyDoc_STR("getvalue() -- Finish picking a list-based pickle")},
- {NULL, NULL} /* sentinel */
+ {NULL, NULL} /* sentinel */
};
@@ -2630,17 +2630,17 @@
Picklerobject *self;
if (proto < 0)
- proto = HIGHEST_PROTOCOL;
+ proto = HIGHEST_PROTOCOL;
if (proto > HIGHEST_PROTOCOL) {
- PyErr_Format(PyExc_ValueError, "pickle protocol %d asked for; "
- "the highest available protocol is %d",
- proto, HIGHEST_PROTOCOL);
- return NULL;
+ PyErr_Format(PyExc_ValueError, "pickle protocol %d asked for; "
+ "the highest available protocol is %d",
+ proto, HIGHEST_PROTOCOL);
+ return NULL;
}
self = PyObject_GC_New(Picklerobject, &Picklertype);
if (self == NULL)
- return NULL;
+ return NULL;
self->proto = proto;
self->bin = proto > 0;
self->fp = NULL;
@@ -2659,49 +2659,49 @@
self->file = NULL;
if (file)
- Py_INCREF(file);
+ Py_INCREF(file);
else {
- file = Pdata_New();
- if (file == NULL)
- goto err;
+ file = Pdata_New();
+ if (file == NULL)
+ goto err;
}
self->file = file;
if (!(self->memo = PyDict_New()))
- goto err;
+ 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;
+ 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;
+ self->write_func = write_cStringIO;
}
else if (file == Py_None) {
- self->write_func = write_none;
+ self->write_func = write_none;
}
else {
- self->write_func = write_other;
+ 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;
- }
- }
-
- self->write_buf = (char *) PyMem_Malloc(WRITE_BUF_SIZE);
- if (self->write_buf == NULL) {
- PyErr_NoMemory();
- goto err;
- }
+ 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;
+ }
+ }
+
+ self->write_buf = (char *) PyMem_Malloc(WRITE_BUF_SIZE);
+ if (self->write_buf == NULL) {
+ PyErr_NoMemory();
+ goto err;
+ }
}
self->dispatch_table = dispatch_table;
@@ -2731,11 +2731,11 @@
* far enough to figure out what it means.
*/
if (!PyArg_ParseTuple(args, "|i:Pickler", &proto)) {
- PyErr_Clear();
- proto = 0;
- if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|i:Pickler",
- kwlist, &file, &proto))
- return NULL;
+ PyErr_Clear();
+ proto = 0;
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|i:Pickler",
+ kwlist, &file, &proto))
+ return NULL;
}
return (PyObject *) newPicklerobject(file, proto);
}
@@ -2789,9 +2789,9 @@
Pickler_get_pers_func(Picklerobject * p)
{
if (p->pers_func == NULL)
- PyErr_SetString(PyExc_AttributeError, "persistent_id");
+ PyErr_SetString(PyExc_AttributeError, "persistent_id");
else
- Py_INCREF(p->pers_func);
+ Py_INCREF(p->pers_func);
return p->pers_func;
}
@@ -2799,9 +2799,9 @@
Pickler_set_pers_func(Picklerobject * p, PyObject * v)
{
if (v == NULL) {
- PyErr_SetString(PyExc_TypeError,
- "attribute deletion is not supported");
- return -1;
+ PyErr_SetString(PyExc_TypeError,
+ "attribute deletion is not supported");
+ return -1;
}
Py_XDECREF(p->pers_func);
Py_INCREF(v);
@@ -2813,9 +2813,9 @@
Pickler_set_inst_pers_func(Picklerobject * p, PyObject * v)
{
if (v == NULL) {
- PyErr_SetString(PyExc_TypeError,
- "attribute deletion is not supported");
- return -1;
+ PyErr_SetString(PyExc_TypeError,
+ "attribute deletion is not supported");
+ return -1;
}
Py_XDECREF(p->inst_pers_func);
Py_INCREF(v);
@@ -2827,9 +2827,9 @@
Pickler_get_memo(Picklerobject * p)
{
if (p->memo == NULL)
- PyErr_SetString(PyExc_AttributeError, "memo");
+ PyErr_SetString(PyExc_AttributeError, "memo");
else
- Py_INCREF(p->memo);
+ Py_INCREF(p->memo);
return p->memo;
}
@@ -2837,13 +2837,13 @@
Pickler_set_memo(Picklerobject * p, PyObject * v)
{
if (v == NULL) {
- PyErr_SetString(PyExc_TypeError,
- "attribute deletion is not supported");
- return -1;
+ 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;
+ PyErr_SetString(PyExc_TypeError, "memo must be a dictionary");
+ return -1;
}
Py_XDECREF(p->memo);
Py_INCREF(v);
@@ -2878,36 +2878,36 @@
static PyTypeObject Picklertype = {
PyObject_HEAD_INIT(NULL)
- 0, /*ob_size */
- "cPickle.Pickler", /*tp_name */
- sizeof(Picklerobject), /*tp_basicsize */
+ 0, /*ob_size */
+ "cPickle.Pickler", /*tp_name */
+ sizeof(Picklerobject), /*tp_basicsize */
0,
- (destructor) Pickler_dealloc, /* tp_dealloc */
- 0, /* tp_print */
- 0, /* tp_getattr */
- 0, /* tp_setattr */
- 0, /* tp_compare */
- 0, /* tp_repr */
- 0, /* tp_as_number */
- 0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- 0, /* tp_hash */
- 0, /* tp_call */
- 0, /* tp_str */
- PyObject_GenericGetAttr, /* tp_getattro */
- PyObject_GenericSetAttr, /* tp_setattro */
- 0, /* tp_as_buffer */
+ (destructor) Pickler_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ PyObject_GenericGetAttr, /* tp_getattro */
+ PyObject_GenericSetAttr, /* tp_setattro */
+ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
- Picklertype__doc__, /* tp_doc */
- (traverseproc) Pickler_traverse, /* tp_traverse */
- (inquiry) Pickler_clear, /* tp_clear */
- 0, /* tp_richcompare */
- 0, /* tp_weaklistoffset */
- 0, /* tp_iter */
- 0, /* tp_iternext */
- Pickler_methods, /* tp_methods */
- Pickler_members, /* tp_members */
- Pickler_getsets, /* tp_getset */
+ Picklertype__doc__, /* tp_doc */
+ (traverseproc) Pickler_traverse, /* tp_traverse */
+ (inquiry) Pickler_clear, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ Pickler_methods, /* tp_methods */
+ Pickler_members, /* tp_members */
+ Pickler_getsets, /* tp_getset */
};
static PyObject *
@@ -2916,29 +2916,29 @@
PyObject *global = 0, *module;
if (fc) {
- if (fc == Py_None) {
- PyErr_SetString(UnpicklingError, "Global and instance "
- "pickles are not supported.");
- return NULL;
- }
- return PyObject_CallFunctionObjArgs(fc, py_module_name,
- py_global_name, NULL);
+ if (fc == Py_None) {
+ PyErr_SetString(UnpicklingError, "Global and instance "
+ "pickles are not supported.");
+ return NULL;
+ }
+ return PyObject_CallFunctionObjArgs(fc, py_module_name,
+ py_global_name, NULL);
}
module = PySys_GetObject("modules");
if (module == NULL)
- return 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);
+ 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);
+ global = PyObject_GetAttr(module, py_global_name);
return global;
}
@@ -2946,8 +2946,8 @@
marker(Unpicklerobject * self)
{
if (self->num_marks < 1) {
- PyErr_SetString(UnpicklingError, "could not find MARK");
- return -1;
+ PyErr_SetString(UnpicklingError, "could not find MARK");
+ return -1;
}
return self->marks[--self->num_marks];
@@ -2977,35 +2977,35 @@
long l;
if ((len = self->readline_func(self, &s)) < 0)
- return -1;
+ return -1;
if (len < 2)
- return bad_readline();
+ return bad_readline();
if (!(s = pystrndup(s, len)))
- return -1;
+ 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;
- }
+ /* 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 (len == 3 && (l == 0 || l == 1)) {
- if (!(py_int = PyBool_FromLong(l)))
- goto finally;
- }
- else {
- if (!(py_int = PyInt_FromLong(l)))
- goto finally;
- }
+ if (len == 3 && (l == 0 || l == 1)) {
+ if (!(py_int = PyBool_FromLong(l)))
+ goto finally;
+ }
+ else {
+ if (!(py_int = PyInt_FromLong(l)))
+ goto finally;
+ }
}
free(s);
@@ -3039,8 +3039,8 @@
long l;
for (i = 0, l = 0L; i < x; i++) {
- c = (unsigned char) s[i];
- l |= (long) c << (i * 8);
+ c = (unsigned char) s[i];
+ l |= (long) c << (i * 8);
}
#if SIZEOF_LONG > 4
/* Unlike BININT1 and BININT2, BININT (more accurately BININT4)
@@ -3048,7 +3048,7 @@
* to extend a BININT's sign bit to the full width.
*/
if (x == 4 && l & (1L << 31))
- l |= (~0L) << 32;
+ l |= (~0L) << 32;
#endif
return l;
}
@@ -3063,7 +3063,7 @@
l = calc_binint(s, x);
if (!(py_int = PyInt_FromLong(l)))
- return -1;
+ return -1;
PDATA_PUSH(self->stack, py_int, -1);
return 0;
@@ -3076,7 +3076,7 @@
char *s;
if (self->read_func(self, &s, 4) < 0)
- return -1;
+ return -1;
return load_binintx(self, s, 4);
}
@@ -3088,7 +3088,7 @@
char *s;
if (self->read_func(self, &s, 1) < 0)
- return -1;
+ return -1;
return load_binintx(self, s, 1);
}
@@ -3100,7 +3100,7 @@
char *s;
if (self->read_func(self, &s, 2) < 0)
- return -1;
+ return -1;
return load_binintx(self, s, 2);
}
@@ -3113,14 +3113,14 @@
int len, res = -1;
if ((len = self->readline_func(self, &s)) < 0)
- return -1;
+ return -1;
if (len < 2)
- return bad_readline();
+ return bad_readline();
if (!(s = pystrndup(s, len)))
- return -1;
+ return -1;
if (!(l = PyLong_FromString(s, &end, 0)))
- goto finally;
+ goto finally;
free(s);
PDATA_PUSH(self->stack, l, -1);
@@ -3146,30 +3146,30 @@
assert(size == 1 || size == 4);
i = self->read_func(self, &nbytes, size);
if (i < 0)
- return -1;
+ return -1;
size = calc_binint(nbytes, size);
if (size < 0) {
- /* Corrupt or hostile pickle -- we never write one like
- * this.
- */
- PyErr_SetString(UnpicklingError, "LONG pickle has negative "
- "byte count");
- return -1;
+ /* Corrupt or hostile pickle -- we never write one like
+ * this.
+ */
+ PyErr_SetString(UnpicklingError, "LONG pickle has negative "
+ "byte count");
+ return -1;
}
if (size == 0)
- along = PyLong_FromLong(0L);
+ along = PyLong_FromLong(0L);
else {
- /* Read the raw little-endian bytes & convert. */
- i = self->read_func(self, (char **) &pdata, size);
- if (i < 0)
- return -1;
- along = _PyLong_FromByteArray(pdata, (size_t) size,
- 1 /* little endian */ , 1 /* signed */ );
+ /* Read the raw little-endian bytes & convert. */
+ i = self->read_func(self, (char **) &pdata, size);
+ if (i < 0)
+ return -1;
+ along = _PyLong_FromByteArray(pdata, (size_t) size,
+ 1 /* little endian */ , 1 /* signed */ );
}
if (along == NULL)
- return -1;
+ return -1;
PDATA_PUSH(self->stack, along, -1);
return 0;
}
@@ -3183,22 +3183,22 @@
double d;
if ((len = self->readline_func(self, &s)) < 0)
- return -1;
+ return -1;
if (len < 2)
- return bad_readline();
+ return bad_readline();
if (!(s = pystrndup(s, len)))
- return -1;
+ return -1;
errno = 0;
d = PyOS_ascii_strtod(s, &endptr);
if (errno || (endptr[0] != '\n') || (endptr[1] != '\0')) {
- PyErr_SetString(PyExc_ValueError, "could not convert string to float");
- goto finally;
+ PyErr_SetString(PyExc_ValueError, "could not convert string to float");
+ goto finally;
}
if (!(py_float = PyFloat_FromDouble(d)))
- goto finally;
+ goto finally;
free(s);
PDATA_PUSH(self->stack, py_float, -1);
@@ -3218,15 +3218,15 @@
char *p;
if (self->read_func(self, &p, 8) < 0)
- return -1;
+ return -1;
x = _PyFloat_Unpack8((unsigned char *) p, 0);
if (x == -1.0 && PyErr_Occurred())
- return -1;
+ return -1;
py_float = PyFloat_FromDouble(x);
if (py_float == NULL)
- return -1;
+ return -1;
PDATA_PUSH(self->stack, py_float, -1);
return 0;
@@ -3240,35 +3240,35 @@
char *s, *p;
if ((len = self->readline_func(self, &s)) < 0)
- return -1;
+ return -1;
if (len < 2)
- return bad_readline();
+ return bad_readline();
if (!(s = pystrndup(s, len)))
- return -1;
+ return -1;
/* Strip outermost quotes */
while (s[len - 1] <= ' ')
- len--;
+ len--;
if (s[0] == '"' && s[len - 1] == '"') {
- s[len - 1] = '\0';
- p = s + 1;
- len -= 2;
+ s[len - 1] = '\0';
+ p = s + 1;
+ len -= 2;
}
else if (s[0] == '\'' && s[len - 1] == '\'') {
- s[len - 1] = '\0';
- p = s + 1;
- len -= 2;
+ s[len - 1] = '\0';
+ p = s + 1;
+ len -= 2;
}
else
- goto insecure;
- /********************************************/
+ goto insecure;
+ /********************************************/
str = PyString_DecodeEscape(p, len, NULL, 0, NULL);
free(s);
if (str) {
- PDATA_PUSH(self->stack, str, -1);
- res = 0;
+ PDATA_PUSH(self->stack, str, -1);
+ res = 0;
}
return res;
@@ -3287,15 +3287,15 @@
char *s;
if (self->read_func(self, &s, 4) < 0)
- return -1;
+ return -1;
l = calc_binint(s, 4);
if (self->read_func(self, &s, l) < 0)
- return -1;
+ return -1;
if (!(py_string = PyString_FromStringAndSize(s, l)))
- return -1;
+ return -1;
PDATA_PUSH(self->stack, py_string, -1);
return 0;
@@ -3310,15 +3310,15 @@
char *s;
if (self->read_func(self, &s, 1) < 0)
- return -1;
+ return -1;
l = (unsigned char) s[0];
if (self->read_func(self, &s, l) < 0)
- return -1;
+ return -1;
if (!(py_string = PyString_FromStringAndSize(s, l)))
- return -1;
+ return -1;
PDATA_PUSH(self->stack, py_string, -1);
return 0;
@@ -3334,12 +3334,12 @@
char *s;
if ((len = self->readline_func(self, &s)) < 0)
- return -1;
+ return -1;
if (len < 1)
- return bad_readline();
+ return bad_readline();
if (!(str = PyUnicode_DecodeRawUnicodeEscape(s, len - 1, NULL)))
- goto finally;
+ goto finally;
PDATA_PUSH(self->stack, str, -1);
return 0;
@@ -3359,15 +3359,15 @@
char *s;
if (self->read_func(self, &s, 4) < 0)
- return -1;
+ return -1;
l = calc_binint(s, 4);
if (self->read_func(self, &s, l) < 0)
- return -1;
+ return -1;
if (!(unicode = PyUnicode_DecodeUTF8(s, l, NULL)))
- return -1;
+ return -1;
PDATA_PUSH(self->stack, unicode, -1);
return 0;
@@ -3382,9 +3382,9 @@
int i;
if ((i = marker(self)) < 0)
- return -1;
+ return -1;
if (!(tup = Pdata_popTuple(self->stack, i)))
- return -1;
+ return -1;
PDATA_PUSH(self->stack, tup, -1);
return 0;
}
@@ -3395,15 +3395,15 @@
PyObject *tup = PyTuple_New(len);
if (tup == NULL)
- return -1;
+ return -1;
while (--len >= 0) {
- PyObject *element;
+ PyObject *element;
- PDATA_POP(self->stack, element);
- if (element == NULL)
- return -1;
- PyTuple_SET_ITEM(tup, len, element);
+ PDATA_POP(self->stack, element);
+ if (element == NULL)
+ return -1;
+ PyTuple_SET_ITEM(tup, len, element);
}
PDATA_PUSH(self->stack, tup, -1);
return 0;
@@ -3415,7 +3415,7 @@
PyObject *list;
if (!(list = PyList_New(0)))
- return -1;
+ return -1;
PDATA_PUSH(self->stack, list, -1);
return 0;
}
@@ -3426,7 +3426,7 @@
PyObject *dict;
if (!(dict = PyDict_New()))
- return -1;
+ return -1;
PDATA_PUSH(self->stack, dict, -1);
return 0;
}
@@ -3439,9 +3439,9 @@
int i;
if ((i = marker(self)) < 0)
- return -1;
+ return -1;
if (!(list = Pdata_popList(self->stack, i)))
- return -1;
+ return -1;
PDATA_PUSH(self->stack, list, -1);
return 0;
}
@@ -3453,19 +3453,19 @@
int i, j, k;
if ((i = marker(self)) < 0)
- return -1;
+ return -1;
j = self->stack->length;
if (!(dict = PyDict_New()))
- return -1;
+ 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;
- }
+ 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);
@@ -3478,21 +3478,21 @@
PyObject *r = 0;
if ((r = PyObject_CallObject(cls, args)))
- return r;
+ return r;
{
- PyObject *tp, *v, *tb, *tmp_value;
+ PyObject *tp, *v, *tb, *tmp_value;
- PyErr_Fetch(&tp, &v, &tb);
- tmp_value = v;
- /* NULL occurs when there was a KeyboardInterrupt */
- if (tmp_value == NULL)
- tmp_value = Py_None;
- if ((r = PyTuple_Pack(3, tmp_value, cls, args))) {
- Py_XDECREF(v);
- v = r;
- }
- PyErr_Restore(tp, v, tb);
+ PyErr_Fetch(&tp, &v, &tb);
+ tmp_value = v;
+ /* NULL occurs when there was a KeyboardInterrupt */
+ if (tmp_value == NULL)
+ tmp_value = Py_None;
+ if ((r = PyTuple_Pack(3, tmp_value, cls, args))) {
+ Py_XDECREF(v);
+ v = r;
+ }
+ PyErr_Restore(tp, v, tb);
}
return NULL;
}
@@ -3505,18 +3505,18 @@
int i;
if ((i = marker(self)) < 0)
- return -1;
+ return -1;
if (!(tup = Pdata_popTuple(self->stack, i + 1)))
- return -1;
+ return -1;
PDATA_POP(self->stack, class);
if (class) {
- obj = Instance_New(class, tup);
- Py_DECREF(class);
+ obj = Instance_New(class, tup);
+ Py_DECREF(class);
}
Py_DECREF(tup);
if (!obj)
- return -1;
+ return -1;
PDATA_PUSH(self->stack, obj, -1);
return 0;
}
@@ -3530,37 +3530,37 @@
char *s;
if ((i = marker(self)) < 0)
- return -1;
+ return -1;
if ((len = self->readline_func(self, &s)) < 0)
- return -1;
+ return -1;
if (len < 2)
- return bad_readline();
+ return bad_readline();
module_name = PyString_FromStringAndSize(s, len - 1);
if (!module_name)
- return -1;
+ 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);
- }
+ 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;
+ return -1;
if ((tup = Pdata_popTuple(self->stack, i))) {
- obj = Instance_New(class, tup);
- Py_DECREF(tup);
+ obj = Instance_New(class, tup);
+ Py_DECREF(tup);
}
Py_DECREF(class);
if (!obj)
- return -1;
+ return -1;
PDATA_PUSH(self->stack, obj, -1);
return 0;
@@ -3571,7 +3571,7 @@
{
PyObject *args = NULL;
PyObject *clsraw = NULL;
- PyTypeObject *cls; /* clsraw cast to its true type */
+ PyTypeObject *cls; /* clsraw cast to its true type */
PyObject *obj;
/* Stack is ... cls argtuple, and we want to call
@@ -3579,31 +3579,31 @@
*/
PDATA_POP(self->stack, args);
if (args == NULL)
- goto Fail;
+ goto Fail;
if (!PyTuple_Check(args)) {
- PyErr_SetString(UnpicklingError, "NEWOBJ expected an arg " "tuple.");
- goto Fail;
+ PyErr_SetString(UnpicklingError, "NEWOBJ expected an arg " "tuple.");
+ goto Fail;
}
PDATA_POP(self->stack, clsraw);
cls = (PyTypeObject *) clsraw;
if (cls == NULL)
- goto Fail;
+ goto Fail;
if (!PyType_Check(cls)) {
- PyErr_SetString(UnpicklingError, "NEWOBJ class argument "
- "isn't a type object");
- goto Fail;
+ PyErr_SetString(UnpicklingError, "NEWOBJ class argument "
+ "isn't a type object");
+ goto Fail;
}
if (cls->tp_new == NULL) {
- PyErr_SetString(UnpicklingError, "NEWOBJ class argument "
- "has NULL tp_new");
- goto Fail;
+ PyErr_SetString(UnpicklingError, "NEWOBJ class argument "
+ "has NULL tp_new");
+ goto Fail;
}
/* Call __new__. */
obj = cls->tp_new(cls, args, NULL);
if (obj == NULL)
- goto Fail;
+ goto Fail;
Py_DECREF(args);
Py_DECREF(clsraw);
@@ -3624,27 +3624,27 @@
char *s;
if ((len = self->readline_func(self, &s)) < 0)
- return -1;
+ return -1;
if (len < 2)
- return bad_readline();
+ return bad_readline();
module_name = PyString_FromStringAndSize(s, len - 1);
if (!module_name)
- return -1;
+ return -1;
if ((len = self->readline_func(self, &s)) >= 0) {
- if (len < 2) {
- Py_DECREF(module_name);
- 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);
- }
+ if (len < 2) {
+ Py_DECREF(module_name);
+ 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;
+ return -1;
PDATA_PUSH(self->stack, class, -1);
return 0;
}
@@ -3658,40 +3658,40 @@
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 ((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;
+ if (!pid)
+ return -1;
- PDATA_PUSH(self->stack, pid, -1);
- return 0;
+ 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;
+ PyErr_SetString(UnpicklingError,
+ "A load persistent id instruction was encountered,\n"
+ "but no persistent_load function was specified.");
+ return -1;
}
}
@@ -3701,34 +3701,34 @@
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_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;
+ 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;
+ PyErr_SetString(UnpicklingError,
+ "A load persistent id instruction was encountered,\n"
+ "but no persistent_load function was specified.");
+ return -1;
}
}
@@ -3739,7 +3739,7 @@
int len;
if (!((len = self->stack->length) > 0))
- return stackUnderflow();
+ 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
@@ -3748,11 +3748,11 @@
*/
if ((self->num_marks > 0) && (self->marks[self->num_marks - 1] == len))
- self->num_marks--;
+ self->num_marks--;
else {
- len--;
- Py_DECREF(self->stack->data[len]);
- self->stack->length = len;
+ len--;
+ Py_DECREF(self->stack->data[len]);
+ self->stack->length = len;
}
return 0;
@@ -3765,7 +3765,7 @@
int i;
if ((i = marker(self)) < 0)
- return -1;
+ return -1;
Pdata_clear(self->stack, i);
@@ -3780,7 +3780,7 @@
int len;
if ((len = self->stack->length) <= 0)
- return stackUnderflow();
+ return stackUnderflow();
last = self->stack->data[len - 1];
Py_INCREF(last);
PDATA_PUSH(self->stack, last, -1);
@@ -3797,21 +3797,21 @@
int rc;
if ((len = self->readline_func(self, &s)) < 0)
- return -1;
+ return -1;
if (len < 2)
- return bad_readline();
+ return bad_readline();
if (!(py_str = PyString_FromStringAndSize(s, len - 1)))
- return -1;
+ return -1;
value = PyDict_GetItem(self->memo, py_str);
if (!value) {
- PyErr_SetObject(BadPickleGet, py_str);
- rc = -1;
+ PyErr_SetObject(BadPickleGet, py_str);
+ rc = -1;
}
else {
- PDATA_APPEND(self->stack, value, -1);
- rc = 0;
+ PDATA_APPEND(self->stack, value, -1);
+ rc = 0;
}
Py_DECREF(py_str);
@@ -3828,20 +3828,20 @@
int rc;
if (self->read_func(self, &s, 1) < 0)
- return -1;
+ return -1;
key = (unsigned char) s[0];
if (!(py_key = PyInt_FromLong((long) key)))
- return -1;
+ return -1;
value = PyDict_GetItem(self->memo, py_key);
if (!value) {
- PyErr_SetObject(BadPickleGet, py_key);
- rc = -1;
+ PyErr_SetObject(BadPickleGet, py_key);
+ rc = -1;
}
else {
- PDATA_APPEND(self->stack, value, -1);
- rc = 0;
+ PDATA_APPEND(self->stack, value, -1);
+ rc = 0;
}
Py_DECREF(py_key);
@@ -3859,7 +3859,7 @@
int rc;
if (self->read_func(self, &s, 4) < 0)
- return -1;
+ return -1;
c = (unsigned char) s[0];
key = (long) c;
@@ -3871,16 +3871,16 @@
key |= (long) c << 24;
if (!(py_key = PyInt_FromLong((long) key)))
- return -1;
+ return -1;
value = PyDict_GetItem(self->memo, py_key);
if (!value) {
- PyErr_SetObject(BadPickleGet, py_key);
- rc = -1;
+ PyErr_SetObject(BadPickleGet, py_key);
+ rc = -1;
}
else {
- PDATA_APPEND(self->stack, value, -1);
- rc = 0;
+ PDATA_APPEND(self->stack, value, -1);
+ rc = 0;
}
Py_DECREF(py_key);
@@ -3893,66 +3893,66 @@
static int
load_extension(Unpicklerobject * self, int nbytes)
{
- char *codebytes; /* the nbytes bytes after the opcode */
- long code; /* calc_binint returns long */
- PyObject *py_code; /* code as a Python int */
- PyObject *obj; /* the object to push */
- PyObject *pair; /* (module_name, class_name) */
+ char *codebytes; /* the nbytes bytes after the opcode */
+ long code; /* calc_binint returns long */
+ PyObject *py_code; /* code as a Python int */
+ PyObject *obj; /* the object to push */
+ PyObject *pair; /* (module_name, class_name) */
PyObject *module_name, *class_name;
assert(nbytes == 1 || nbytes == 2 || nbytes == 4);
if (self->read_func(self, &codebytes, nbytes) < 0)
- return -1;
+ return -1;
code = calc_binint(codebytes, nbytes);
- if (code <= 0) { /* note that 0 is forbidden */
- /* Corrupt or hostile pickle. */
- PyErr_SetString(UnpicklingError, "EXT specifies code <= 0");
- return -1;
+ if (code <= 0) { /* note that 0 is forbidden */
+ /* Corrupt or hostile pickle. */
+ PyErr_SetString(UnpicklingError, "EXT specifies code <= 0");
+ return -1;
}
/* Look for the code in the cache. */
py_code = PyInt_FromLong(code);
if (py_code == NULL)
- return -1;
+ return -1;
obj = PyDict_GetItem(extension_cache, py_code);
if (obj != NULL) {
- /* Bingo. */
- Py_DECREF(py_code);
- PDATA_APPEND(self->stack, obj, -1);
- return 0;
+ /* Bingo. */
+ Py_DECREF(py_code);
+ PDATA_APPEND(self->stack, obj, -1);
+ return 0;
}
/* Look up the (module_name, class_name) pair. */
pair = PyDict_GetItem(inverted_registry, py_code);
if (pair == NULL) {
- Py_DECREF(py_code);
- PyErr_Format(PyExc_ValueError, "unregistered extension "
- "code %ld", code);
- return -1;
+ Py_DECREF(py_code);
+ PyErr_Format(PyExc_ValueError, "unregistered extension "
+ "code %ld", code);
+ return -1;
}
/* Since the extension registry is manipulable via Python code,
* confirm that pair is really a 2-tuple of strings.
*/
if (!PyTuple_Check(pair) || PyTuple_Size(pair) != 2 ||
- !PyString_Check(module_name = PyTuple_GET_ITEM(pair, 0)) ||
- !PyString_Check(class_name = PyTuple_GET_ITEM(pair, 1))) {
- Py_DECREF(py_code);
- PyErr_Format(PyExc_ValueError, "_inverted_registry[%ld] "
- "isn't a 2-tuple of strings", code);
- return -1;
+ !PyString_Check(module_name = PyTuple_GET_ITEM(pair, 0)) ||
+ !PyString_Check(class_name = PyTuple_GET_ITEM(pair, 1))) {
+ Py_DECREF(py_code);
+ PyErr_Format(PyExc_ValueError, "_inverted_registry[%ld] "
+ "isn't a 2-tuple of strings", code);
+ return -1;
}
/* Load the object. */
obj = find_class(module_name, class_name, self->find_class);
if (obj == NULL) {
- Py_DECREF(py_code);
- return -1;
+ Py_DECREF(py_code);
+ return -1;
}
/* Cache code -> obj. */
code = PyDict_SetItem(extension_cache, py_code, obj);
Py_DECREF(py_code);
if (code < 0) {
- Py_DECREF(obj);
- return -1;
+ Py_DECREF(obj);
+ return -1;
}
PDATA_PUSH(self->stack, obj, -1);
return 0;
@@ -3966,13 +3966,13 @@
char *s;
if ((l = self->readline_func(self, &s)) < 0)
- return -1;
+ return -1;
if (l < 2)
- return bad_readline();
+ return bad_readline();
if (!(len = self->stack->length))
- return stackUnderflow();
+ return stackUnderflow();
if (!(py_str = PyString_FromStringAndSize(s, l - 1)))
- return -1;
+ return -1;
value = self->stack->data[len - 1];
l = PyDict_SetItem(self->memo, py_str, value);
Py_DECREF(py_str);
@@ -3989,14 +3989,14 @@
int len;
if (self->read_func(self, &s, 1) < 0)
- return -1;
+ return -1;
if (!((len = self->stack->length) > 0))
- return stackUnderflow();
+ return stackUnderflow();
key = (unsigned char) s[0];
if (!(py_key = PyInt_FromLong((long) key)))
- return -1;
+ return -1;
value = self->stack->data[len - 1];
len = PyDict_SetItem(self->memo, py_key, value);
Py_DECREF(py_key);
@@ -4014,9 +4014,9 @@
int len;
if (self->read_func(self, &s, 4) < 0)
- return -1;
+ return -1;
if (!(len = self->stack->length))
- return stackUnderflow();
+ return stackUnderflow();
c = (unsigned char) s[0];
key = (long) c;
@@ -4028,7 +4028,7 @@
key |= (long) c << 24;
if (!(py_key = PyInt_FromLong(key)))
- return -1;
+ return -1;
value = self->stack->data[len - 1];
len = PyDict_SetItem(self->memo, py_key, value);
Py_DECREF(py_key);
@@ -4044,50 +4044,50 @@
len = self->stack->length;
if (!(len >= x && x > 0))
- return stackUnderflow();
+ return stackUnderflow();
/* nothing to do */
if (len == x)
- return 0;
+ return 0;
list = self->stack->data[x - 1];
if (PyList_Check(list)) {
- PyObject *slice;
- int list_len;
+ PyObject *slice;
+ int list_len;
- slice = Pdata_popList(self->stack, x);
- if (!slice)
- return -1;
- list_len = PyList_GET_SIZE(list);
- i = PyList_SetSlice(list, list_len, list_len, slice);
- Py_DECREF(slice);
- return i;
+ slice = Pdata_popList(self->stack, x);
+ if (!slice)
+ return -1;
+ 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;
+ if (!(append_method = PyObject_GetAttr(list, append_str)))
+ return -1;
- for (i = x; i < len; i++) {
- PyObject *junk;
+ 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);
+ 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;
@@ -4115,17 +4115,17 @@
int len, i, r = 0;
if (!((len = self->stack->length) >= x && x > 0))
- return stackUnderflow();
+ return stackUnderflow();
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;
- }
+ 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);
@@ -4160,77 +4160,77 @@
* the stack top, possibly mutated via instance.__setstate__(state).
*/
if (self->stack->length < 2)
- return stackUnderflow();
+ return stackUnderflow();
PDATA_POP(self->stack, state);
if (state == NULL)
- return -1;
+ return -1;
inst = self->stack->data[self->stack->length - 1];
__setstate__ = PyObject_GetAttr(inst, __setstate___str);
if (__setstate__ != NULL) {
- PyObject *junk = NULL;
+ PyObject *junk = NULL;
- /* The explicit __setstate__ is responsible for everything. */
- ARG_TUP(self, state);
- if (self->arg) {
- junk = PyObject_Call(__setstate__, self->arg, NULL);
- FREE_ARG_TUP(self);
- }
- Py_DECREF(__setstate__);
- if (junk == NULL)
- return -1;
- Py_DECREF(junk);
- return 0;
+ /* The explicit __setstate__ is responsible for everything. */
+ ARG_TUP(self, state);
+ if (self->arg) {
+ junk = PyObject_Call(__setstate__, self->arg, NULL);
+ FREE_ARG_TUP(self);
+ }
+ Py_DECREF(__setstate__);
+ if (junk == NULL)
+ return -1;
+ Py_DECREF(junk);
+ return 0;
}
if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return -1;
+ return -1;
PyErr_Clear();
/* A default __setstate__. First see whether state embeds a
* slot state dict too (a proto 2 addition).
*/
if (PyTuple_Check(state) && PyTuple_Size(state) == 2) {
- PyObject *temp = state;
- state = PyTuple_GET_ITEM(temp, 0);
- slotstate = PyTuple_GET_ITEM(temp, 1);
- Py_INCREF(state);
- Py_INCREF(slotstate);
- Py_DECREF(temp);
+ PyObject *temp = state;
+ state = PyTuple_GET_ITEM(temp, 0);
+ slotstate = PyTuple_GET_ITEM(temp, 1);
+ Py_INCREF(state);
+ Py_INCREF(slotstate);
+ Py_DECREF(temp);
}
else
- slotstate = NULL;
+ slotstate = NULL;
/* Set inst.__dict__ from the state dict (if any). */
if (state != Py_None) {
- PyObject *dict;
- if (!PyDict_Check(state)) {
- PyErr_SetString(UnpicklingError, "state is not a " "dictionary");
- goto finally;
- }
- dict = PyObject_GetAttr(inst, __dict___str);
- if (dict == NULL)
- goto finally;
-
- i = 0;
- while (PyDict_Next(state, &i, &d_key, &d_value)) {
- if (PyObject_SetItem(dict, d_key, d_value) < 0)
- goto finally;
- }
- Py_DECREF(dict);
+ PyObject *dict;
+ if (!PyDict_Check(state)) {
+ PyErr_SetString(UnpicklingError, "state is not a " "dictionary");
+ goto finally;
+ }
+ dict = PyObject_GetAttr(inst, __dict___str);
+ if (dict == NULL)
+ goto finally;
+
+ i = 0;
+ while (PyDict_Next(state, &i, &d_key, &d_value)) {
+ if (PyObject_SetItem(dict, d_key, d_value) < 0)
+ goto finally;
+ }
+ Py_DECREF(dict);
}
/* Also set instance attributes from the slotstate dict (if any). */
if (slotstate != NULL) {
- if (!PyDict_Check(slotstate)) {
- PyErr_SetString(UnpicklingError, "slot state is not "
- "a dictionary");
- goto finally;
- }
- i = 0;
- while (PyDict_Next(slotstate, &i, &d_key, &d_value)) {
- if (PyObject_SetAttr(inst, d_key, d_value) < 0)
- goto finally;
- }
+ if (!PyDict_Check(slotstate)) {
+ PyErr_SetString(UnpicklingError, "slot state is not "
+ "a dictionary");
+ goto finally;
+ }
+ i = 0;
+ while (PyDict_Next(slotstate, &i, &d_key, &d_value)) {
+ if (PyObject_SetAttr(inst, d_key, d_value) < 0)
+ goto finally;
+ }
}
res = 0;
@@ -4252,20 +4252,20 @@
*/
if ((self->num_marks + 1) >= self->marks_size) {
- int *marks;
- s = self->marks_size + 20;
- if (s <= self->num_marks)
- s = self->num_marks + 1;
- if (self->marks == NULL)
- marks = (int *) malloc(s * sizeof(int));
- else
- marks = (int *) realloc(self->marks, s * sizeof(int));
- if (!marks) {
- PyErr_NoMemory();
- return -1;
- }
- self->marks = marks;
- self->marks_size = s;
+ int *marks;
+ s = self->marks_size + 20;
+ if (s <= self->num_marks)
+ s = self->num_marks + 1;
+ if (self->marks == NULL)
+ marks = (int *) malloc(s * sizeof(int));
+ else
+ marks = (int *) realloc(self->marks, s * sizeof(int));
+ if (!marks) {
+ PyErr_NoMemory();
+ return -1;
+ }
+ self->marks = marks;
+ self->marks_size = s;
}
self->marks[self->num_marks++] = self->stack->length;
@@ -4280,16 +4280,16 @@
PDATA_POP(self->stack, arg_tup);
if (!arg_tup)
- return -1;
+ return -1;
PDATA_POP(self->stack, callable);
if (callable) {
- ob = Instance_New(callable, arg_tup);
- Py_DECREF(callable);
+ ob = Instance_New(callable, arg_tup);
+ Py_DECREF(callable);
}
Py_DECREF(arg_tup);
if (!ob)
- return -1;
+ return -1;
PDATA_PUSH(self->stack, ob, -1);
return 0;
@@ -4306,7 +4306,7 @@
i = self->read_func(self, &protobyte, 1);
if (i < 0)
- return -1;
+ return -1;
i = calc_binint(protobyte, 1);
/* No point checking for < 0, since calc_binint returns an unsigned
@@ -4314,7 +4314,7 @@
*/
assert(i >= 0);
if (i <= HIGHEST_PROTOCOL)
- return 0;
+ return 0;
PyErr_Format(PyExc_ValueError, "unsupported pickle protocol: %d", i);
return -1;
@@ -4328,296 +4328,296 @@
self->num_marks = 0;
if (self->stack->length)
- Pdata_clear(self->stack, 0);
+ Pdata_clear(self->stack, 0);
while (1) {
- if (self->read_func(self, &s, 1) < 0)
- break;
+ 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 LONG1:
- if (load_counted_long(self, 1) < 0)
- break;
- continue;
-
- case LONG4:
- if (load_counted_long(self, 4) < 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;
+ 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 LONG1:
+ if (load_counted_long(self, 1) < 0)
+ break;
+ continue;
+
+ case LONG4:
+ if (load_counted_long(self, 4) < 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_counted_tuple(self, 0) < 0)
- break;
- continue;
-
- case TUPLE1:
- if (load_counted_tuple(self, 1) < 0)
- break;
- continue;
-
- case TUPLE2:
- if (load_counted_tuple(self, 2) < 0)
- break;
- continue;
-
- case TUPLE3:
- if (load_counted_tuple(self, 3) < 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 NEWOBJ:
- if (load_newobj(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 EXT1:
- if (load_extension(self, 1) < 0)
- break;
- continue;
-
- case EXT2:
- if (load_extension(self, 2) < 0)
- break;
- continue;
-
- case EXT4:
- if (load_extension(self, 4) < 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 PROTO:
- if (load_proto(self) < 0)
- break;
- continue;
-
- case NEWTRUE:
- if (load_bool(self, Py_True) < 0)
- break;
- continue;
-
- case NEWFALSE:
- if (load_bool(self, Py_False) < 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;
- }
+ case EMPTY_TUPLE:
+ if (load_counted_tuple(self, 0) < 0)
+ break;
+ continue;
+
+ case TUPLE1:
+ if (load_counted_tuple(self, 1) < 0)
+ break;
+ continue;
+
+ case TUPLE2:
+ if (load_counted_tuple(self, 2) < 0)
+ break;
+ continue;
+
+ case TUPLE3:
+ if (load_counted_tuple(self, 3) < 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 NEWOBJ:
+ if (load_newobj(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 EXT1:
+ if (load_extension(self, 1) < 0)
+ break;
+ continue;
+
+ case EXT2:
+ if (load_extension(self, 2) < 0)
+ break;
+ continue;
+
+ case EXT4:
+ if (load_extension(self, 4) < 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 PROTO:
+ if (load_proto(self) < 0)
+ break;
+ continue;
+
+ case NEWTRUE:
+ if (load_bool(self, Py_True) < 0)
+ break;
+ continue;
+
+ case NEWFALSE:
+ if (load_bool(self, Py_False) < 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;
+ break;
}
if ((err = PyErr_Occurred())) {
- if (err == PyExc_EOFError) {
- PyErr_SetNone(PyExc_EOFError);
- }
- return NULL;
+ if (err == PyExc_EOFError) {
+ PyErr_SetNone(PyExc_EOFError);
+ }
+ return NULL;
}
PDATA_POP(self->stack, val);
@@ -4634,7 +4634,7 @@
int i;
if ((i = marker(self)) < 0)
- return -1;
+ return -1;
return Pdata_clear(self->stack, i + 1);
}
@@ -4646,12 +4646,12 @@
char *s;
if ((i = marker(self)) < 0)
- return -1;
+ return -1;
Pdata_clear(self->stack, i);
if (self->readline_func(self, &s) < 0)
- return -1;
+ return -1;
if (self->readline_func(self, &s) < 0)
- return -1;
+ return -1;
PDATA_APPEND(self->stack, Py_None, -1);
return 0;
}
@@ -4661,14 +4661,14 @@
{
PyObject *obj;
- PDATA_POP(self->stack, obj); /* pop argtuple */
+ PDATA_POP(self->stack, obj); /* pop argtuple */
if (obj == NULL)
- return -1;
+ return -1;
Py_DECREF(obj);
- PDATA_POP(self->stack, obj); /* pop cls */
+ PDATA_POP(self->stack, obj); /* pop cls */
if (obj == NULL)
- return -1;
+ return -1;
Py_DECREF(obj);
PDATA_APPEND(self->stack, Py_None, -1);
@@ -4681,9 +4681,9 @@
char *s;
if (self->readline_func(self, &s) < 0)
- return -1;
+ return -1;
if (self->readline_func(self, &s) < 0)
- return -1;
+ return -1;
PDATA_APPEND(self->stack, Py_None, -1);
return 0;
}
@@ -4693,7 +4693,7 @@
{
if (self->stack->length < 2)
- return stackUnderflow();
+ return stackUnderflow();
Pdata_clear(self->stack, self->stack->length - 2);
PDATA_APPEND(self->stack, Py_None, -1);
return 0;
@@ -4704,7 +4704,7 @@
{
if (self->stack->length < 1)
- return stackUnderflow();
+ return stackUnderflow();
Pdata_clear(self->stack, self->stack->length - 1);
return 0;
}
@@ -4716,7 +4716,7 @@
assert(nbytes == 1 || nbytes == 2 || nbytes == 4);
if (self->read_func(self, &codebytes, nbytes) < 0)
- return -1;
+ return -1;
PDATA_APPEND(self->stack, Py_None, -1);
return 0;
}
@@ -4732,288 +4732,288 @@
Pdata_clear(self->stack, 0);
while (1) {
- if (self->read_func(self, &s, 1) < 0)
- break;
+ 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 LONG1:
- if (load_counted_long(self, 1) < 0)
- break;
- continue;
-
- case LONG4:
- if (load_counted_long(self, 4) < 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;
+ 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 LONG1:
+ if (load_counted_long(self, 1) < 0)
+ break;
+ continue;
+
+ case LONG4:
+ if (load_counted_long(self, 4) < 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_counted_tuple(self, 0) < 0)
- break;
- continue;
-
- case TUPLE1:
- if (load_counted_tuple(self, 1) < 0)
- break;
- continue;
-
- case TUPLE2:
- if (load_counted_tuple(self, 2) < 0)
- break;
- continue;
-
- case TUPLE3:
- if (load_counted_tuple(self, 3) < 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 NEWOBJ:
- if (noload_newobj(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 EXT1:
- if (noload_extension(self, 1) < 0)
- break;
- continue;
-
- case EXT2:
- if (noload_extension(self, 2) < 0)
- break;
- continue;
-
- case EXT4:
- if (noload_extension(self, 4) < 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;
-
- case PROTO:
- if (load_proto(self) < 0)
- break;
- continue;
-
- case NEWTRUE:
- if (load_bool(self, Py_True) < 0)
- break;
- continue;
-
- case NEWFALSE:
- if (load_bool(self, Py_False) < 0)
- break;
- continue;
- default:
- cPickle_ErrFormat(UnpicklingError,
- "invalid load key, '%s'.", "c", s[0]);
- return NULL;
- }
+ case EMPTY_TUPLE:
+ if (load_counted_tuple(self, 0) < 0)
+ break;
+ continue;
+
+ case TUPLE1:
+ if (load_counted_tuple(self, 1) < 0)
+ break;
+ continue;
+
+ case TUPLE2:
+ if (load_counted_tuple(self, 2) < 0)
+ break;
+ continue;
+
+ case TUPLE3:
+ if (load_counted_tuple(self, 3) < 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 NEWOBJ:
+ if (noload_newobj(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 EXT1:
+ if (noload_extension(self, 1) < 0)
+ break;
+ continue;
+
+ case EXT2:
+ if (noload_extension(self, 2) < 0)
+ break;
+ continue;
+
+ case EXT4:
+ if (noload_extension(self, 4) < 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;
+
+ case PROTO:
+ if (load_proto(self) < 0)
+ break;
+ continue;
+
+ case NEWTRUE:
+ if (load_bool(self, Py_True) < 0)
+ break;
+ continue;
+
+ case NEWFALSE:
+ if (load_bool(self, Py_False) < 0)
+ break;
+ continue;
+ default:
+ cPickle_ErrFormat(UnpicklingError,
+ "invalid load key, '%s'.", "c", s[0]);
+ return NULL;
+ }
- break;
+ break;
}
if ((err = PyErr_Occurred())) {
- if (err == PyExc_EOFError) {
- PyErr_SetNone(PyExc_EOFError);
- }
- return NULL;
+ if (err == PyExc_EOFError) {
+ PyErr_SetNone(PyExc_EOFError);
+ }
+ return NULL;
}
PDATA_POP(self->stack, val);
@@ -5047,7 +5047,7 @@
"persistent references without instantiating any objects or importing\n"
"any modules.\n")
},
- {NULL, NULL} /* sentinel */
+ {NULL, NULL} /* sentinel */
};
@@ -5057,7 +5057,7 @@
Unpicklerobject *self;
if (!(self = PyObject_GC_New(Unpicklerobject, &Unpicklertype)))
- return NULL;
+ return NULL;
self->file = NULL;
self->arg = NULL;
@@ -5073,43 +5073,43 @@
self->find_class = NULL;
if (!(self->memo = PyDict_New()))
- goto err;
+ goto err;
if (!self->stack)
- goto err;
+ 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;
+ 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;
+ 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;
- }
+ 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;
+ }
}
PyObject_GC_Track(self);
@@ -5143,11 +5143,11 @@
Py_XDECREF(self->find_class);
if (self->marks) {
- free(self->marks);
+ free(self->marks);
}
if (self->buf_size) {
- free(self->buf);
+ free(self->buf);
}
self->ob_type->tp_free((PyObject *) self);
@@ -5187,38 +5187,38 @@
Unpickler_getattr(Unpicklerobject * self, char *name)
{
if (!strcmp(name, "persistent_load")) {
- if (!self->pers_func) {
- PyErr_SetString(PyExc_AttributeError, name);
- return NULL;
- }
+ if (!self->pers_func) {
+ PyErr_SetString(PyExc_AttributeError, name);
+ return NULL;
+ }
- Py_INCREF(self->pers_func);
- return self->pers_func;
+ 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 (!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 (!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;
+ Py_INCREF(UnpicklingError);
+ return UnpicklingError;
}
return Py_FindMethod(Unpickler_methods, (PyObject *) self, name);
@@ -5230,34 +5230,34 @@
{
if (!strcmp(name, "persistent_load")) {
- Py_XDECREF(self->pers_func);
- self->pers_func = value;
- Py_XINCREF(value);
- return 0;
+ 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;
+ 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;
+ 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;
+ 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);
@@ -5278,14 +5278,14 @@
int proto = 0;
if (!(PyArg_ParseTupleAndKeywords(args, kwds, "OO|i", kwlist,
- &ob, &file, &proto)))
- goto finally;
+ &ob, &file, &proto)))
+ goto finally;
if (!(pickler = newPicklerobject(file, proto)))
- goto finally;
+ goto finally;
if (dump(pickler, ob) < 0)
- goto finally;
+ goto finally;
Py_INCREF(Py_None);
res = Py_None;
@@ -5307,17 +5307,17 @@
int proto = 0;
if (!(PyArg_ParseTupleAndKeywords(args, kwds, "O|i:dumps", kwlist,
- &ob, &proto)))
- goto finally;
+ &ob, &proto)))
+ goto finally;
if (!(file = PycStringIO->NewOutput(128)))
- goto finally;
+ goto finally;
if (!(pickler = newPicklerobject(file, proto)))
- goto finally;
+ goto finally;
if (dump(pickler, ob) < 0)
- goto finally;
+ goto finally;
res = PycStringIO->cgetvalue(file);
@@ -5337,7 +5337,7 @@
PyObject *res = NULL;
if (!(unpickler = newUnpicklerobject(ob)))
- goto finally;
+ goto finally;
res = load(unpickler);
@@ -5356,13 +5356,13 @@
Unpicklerobject *unpickler = 0;
if (!(PyArg_ParseTuple(args, "S:loads", &ob)))
- goto finally;
+ goto finally;
if (!(file = PycStringIO->NewInput(ob)))
- goto finally;
+ goto finally;
if (!(unpickler = newUnpicklerobject(file)))
- goto finally;
+ goto finally;
res = load(unpickler);
@@ -5378,44 +5378,44 @@
static PyTypeObject Unpicklertype = {
PyObject_HEAD_INIT(NULL)
- 0, /*ob_size */
- "cPickle.Unpickler", /*tp_name */
- sizeof(Unpicklerobject), /*tp_basicsize */
+ 0, /*ob_size */
+ "cPickle.Unpickler", /*tp_name */
+ sizeof(Unpicklerobject), /*tp_basicsize */
0,
- (destructor) Unpickler_dealloc, /* tp_dealloc */
- 0, /* tp_print */
- (getattrfunc) Unpickler_getattr, /* tp_getattr */
- (setattrfunc) Unpickler_setattr, /* tp_setattr */
- 0, /* tp_compare */
- 0, /* tp_repr */
- 0, /* tp_as_number */
- 0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- 0, /* tp_hash */
- 0, /* tp_call */
- 0, /* tp_str */
- 0, /* tp_getattro */
- 0, /* tp_setattro */
- 0, /* tp_as_buffer */
+ (destructor) Unpickler_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ (getattrfunc) Unpickler_getattr, /* tp_getattr */
+ (setattrfunc) Unpickler_setattr, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
- Unpicklertype__doc__, /* tp_doc */
- (traverseproc) Unpickler_traverse, /* tp_traverse */
- (inquiry) Unpickler_clear, /* tp_clear */
+ Unpicklertype__doc__, /* tp_doc */
+ (traverseproc) Unpickler_traverse, /* tp_traverse */
+ (inquiry) Unpickler_clear, /* tp_clear */
};
static struct PyMethodDef cPickle_methods[] = {
{"dump", (PyCFunction) cpm_dump, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("dump(obj, file, protocol=0) -- "
- "Write an object in pickle format to the given file.\n"
- "\n"
- "See the Pickler docstring for the meaning of optional argument proto.")
+ "Write an object in pickle format to the given file.\n"
+ "\n"
+ "See the Pickler docstring for the meaning of optional argument proto.")
},
{"dumps", (PyCFunction) cpm_dumps, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("dumps(obj, protocol=0) -- "
- "Return a string containing an object in pickle format.\n"
- "\n"
- "See the Pickler docstring for the meaning of optional argument proto.")
+ "Return a string containing an object in pickle format.\n"
+ "\n"
+ "See the Pickler docstring for the meaning of optional argument proto.")
},
{"load", (PyCFunction) cpm_load, METH_O,
@@ -5426,27 +5426,27 @@
{"Pickler", (PyCFunction) get_Pickler, METH_VARARGS | METH_KEYWORDS,
PyDoc_STR("Pickler(file, protocol=0) -- Create a pickler.\n"
- "\n"
- "This takes a file-like object for writing a pickle data stream.\n"
- "The optional proto argument tells the pickler to use the given\n"
- "protocol; supported protocols are 0, 1, 2. The default\n"
- "protocol is 0, to be backwards compatible. (Protocol 0 is the\n"
- "only protocol that can be written to a file opened in text\n"
- "mode and read back successfully. When using a protocol higher\n"
- "than 0, make sure the file is opened in binary mode, both when\n"
- "pickling and unpickling.)\n"
- "\n"
- "Protocol 1 is more efficient than protocol 0; protocol 2 is\n"
- "more efficient than protocol 1.\n"
- "\n"
- "Specifying a negative protocol version selects the highest\n"
- "protocol version supported. The higher the protocol used, the\n"
- "more recent the version of Python needed to read the pickle\n"
- "produced.\n"
- "\n"
- "The file parameter must have a write() method that accepts a single\n"
- "string argument. It can thus be an open file object, a StringIO\n"
- "object, or any other custom object that meets this interface.\n")
+ "\n"
+ "This takes a file-like object for writing a pickle data stream.\n"
+ "The optional proto argument tells the pickler to use the given\n"
+ "protocol; supported protocols are 0, 1, 2. The default\n"
+ "protocol is 0, to be backwards compatible. (Protocol 0 is the\n"
+ "only protocol that can be written to a file opened in text\n"
+ "mode and read back successfully. When using a protocol higher\n"
+ "than 0, make sure the file is opened in binary mode, both when\n"
+ "pickling and unpickling.)\n"
+ "\n"
+ "Protocol 1 is more efficient than protocol 0; protocol 2 is\n"
+ "more efficient than protocol 1.\n"
+ "\n"
+ "Specifying a negative protocol version selects the highest\n"
+ "protocol version supported. The higher the protocol used, the\n"
+ "more recent the version of Python needed to read the pickle\n"
+ "produced.\n"
+ "\n"
+ "The file parameter must have a write() method that accepts a single\n"
+ "string argument. It can thus be an open file object, a StringIO\n"
+ "object, or any other custom object that meets this interface.\n")
},
{"Unpickler", (PyCFunction) get_Unpickler, METH_O,
@@ -5463,9 +5463,9 @@
#define INIT_STR(S) if (!( S ## _str=PyString_InternFromString(#S))) return -1;
if (PyType_Ready(&Unpicklertype) < 0)
- return -1;
+ return -1;
if (PyType_Ready(&Picklertype) < 0)
- return -1;
+ return -1;
INIT_STR(__class__);
INIT_STR(__getinitargs__);
@@ -5484,35 +5484,35 @@
INIT_STR(dispatch_table);
if (!(copy_reg = PyImport_ImportModule("copy_reg")))
- return -1;
+ return -1;
/* This is special because we want to use a different
* one in restricted mode. */
dispatch_table = PyObject_GetAttr(copy_reg, dispatch_table_str);
if (!dispatch_table)
- return -1;
+ return -1;
extension_registry = PyObject_GetAttrString(copy_reg,
- "_extension_registry");
+ "_extension_registry");
if (!extension_registry)
- return -1;
+ return -1;
inverted_registry = PyObject_GetAttrString(copy_reg, "_inverted_registry");
if (!inverted_registry)
- return -1;
+ return -1;
extension_cache = PyObject_GetAttrString(copy_reg, "_extension_cache");
if (!extension_cache)
- return -1;
+ return -1;
Py_DECREF(copy_reg);
if (!(empty_tuple = PyTuple_New(0)))
- return -1;
+ return -1;
two_tuple = PyTuple_New(2);
if (two_tuple == NULL)
- return -1;
+ return -1;
/* We use this temp container with no regard to refcounts, or to
* keeping containees alive. Exempt from GC, because we don't
* want anything looking at two_tuple() by magic.
@@ -5521,77 +5521,77 @@
/* Ugh */
if (!(t = PyImport_ImportModule("__builtin__")))
- return -1;
+ return -1;
if (PyDict_SetItemString(module_dict, "__builtins__", t) < 0)
- return -1;
+ return -1;
if (!(t = PyDict_New()))
- return -1;
+ return -1;
if (!(r = PyRun_String("def __str__(self):\n"
- " return self.args and ('%s' % self.args[0]) or '(what)'\n",
- Py_file_input, module_dict, t)))
- return -1;
+ " 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;
+ return -1;
Py_DECREF(t);
PicklingError = PyErr_NewException("cPickle.PicklingError",
- PickleError, NULL);
+ PickleError, NULL);
if (!PicklingError)
- return -1;
+ return -1;
if (!(t = PyDict_New()))
- return -1;
+ return -1;
if (!(r = PyRun_String("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;
+ " 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;
+ (UnpickleableError =
+ PyErr_NewException("cPickle.UnpickleableError", PicklingError, t)))
+ return -1;
Py_DECREF(t);
if (!(UnpicklingError = PyErr_NewException("cPickle.UnpicklingError",
- PickleError, NULL)))
- return -1;
+ PickleError, NULL)))
+ return -1;
if (!(BadPickleGet = PyErr_NewException("cPickle.BadPickleGet",
- UnpicklingError, NULL)))
- return -1;
+ UnpicklingError, NULL)))
+ return -1;
if (PyDict_SetItemString(module_dict, "PickleError", PickleError) < 0)
- return -1;
+ return -1;
if (PyDict_SetItemString(module_dict, "PicklingError", PicklingError) < 0)
- return -1;
+ return -1;
if (PyDict_SetItemString(module_dict, "UnpicklingError",
- UnpicklingError) < 0)
- return -1;
+ UnpicklingError) < 0)
+ return -1;
if (PyDict_SetItemString(module_dict, "UnpickleableError",
- UnpickleableError) < 0)
- return -1;
+ UnpickleableError) < 0)
+ return -1;
if (PyDict_SetItemString(module_dict, "BadPickleGet", BadPickleGet) < 0)
- return -1;
+ return -1;
PycString_IMPORT;
return 0;
}
-#ifndef PyMODINIT_FUNC /* declarations for DLL import/export */
+#ifndef PyMODINIT_FUNC /* declarations for DLL import/export */
#define PyMODINIT_FUNC void
#endif
PyMODINIT_FUNC
@@ -5599,7 +5599,7 @@
{
PyObject *m, *d, *di, *v, *k;
Py_ssize_t i;
- char *rev = "1.71"; /* XXX when does this change? */
+ char *rev = "1.71"; /* XXX when does this change? */
PyObject *format_version;
PyObject *compatible_formats;
@@ -5612,16 +5612,16 @@
*/
di = PyDict_New();
if (!di)
- return;
+ return;
if (init_stuff(di) < 0)
- return;
+ return;
/* Create the module and add the functions */
m = Py_InitModule4("cPickle", cPickle_methods,
- cPickle_module_documentation,
- (PyObject *) NULL, PYTHON_API_VERSION);
+ cPickle_module_documentation,
+ (PyObject *) NULL, PYTHON_API_VERSION);
if (m == NULL)
- return;
+ return;
/* Add some symbolic constants to the module */
d = PyModule_GetDict(m);
@@ -5631,26 +5631,26 @@
/* 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;
- }
+ if (PyObject_SetItem(d, k, v) < 0) {
+ Py_DECREF(di);
+ return;
+ }
}
Py_DECREF(di);
i = PyModule_AddIntConstant(m, "HIGHEST_PROTOCOL", HIGHEST_PROTOCOL);
if (i < 0)
- return;
+ return;
/* These are purely informational; no code uses them. */
/* File format version we write. */
format_version = PyString_FromString("2.0");
/* Format versions we can read. */
- compatible_formats = Py_BuildValue("[sssss]", "1.0", /* Original protocol 0 */
- "1.1", /* Protocol 0 + INST */
- "1.2", /* Original protocol 1 */
- "1.3", /* Protocol 1 + BINFLOAT */
- "2.0"); /* Original protocol 2 */
+ compatible_formats = Py_BuildValue("[sssss]", "1.0", /* Original protocol 0 */
+ "1.1", /* Protocol 0 + INST */
+ "1.2", /* Original protocol 1 */
+ "1.3", /* Protocol 1 + BINFLOAT */
+ "2.0"); /* Original protocol 2 */
PyDict_SetItemString(d, "format_version", format_version);
PyDict_SetItemString(d, "compatible_formats", compatible_formats);
Py_XDECREF(format_version);
More information about the Python-checkins
mailing list