cpython/Modules/cPickle.c

3901 lines
84 KiB
C
Raw Normal View History

1997-01-06 18:59:08 -04:00
/*
$Id$
Copyright
Copyright 1996 Digital Creations, L.C., 910 Princess Anne
Street, Suite 300, Fredericksburg, Virginia 22401 U.S.A. All
rights reserved. Copyright in this software is owned by DCLC,
unless otherwise indicated. Permission to use, copy and
distribute this software is hereby granted, provided that the
above copyright notice appear in all copies and that both that
copyright notice and this permission notice appear. Note that
any product, process or technology described in this software
may be the subject of other Intellectual Property rights
reserved by Digital Creations, L.C. and are not licensed
hereunder.
Trademarks
Digital Creations & DCLC, are trademarks of Digital Creations, L.C..
All other trademarks are owned by their respective companies.
No Warranty
The software is provided "as is" without warranty of any kind,
either express or implied, including, but not limited to, the
implied warranties of merchantability, fitness for a particular
purpose, or non-infringement. This software could include
technical inaccuracies or typographical errors. Changes are
periodically made to the software; these changes will be
incorporated in new editions of the software. DCLC may make
improvements and/or changes in this software at any time
without notice.
Limitation Of Liability
In no event will DCLC be liable for direct, indirect, special,
incidental, economic, cover, or consequential damages arising
out of the use of or inability to use this software even if
advised of the possibility of such damages. Some states do not
allow the exclusion or limitation of implied warranties or
limitation of liability for incidental or consequential
damages, so the above limitation or exclusion may not apply to
you.
If you have questions regarding this software,
contact:
Jim Fulton, jim@digicool.com
Digital Creations L.C.
(540) 371-6909
*/
static char cPickle_module_documentation[] =
""
;
#include "Python.h"
#include "cStringIO.h"
1997-04-09 14:36:32 -03:00
#include "mymath.h"
1997-01-06 18:59:08 -04:00
#include <errno.h>
1997-04-09 14:36:32 -03:00
#define UNLESS(E) if (!(E))
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
#define DEL_LIST_SLICE(list, from, to) (PyList_SetSlice(list, from, to, NULL))
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
#define WRITE_BUF_SIZE 256
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
#define MARK '('
#define STOP '.'
#define POP '0'
#define POP_MARK '1'
#define DUP '2'
#define FLOAT 'F'
#ifdef FORMAT_1_3
#define BINFLOAT 'G'
#endif
#define INT 'I'
#define BININT 'J'
#define BININT1 'K'
#define LONG 'L'
#define BININT2 'M'
#define NONE 'N'
#define PERSID 'P'
#define BINPERSID 'Q'
#define REDUCE 'R'
#define STRING 'S'
#define BINSTRING 'T'
#define SHORT_BINSTRING 'U'
#define APPEND 'a'
#define BUILD 'b'
#define GLOBAL 'c'
#define DICT 'd'
#define EMPTY_DICT '}'
#define APPENDS 'e'
#define GET 'g'
#define BINGET 'h'
#define INST 'i'
#define LONG_BINGET 'j'
#define LIST 'l'
#define EMPTY_LIST ']'
#define OBJ 'o'
#define PUT 'p'
#define BINPUT 'q'
#define LONG_BINPUT 'r'
#define SETITEM 's'
#define TUPLE 't'
#define EMPTY_TUPLE ')'
#define SETITEMS 'u'
static char MARKv = MARK;
1997-01-06 18:59:08 -04:00
/* atol function from string module */
static PyObject *atol_func;
static PyObject *PicklingError;
static PyObject *UnpicklingError;
1997-04-09 14:36:32 -03:00
static PyObject *dispatch_table;
static PyObject *safe_constructors;
1997-01-06 18:59:08 -04:00
static PyObject *class_map;
1997-04-09 14:36:32 -03:00
static PyObject *empty_tuple;
static PyObject *__class___str, *__getinitargs___str, *__dict___str,
*__getstate___str, *__setstate___str, *__name___str, *__reduce___str,
*write_str, *__safe_for_unpickling___str, *append_str,
*read_str, *readline_str;
/* __builtins__ module */
static PyObject *builtins;
static int save();
static int put2();
typedef struct {
PyObject_HEAD
FILE *fp;
PyObject *write;
PyObject *file;
PyObject *memo;
PyObject *arg;
PyObject *pers_func;
PyObject *inst_pers_func;
int bin;
int (*write_func)();
char *write_buf;
int buf_size;
} Picklerobject;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static PyTypeObject Picklertype;
typedef struct {
PyObject_HEAD
FILE *fp;
PyObject *file;
PyObject *readline;
PyObject *read;
PyObject *memo;
PyObject *arg;
PyObject *stack;
PyObject *mark;
PyObject *pers_func;
PyObject *last_string;
int *marks;
int num_marks;
int marks_size;
int (*read_func)();
int (*readline_func)();
int buf_size;
char *buf;
} Unpicklerobject;
static PyTypeObject Unpicklertype;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
int
cPickle_PyMapping_HasKey(o, key)
PyObject *o;
PyObject *key;
1997-01-06 18:59:08 -04:00
{
1997-04-09 14:36:32 -03:00
PyObject *v;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (v = PyObject_GetItem(o,key))
{
Py_DECREF(v);
return 1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
PyErr_Clear();
return 0;
}
1997-01-06 18:59:08 -04:00
#define PyErr_Format PyErr_JFFormat
static
1997-04-09 14:36:32 -03:00
PyObject *
#ifdef HAVE_STDARG_PROTOTYPES
/* VARARGS 2 */
PyErr_Format(PyObject *ErrType, char *stringformat, char *format, ...)
#else
/* VARARGS */
PyErr_Format(va_alist) va_dcl
#endif
1997-01-06 18:59:08 -04:00
{
1997-04-09 14:36:32 -03:00
va_list va;
PyObject *args=0, *retval=0;
#ifdef HAVE_STDARG_PROTOTYPES
va_start(va, format);
#else
PyObject *ErrType;
char *stringformat, *format;
va_start(va);
ErrType = va_arg(va, PyObject *);
stringformat = va_arg(va, char *);
format = va_arg(va, char *);
#endif
if(format) args = Py_VaBuildValue(format, va);
va_end(va);
if(format && ! args) return NULL;
if(stringformat && !(retval=PyString_FromString(stringformat))) return NULL;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if(retval)
{
if(args)
{
PyObject *v;
v=PyString_Format(retval, args);
Py_DECREF(retval);
Py_DECREF(args);
if(! v) return NULL;
retval=v;
}
}
else
if(args) retval=args;
else
{
PyErr_SetObject(ErrType,Py_None);
return NULL;
}
PyErr_SetObject(ErrType,retval);
Py_DECREF(retval);
return NULL;
}
1997-01-06 18:59:08 -04:00
static int
1997-04-09 14:36:32 -03:00
write_file(Picklerobject *self, char *s, int n) {
if (s == NULL) {
return 0;
}
if ((int)fwrite(s, sizeof(char), n, self->fp) != n) {
PyErr_SetFromErrno(PyExc_IOError);
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return n;
1997-01-06 18:59:08 -04:00
}
static int
1997-04-09 14:36:32 -03:00
write_cStringIO(Picklerobject *self, char *s, int n) {
if (s == NULL) {
return 0;
}
if (PycStringIO->cwrite((PyObject *)self->file, s, n) != n) {
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return n;
1997-01-06 18:59:08 -04:00
}
static int
1997-04-09 14:36:32 -03:00
write_other(Picklerobject *self, char *s, int n) {
PyObject *py_str = 0, *junk = 0;
int res = -1;
if (s == NULL) {
UNLESS(self->buf_size) return 0;
UNLESS(py_str =
PyString_FromStringAndSize(self->write_buf, self->buf_size))
goto finally;
}
else {
if (self->buf_size && (n + self->buf_size) > WRITE_BUF_SIZE) {
if (write_other(self, NULL, 0) < 0)
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (n > WRITE_BUF_SIZE) {
UNLESS(py_str =
PyString_FromStringAndSize(s, n))
goto finally;
}
else {
memcpy(self->write_buf + self->buf_size, s, n);
self->buf_size += n;
res = n;
goto finally;
}
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
UNLESS(self->arg)
UNLESS(self->arg = PyTuple_New(1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(py_str);
if (PyTuple_SetItem(self->arg, 0, py_str) < 0)
goto finally;
UNLESS(junk = PyObject_CallObject(self->write, self->arg))
goto finally;
Py_DECREF(junk);
self->buf_size = 0;
res = n;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(py_str);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
static int
1997-04-09 14:36:32 -03:00
read_file(Unpicklerobject *self, char **s, int n) {
if (self->buf_size == 0) {
int size;
size = ((n < 32) ? 32 : n);
UNLESS(self->buf = (char *)malloc(size * sizeof(char))) {
PyErr_NoMemory();
return -1;
}
self->buf_size = size;
}
else if (n > self->buf_size) {
UNLESS(self->buf = (char *)realloc(self->buf, n * sizeof(char))) {
PyErr_NoMemory();
return -1;
}
self->buf_size = n;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if ((int)fread(self->buf, sizeof(char), n, self->fp) != n) {
if (feof(self->fp)) {
PyErr_SetNone(PyExc_EOFError);
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
PyErr_SetFromErrno(PyExc_IOError);
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
*s = self->buf;
return n;
1997-01-06 18:59:08 -04:00
}
static int
1997-04-09 14:36:32 -03:00
readline_file(Unpicklerobject *self, char **s) {
int i;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (self->buf_size == 0) {
UNLESS(self->buf = (char *)malloc(40 * sizeof(char))) {
PyErr_NoMemory();
return -1;
}
self->buf_size = 40;
}
i = 0;
while (1) {
for (; i < (self->buf_size - 1); i++) {
if (feof(self->fp) || (self->buf[i] = getc(self->fp)) == '\n') {
self->buf[i + 1] = '\0';
*s = self->buf;
return i + 1;
}
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(self->buf = (char *)realloc(self->buf,
(self->buf_size * 2) * sizeof(char))) {
PyErr_NoMemory();
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
self->buf_size *= 2;
1997-01-06 18:59:08 -04:00
}
}
static int
1997-04-09 14:36:32 -03:00
read_cStringIO(Unpicklerobject *self, char **s, int n) {
char *ptr;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PycStringIO->cread((PyObject *)self->file, &ptr, n) != n) {
PyErr_SetNone(PyExc_EOFError);
return -1;
}
*s = ptr;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return n;
1997-01-06 18:59:08 -04:00
}
static int
1997-04-09 14:36:32 -03:00
readline_cStringIO(Unpicklerobject *self, char **s) {
int n;
char *ptr;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((n = PycStringIO->creadline((PyObject *)self->file, &ptr)) < 0) {
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
*s = ptr;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return n;
1997-01-06 18:59:08 -04:00
}
static int
1997-04-09 14:36:32 -03:00
read_other(Unpicklerobject *self, char **s, int n) {
PyObject *bytes, *str;
int res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(bytes = PyInt_FromLong(n)) {
if (!PyErr_Occurred())
PyErr_SetNone(PyExc_EOFError);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
goto finally;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
UNLESS(self->arg)
UNLESS(self->arg = PyTuple_New(1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(bytes);
if (PyTuple_SetItem(self->arg, 0, bytes) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(str = PyObject_CallObject(self->read, self->arg))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_XDECREF(self->last_string);
self->last_string = str;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
*s = PyString_AsString(str);
res = n;
finally:
Py_XDECREF(bytes);
return res;
1997-01-06 18:59:08 -04:00
}
static int
1997-04-09 14:36:32 -03:00
readline_other(Unpicklerobject *self, char **s) {
PyObject *str;
int str_size;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(str = PyObject_CallObject(self->readline, empty_tuple)) {
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
str_size = PyString_Size(str);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_XDECREF(self->last_string);
self->last_string = str;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
*s = PyString_AsString(str);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return str_size;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static char *
strndup(char *s, int l)
{
char *r;
UNLESS(r=malloc((l+1)*sizeof(char))) return (char*)PyErr_NoMemory();
memcpy(r,s,l);
r[l]=0;
return r;
1997-01-06 18:59:08 -04:00
}
static int
1997-04-09 14:36:32 -03:00
get(Picklerobject *self, PyObject *id) {
PyObject *value = 0;
long c_value;
char s[30];
int len;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(value = PyDict_GetItem(self->memo, id))
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(value = PyTuple_GetItem(value, 0))
return -1;
c_value = PyInt_AsLong(value);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (!self->bin) {
s[0] = GET;
sprintf(s + 1, "%ld\n", c_value);
len = strlen(s);
}
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;
}
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, s, len) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return 0;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
put(Picklerobject *self, PyObject *ob) {
if (ob->ob_refcnt < 2)
return 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return put2(self, ob);
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
put2(Picklerobject *self, PyObject *ob) {
char c_str[30];
int p, len, res = -1;
PyObject *py_ob_id = 0, *memo_len = 0, *t = 0;
if ((p = PyDict_Size(self->memo)) < 0)
goto finally;
if (!self->bin) {
c_str[0] = PUT;
sprintf(c_str + 1, "%d\n", p);
len = strlen(c_str);
}
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;
}
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, c_str, len) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(py_ob_id = PyInt_FromLong((long)ob))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(memo_len = PyInt_FromLong(p))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(t = PyTuple_New(2))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
PyTuple_SET_ITEM(t, 0, memo_len);
Py_INCREF(memo_len);
PyTuple_SET_ITEM(t, 1, ob);
Py_INCREF(ob);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyDict_SetItem(self->memo, py_ob_id, t) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(py_ob_id);
Py_XDECREF(memo_len);
Py_XDECREF(t);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
static PyObject *
1997-04-09 14:36:32 -03:00
whichmodule(PyObject *global, PyObject *global_name) {
int i, j;
PyObject *module = 0, *modules_dict = 0,
*global_name_attr = 0, *name = 0;
if (module = PyDict_GetItem(class_map, global)) {
Py_INCREF(module);
return module;
}
else {
PyErr_Clear();
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(modules_dict = PySys_GetObject("modules"))
return NULL;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
i = 0;
while (j = PyDict_Next(modules_dict, &i, &name, &module)) {
UNLESS(global_name_attr = PyObject_GetAttr(module, global_name)) {
PyErr_Clear();
continue;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (global_name_attr != global) {
Py_DECREF(global_name_attr);
continue;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_DECREF(global_name_attr);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
break;
}
if (!j) {
PyErr_Format(PicklingError, "Could not find module for %s.",
"O", global_name);
return NULL;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
PyDict_SetItem(class_map, global, name);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(name);
return name;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
save_none(Picklerobject *self, PyObject *args) {
static char none = NONE;
if ((*self->write_func)(self, &none, 1) < 0)
return -1;
return 0;
}
static int
save_int(Picklerobject *self, PyObject *args) {
char c_str[32];
long l = PyInt_AS_LONG((PyIntObject *)args);
int len = 0;
if (!self->bin
#if SIZEOF_LONG > 4
|| (l >> 32)
#endif
) {
1997-04-09 14:36:32 -03:00
/* Save extra-long ints in non-binary mode, so that
we can use python long parsing code to restore,
if necessary. */
c_str[0] = INT;
sprintf(c_str + 1, "%ld\n", l);
if ((*self->write_func)(self, c_str, strlen(c_str)) < 0)
return -1;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
else {
c_str[1] = (int)( l & 0xff);
c_str[2] = (int)((l >> 8) & 0xff);
c_str[3] = (int)((l >> 16) & 0xff);
c_str[4] = (int)((l >> 24) & 0xff);
if ((c_str[4] == 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;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, c_str, len) < 0)
return -1;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
return 0;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
save_long(Picklerobject *self, PyObject *args) {
int size, res = -1;
PyObject *repr = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static char l = LONG;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(repr = PyObject_Repr(args))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((size = PyString_Size(repr)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, &l, 1) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self,
PyString_AS_STRING((PyStringObject *)repr), size) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, "\n", 1) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(repr);
return res;
}
static int
save_float(Picklerobject *self, PyObject *args) {
double x = PyFloat_AS_DOUBLE((PyFloatObject *)args);
#ifdef FORMAT_1_3
if (self->bin) {
int s, e, i = -1;
double f;
long fhi, flo;
char str[9], *p = str;
*p = BINFLOAT;
p++;
if (x < 0) {
s = 1;
x = -x;
1997-01-06 18:59:08 -04:00
}
else
1997-04-09 14:36:32 -03:00
s = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
f = frexp(x, &e);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Normalize f to be in the range [1.0, 2.0) */
if (0.5 <= f && f < 1.0) {
f *= 2.0;
e--;
}
else if (f == 0.0) {
e = 0;
}
else {
PyErr_SetString(PyExc_SystemError,
"frexp() result out of range");
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (e >= 1024) {
/* XXX 1024 itself is reserved for Inf/NaN */
PyErr_SetString(PyExc_OverflowError,
"float too large to pack with d format");
return -1;
}
else if (e < -1022) {
/* Gradual underflow */
f = ldexp(f, 1022 + e);
e = 0;
}
else {
e += 1023;
f -= 1.0; /* Get rid of leading 1 */
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* fhi receives the high 28 bits; flo the low 24 bits (== 52 bits) */
f *= 268435456.0; /* 2**28 */
fhi = (long) floor(f); /* Truncate */
f -= (double)fhi;
f *= 16777216.0; /* 2**24 */
flo = (long) floor(f + 0.5); /* Round */
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* First byte */
*p = (s<<7) | (e>>4);
p++;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Second byte */
*p = ((e&0xF)<<4) | (fhi>>24);
p++;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Third byte */
*p = (fhi>>16) & 0xFF;
p++;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Fourth byte */
*p = (fhi>>8) & 0xFF;
p++;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Fifth byte */
*p = fhi & 0xFF;
p++;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Sixth byte */
*p = (flo>>16) & 0xFF;
p++;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Seventh byte */
*p = (flo>>8) & 0xFF;
p++;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Eighth byte */
*p = flo & 0xFF;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, str, 9) < 0)
return -1;
}
else
#endif
{
char c_str[250];
c_str[0] = FLOAT;
sprintf(c_str + 1, "%f\n", x);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, c_str, strlen(c_str)) < 0)
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return 0;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
save_string(Picklerobject *self, PyObject *args) {
int size, len;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
size = PyString_Size(args);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (!self->bin) {
PyObject *repr;
char *repr_str;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static char string = STRING;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(repr = PyObject_Repr(args))
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
repr_str = PyString_AS_STRING((PyStringObject *)repr);
len = PyString_Size(repr);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, &string, 1) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, repr_str, len) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, "\n", 1) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_XDECREF(repr);
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
else {
int i;
char c_str[5];
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
size = PyString_Size(args);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (size < 256) {
c_str[0] = SHORT_BINSTRING;
c_str[1] = size;
len = 2;
}
else {
c_str[0] = BINSTRING;
for (i = 1; i < 5; i++)
c_str[i] = (int)(size >> ((i - 1) * 8));
len = 5;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, c_str, len) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self,
PyString_AS_STRING((PyStringObject *)args), size) < 0)
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (size > 1)
if (put(self, args) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return 0;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
save_tuple(Picklerobject *self, PyObject *args) {
PyObject *element = 0, *py_tuple_id = 0;
int len, i, has_key, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static char tuple = TUPLE;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, &MARKv, 1) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyTuple_Size(args)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
for (i = 0; i < len; i++) {
UNLESS(element = PyTuple_GET_ITEM((PyTupleObject *)args, i))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (save(self, element, 0) < 0)
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(py_tuple_id = PyInt_FromLong((long)args))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (len) {
if (has_key = cPickle_PyMapping_HasKey(self->memo, py_tuple_id) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (has_key) {
if (self->bin) {
static char pop_mark = POP_MARK;
if ((*self->write_func)(self, &pop_mark, 1) < 0)
goto finally;
}
else {
static char pop = POP;
for (i = 0; i <= len; i++) {
if ((*self->write_func)(self, &pop, 1) < 0)
goto finally;
}
}
if (get(self, py_tuple_id) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
goto finally;
}
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, &tuple, 1) < 0) {
goto finally;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if (put(self, args) < 0)
goto finally;
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(py_tuple_id);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
save_empty_tuple(Picklerobject *self, PyObject *args) {
static char tuple = EMPTY_TUPLE;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return (*self->write_func)(self, &tuple, 1);
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
save_list(Picklerobject *self, PyObject *args) {
PyObject *element = 0;
int s_len, len, i, using_appends, res = -1;
char s[3];
static char append = APPEND, appends = APPENDS;
if(self->bin) {
s[0] = EMPTY_LIST;
s_len = 1;
}
else {
s[0] = MARK;
s[1] = LIST;
s_len = 2;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyList_Size(args)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, s, s_len) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (len == 0)
1997-01-06 18:59:08 -04:00
{
1997-04-09 14:36:32 -03:00
if (put(self, args) < 0)
goto finally;
}
else
{
if (put2(self, args) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if (using_appends = (self->bin && (len > 1)))
if ((*self->write_func)(self, &MARKv, 1) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
for (i = 0; i < len; i++) {
UNLESS(element = PyList_GET_ITEM((PyListObject *)args, i))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (save(self, element, 0) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (!using_appends) {
if ((*self->write_func)(self, &append, 1) < 0)
goto finally;
}
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (using_appends) {
if ((*self->write_func)(self, &appends, 1) < 0)
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
save_dict(Picklerobject *self, PyObject *args) {
PyObject *key = 0, *value = 0;
int i, len, res = -1, using_setitems;
char s[3];
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static char setitem = SETITEM, setitems = SETITEMS;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (self->bin) {
s[0] = EMPTY_DICT;
len = 1;
}
else {
s[0] = MARK;
s[1] = DICT;
len = 2;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, s, len) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyDict_Size(args)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (len == 0)
1997-01-06 18:59:08 -04:00
{
1997-04-09 14:36:32 -03:00
if (put(self, args) < 0)
goto finally;
}
else
{
if (put2(self, args) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if (using_setitems = (self->bin && (PyDict_Size(args) > 1)))
if ((*self->write_func)(self, &MARKv, 1) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
i = 0;
while (PyDict_Next(args, &i, &key, &value)) {
if (save(self, key, 0) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (save(self, value, 0) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (!using_setitems) {
if ((*self->write_func)(self, &setitem, 1) < 0)
goto finally;
}
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (using_setitems) {
if ((*self->write_func)(self, &setitems, 1) < 0)
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
save_inst(Picklerobject *self, PyObject *args) {
PyObject *class = 0, *module = 0, *name = 0, *state = 0,
*getinitargs_func = 0, *getstate_func = 0, *class_args = 0;
char *module_str, *name_str;
int module_size, name_size, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static char inst = INST, obj = OBJ, build = BUILD;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, &MARKv, 1) < 0)
goto finally;
UNLESS(class = PyObject_GetAttr(args, __class___str))
goto finally;
if (self->bin) {
if (save(self, class, 0) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if (getinitargs_func = PyObject_GetAttr(args, __getinitargs___str)) {
PyObject *element = 0;
int i, len;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(class_args =
PyObject_CallObject(getinitargs_func, empty_tuple))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyObject_Length(class_args)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
for (i = 0; i < len; i++) {
UNLESS(element = PySequence_GetItem(class_args, i))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (save(self, element, 0) < 0) {
Py_DECREF(element);
goto finally;
}
Py_DECREF(element);
}
}
else {
PyErr_Clear();
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if (!self->bin) {
UNLESS(name = ((PyClassObject *)class)->cl_name) {
PyErr_SetString(PicklingError, "class has no name");
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(module = whichmodule(class, name))
goto finally;
module_str = PyString_AS_STRING((PyStringObject *)module);
module_size = PyString_Size(module);
name_str = PyString_AS_STRING((PyStringObject *)name);
name_size = PyString_Size(name);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, &inst, 1) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, module_str, module_size) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, "\n", 1) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, name_str, name_size) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, "\n", 1) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
else if ((*self->write_func)(self, &obj, 1) < 0) {
goto finally;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if (getstate_func = PyObject_GetAttr(args, __getstate___str)) {
UNLESS(state = PyObject_CallObject(getstate_func, empty_tuple))
goto finally;
}
else {
PyErr_Clear();
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(state = PyObject_GetAttr(args, __dict___str)) {
PyErr_Clear();
res = 0;
goto finally;
}
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (!PyDict_Check(state)) {
if (put2(self, args) < 0)
goto finally;
}
else {
if (put(self, args) < 0)
goto finally;
}
if (save(self, state, 0) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, &build, 1) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(module);
Py_XDECREF(class);
Py_XDECREF(state);
Py_XDECREF(getinitargs_func);
Py_XDECREF(getstate_func);
Py_XDECREF(class_args);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
save_global(Picklerobject *self, PyObject *args, PyObject *name) {
PyObject *global_name = 0, *module = 0;
char *name_str, *module_str;
int module_size, name_size, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static char global = GLOBAL;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (name)
{
global_name = name;
Py_INCREF(global_name);
}
else
{
UNLESS(global_name = PyObject_GetAttr(args, __name___str))
goto finally;
}
UNLESS(module = whichmodule(args, global_name))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
module_str = PyString_AS_STRING((PyStringObject *)module);
module_size = PyString_Size(module);
name_str = PyString_AS_STRING((PyStringObject *)global_name);
name_size = PyString_Size(global_name);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, &global, 1) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, module_str, module_size) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, "\n", 1) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, name_str, name_size) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, "\n", 1) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (put(self, args) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(module);
Py_XDECREF(global_name);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
save_pers(Picklerobject *self, PyObject *args, PyObject *f) {
PyObject *pid = 0;
int size, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static char persid = PERSID, binpersid = BINPERSID;
1997-01-06 18:59:08 -04:00
UNLESS(self->arg)
1997-04-09 14:36:32 -03:00
UNLESS(self->arg = PyTuple_New(1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(args);
if (PyTuple_SetItem(self->arg, 0, args) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(pid = PyObject_CallObject(f, self->arg))
goto finally;
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;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(pid);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
save_reduce(Picklerobject *self, PyObject *callable,
PyObject *tup, PyObject *state, PyObject *ob) {
static char reduce = REDUCE, build = BUILD;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (save(self, callable, 0) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (save(self, tup, 0) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, &reduce, 1) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (ob != NULL)
{
if (state && !PyDict_Check(state)) {
if (put2(self, ob) < 0)
return -1;
}
else {
if (put(self, ob) < 0)
return -1;
}
}
if (state)
{
if (save(self, state, 0) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, &build, 1) < 0)
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return 0;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
save(Picklerobject *self, PyObject *args, int pers_save) {
PyTypeObject *type;
PyObject *py_ob_id = 0, *__reduce__ = 0, *t = 0, *arg_tup = 0,
*callable = 0, *state = 0, *junk = 0;
int res = -1, tmp, size;
if (!pers_save && self->pers_func) {
if ((tmp = save_pers(self, args, self->pers_func)) != 0) {
res = tmp;
goto finally;
}
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (args == Py_None) {
res = save_none(self, args);
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
type = args->ob_type;
switch (type->tp_name[0]) {
case 'i':
if (type == &PyInt_Type) {
res = save_int(self, args);
goto finally;
}
break;
case 'l':
if (type == &PyLong_Type) {
res = save_long(self, args);
goto finally;
}
break;
case 'f':
if (type == &PyFloat_Type) {
res = save_float(self, args);
goto finally;
}
break;
case 't':
if (type == &PyTuple_Type && PyTuple_Size(args)==0) {
if(self->bin) res = save_empty_tuple(self, args);
else res = save_tuple(self, args);
goto finally;
}
case 's':
if ((type == &PyString_Type) && (PyString_Size(args) < 2)) {
res = save_string(self, args);
goto finally;
}
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if (args->ob_refcnt > 1) {
long ob_id;
int has_key;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
ob_id = (long)args;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(py_ob_id = PyInt_FromLong(ob_id))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((has_key = cPickle_PyMapping_HasKey(self->memo, py_ob_id)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (has_key) {
if (get(self, py_ob_id) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
goto finally;
}
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
switch (type->tp_name[0]) {
case 's':
if (type == &PyString_Type) {
res = save_string(self, args);
goto finally;
}
case 't':
if (type == &PyTuple_Type) {
res = save_tuple(self, args);
goto finally;
}
case 'l':
if (type == &PyList_Type) {
res = save_list(self, args);
goto finally;
}
case 'd':
if (type == &PyDict_Type) {
res = save_dict(self, args);
goto finally;
}
case 'i':
if (type == &PyInstance_Type) {
res = save_inst(self, args);
goto finally;
}
case 'c':
if (type == &PyClass_Type) {
res = save_global(self, args, NULL);
goto finally;
}
case 'f':
if (type == &PyFunction_Type) {
res = save_global(self, args, NULL);
goto finally;
}
case 'b':
if (type == &PyCFunction_Type) {
res = save_global(self, args, NULL);
goto finally;
}
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if (!pers_save && self->inst_pers_func) {
if ((tmp = save_pers(self, args, self->inst_pers_func)) != 0) {
res = tmp;
goto finally;
}
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (__reduce__ = PyDict_GetItem(dispatch_table, (PyObject *)type)) {
Py_INCREF(__reduce__);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(self->arg)
UNLESS(self->arg = PyTuple_New(1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(args);
if (PyTuple_SetItem(self->arg, 0, args) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(t = PyObject_CallObject(__reduce__, self->arg))
goto finally;
}
else {
PyErr_Clear();
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (__reduce__ = PyObject_GetAttr(args, __reduce___str)) {
UNLESS(t = PyObject_CallObject(__reduce__, empty_tuple))
goto finally;
}
else {
PyErr_Clear();
}
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (t) {
if (PyString_Check(t)) {
res = save_global(self, args, t);
goto finally;
}
if (!PyTuple_Check(t)) {
PyErr_Format(PicklingError, "Value returned by %s must "
"be a tuple", "O", __reduce__);
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
size = PyTuple_Size(t);
if ((size != 3) && (size != 2)) {
PyErr_Format(PicklingError, "tuple returned by %s must "
"contain only two or three elements", "O", __reduce__);
goto finally;
}
callable = PyTuple_GET_ITEM(t, 0);
arg_tup = PyTuple_GET_ITEM(t, 1);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (size > 2) {
state = PyTuple_GET_ITEM(t, 2);
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(PyTuple_Check(arg_tup)) {
PyErr_Format(PicklingError, "Second element of tuple "
"returned by %s must be a tuple", "O", __reduce__);
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = save_reduce(self, callable, arg_tup, state, args);
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/*
if (PyObject_HasAttrString(args, "__class__")) {
res = save_inst(self, args);
goto finally;
}
*/
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
PyErr_Format(PicklingError, "Cannot pickle %s objects.",
"O", (PyObject *)type);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(py_ob_id);
Py_XDECREF(__reduce__);
Py_XDECREF(t);
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
dump(Picklerobject *self, PyObject *args) {
static char stop = STOP;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (save(self, args, 0) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, &stop, 1) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->write_func)(self, NULL, 0) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return 0;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static PyObject *
Pickler_dump(Picklerobject *self, PyObject *args) {
PyObject *ob;
UNLESS(PyArg_ParseTuple(args, "O", &ob))
return NULL;
if (dump(self, ob) < 0)
return NULL;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(Py_None);
return Py_None;
1997-01-06 18:59:08 -04:00
}
static PyObject *
1997-04-09 14:36:32 -03:00
dump_special(Picklerobject *self, PyObject *args) {
static char stop = STOP;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
PyObject *callable, *arg_tup, *state = NULL;
UNLESS(PyArg_ParseTuple(args, "OO|O", &callable, &arg_tup, &state))
return NULL;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(PyTuple_Check(arg_tup)) {
PyErr_SetString(PicklingError, "Second arg to dump_special must "
"be tuple");
return NULL;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (save_reduce(self, callable, arg_tup, state, NULL) < 0)
return NULL;
if ((*self->write_func)(self, &stop, 1) < 0)
return NULL;
if ((*self->write_func)(self, NULL, 0) < 0)
return NULL;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(Py_None);
return Py_None;
1997-01-06 18:59:08 -04:00
}
static struct PyMethodDef Pickler_methods[] = {
1997-04-09 14:36:32 -03:00
{"dump", (PyCFunction)Pickler_dump, 1, ""},
{"dump_special", (PyCFunction)dump_special, 1, ""},
{NULL, NULL} /* sentinel */
1997-01-06 18:59:08 -04:00
};
static Picklerobject *
1997-04-09 14:36:32 -03:00
newPicklerobject(PyObject *file, int bin) {
Picklerobject *self;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(self = PyObject_NEW(Picklerobject, &Picklertype))
return NULL;
1997-01-06 18:59:08 -04:00
self->fp = NULL;
self->write = NULL;
1997-04-09 14:36:32 -03:00
self->memo = NULL;
self->arg = NULL;
self->pers_func = NULL;
self->inst_pers_func = NULL;
self->write_buf = NULL;
self->bin = bin;
self->buf_size = 0;
Py_INCREF(file);
self->file = file;
UNLESS(self->memo = PyDict_New()) {
Py_XDECREF((PyObject *)self);
return NULL;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyFile_Check(file)) {
self->fp = PyFile_AsFile(file);
self->write_func = write_file;
}
else if (PycStringIO_OutputCheck(file)) {
self->write_func = write_cStringIO;
}
else {
self->write_func = write_other;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(self->write = PyObject_GetAttr(file, write_str))
{
PyErr_Clear();
PyErr_SetString(PyExc_TypeError, "argument must have 'write' "
"attribute");
Py_XDECREF((PyObject *)self);
return NULL;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(self->write_buf =
(char *)malloc(WRITE_BUF_SIZE * sizeof(char))) {
PyErr_NoMemory();
Py_XDECREF((PyObject *)self);
return NULL;
}
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return self;
1997-01-06 18:59:08 -04:00
}
static PyObject *
1997-04-09 14:36:32 -03:00
get_Pickler(PyObject *self, PyObject *args) {
PyObject *file;
int bin = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(PyArg_ParseTuple(args, "O|i", &file, &bin)) return NULL;
return (PyObject *)newPicklerobject(file, bin);
1997-01-06 18:59:08 -04:00
}
static void
1997-04-09 14:36:32 -03:00
Pickler_dealloc(Picklerobject *self) {
Py_XDECREF(self->write);
Py_XDECREF(self->memo);
Py_XDECREF(self->arg);
Py_XDECREF(self->file);
Py_XDECREF(self->pers_func);
Py_XDECREF(self->inst_pers_func);
if (self->write_buf) {
free(self->write_buf);
}
PyMem_DEL(self);
1997-01-06 18:59:08 -04:00
}
static PyObject *
1997-04-09 14:36:32 -03:00
Pickler_getattr(Picklerobject *self, char *name) {
if (strcmp(name, "persistent_id") == 0) {
if (!self->pers_func) {
PyErr_SetString(PyExc_AttributeError, name);
return NULL;
}
Py_INCREF(self->pers_func);
return self->pers_func;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if (strcmp(name, "memo") == 0) {
if (!self->memo) {
PyErr_SetString(PyExc_AttributeError, name);
return NULL;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(self->memo);
return self->memo;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if (strcmp(name, "PicklingError") == 0) {
Py_INCREF(PicklingError);
return PicklingError;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return Py_FindMethod(Pickler_methods, (PyObject *)self, name);
1997-01-06 18:59:08 -04:00
}
int
1997-04-09 14:36:32 -03:00
Pickler_setattr(Picklerobject *self, char *name, PyObject *value) {
if (strcmp(name, "persistent_id") == 0) {
Py_XDECREF(self->pers_func);
self->pers_func = value;
Py_INCREF(value);
return 0;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (strcmp(name, "inst_persistent_id") == 0) {
Py_XDECREF(self->inst_pers_func);
self->inst_pers_func = value;
Py_INCREF(value);
return 0;
}
PyErr_SetString(PyExc_AttributeError, name);
return -1;
1997-01-06 18:59:08 -04:00
}
static char Picklertype__doc__[] = "";
1997-04-09 14:36:32 -03:00
static PyTypeObject Picklertype_value() {
PyTypeObject Picklertype = {
PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"Pickler", /*tp_name*/
sizeof(Picklerobject), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)Pickler_dealloc, /*tp_dealloc*/
(printfunc)0, /*tp_print*/
(getattrfunc)Pickler_getattr, /*tp_getattr*/
(setattrfunc)Pickler_setattr, /*tp_setattr*/
(cmpfunc)0, /*tp_compare*/
(reprfunc)0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
(hashfunc)0, /*tp_hash*/
(ternaryfunc)0, /*tp_call*/
(reprfunc)0, /*tp_str*/
/* Space for future expansion */
0L,0L,0L,0L,
Picklertype__doc__ /* Documentation string */
};
return Picklertype;
}
PyObject *
PyImport_ImportModuleNi(char *module_name)
{
char *import_str;
int size, i;
PyObject *import;
static PyObject *eval_dict = 0;
size = strlen(module_name);
for (i = 0; i < size; i++) {
if (((module_name[i] < 'A') || (module_name[i] > 'z')) &&
(module_name[i] != '_')) {
PyErr_SetString(PyExc_ImportError, "module name contains "
"invalid characters.");
return NULL;
}
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(import_str =
(char *)malloc((strlen(module_name) + 15) * sizeof(char))) {
PyErr_NoMemory();
return NULL;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
sprintf(import_str, "__import__('%s')", module_name);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(eval_dict)
UNLESS(eval_dict = Py_BuildValue("{sO}", "__builtins__", builtins))
return NULL;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (!(import =
PyRun_String(import_str, Py_eval_input, eval_dict, eval_dict))) {
1997-04-09 14:36:32 -03:00
free(import_str);
return NULL;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
free(import_str);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return import;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static PyObject *
find_class(PyObject *py_module_name, PyObject *py_class_name) {
PyObject *import = 0, *class = 0, *t = 0;
char *module_name, *class_name;
PyObject *res = NULL;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static PyObject *eval_dict = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
module_name = PyString_AS_STRING((PyStringObject *)py_module_name);
class_name = PyString_AS_STRING((PyStringObject *)py_class_name);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(t = PyTuple_New(2))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
PyTuple_SET_ITEM((PyTupleObject *)t, 0, py_module_name);
Py_INCREF(py_module_name);
PyTuple_SET_ITEM((PyTupleObject *)t, 1, py_class_name);
Py_INCREF(py_class_name);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (class = PyDict_GetItem(class_map, t)) {
res = class;
Py_INCREF(class);
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
PyErr_Clear();
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (!(import = PyImport_ImportModuleNi(module_name)) ||
!(class = PyObject_GetAttr(import, py_class_name))) {
PyErr_Format(PyExc_SystemError, "Failed to import global %s "
"from module %s", "ss", class_name, module_name);
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyDict_SetItem(class_map, t, class) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = class;
finally:
Py_XDECREF(import);
Py_XDECREF(t);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
marker(Unpicklerobject *self) {
if (self->num_marks < 1)
{
PyErr_SetString(UnpicklingError, "could not find MARK");
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return self->marks[--self->num_marks];
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_none(Unpicklerobject *self) {
if (PyList_Append(self->stack, Py_None) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return 0;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_int(Unpicklerobject *self) {
PyObject *py_int = 0;
char *endptr, *s;
int len, res = -1;
long l;
if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
UNLESS(s=strndup(s,len)) return -1;
errno = 0;
l = strtol(s, &endptr, 0);
if (errno || (*endptr != '\n') || (endptr[1] != '\0')) {
/* Hm, maybe we've got something long. Let's try reading
it as a Python long object. */
errno=0;
UNLESS(py_int=PyLong_FromString(s,&endptr,0)) goto finally;
if ((*endptr != '\n') || (endptr[1] != '\0')) {
PyErr_SetString(PyExc_ValueError,
"could not convert string to int");
goto finally;
}
}
else {
UNLESS(py_int = PyInt_FromLong(l)) goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, py_int) < 0) goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
free(s);
Py_XDECREF(py_int);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static long
calc_binint(char *s, int x) {
unsigned char c;
int i;
long l;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
for (i = 0, l = 0L; i < x; i++) {
c = (unsigned char)s[i];
l |= (long)c << (i * 8);
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return l;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_binintx(Unpicklerobject *self, char *s, int x) {
PyObject *py_int = 0;
long l;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
l = calc_binint(s, x);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(py_int = PyInt_FromLong(l))
return -1;
if (PyList_Append(self->stack, py_int) < 0) {
Py_DECREF(py_int);
return -1;
}
1997-01-06 18:59:08 -04:00
Py_DECREF(py_int);
1997-04-09 14:36:32 -03:00
return 0;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_binint(Unpicklerobject *self) {
char *s;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->read_func)(self, &s, 4) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return load_binintx(self, s, 4);
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_binint1(Unpicklerobject *self) {
char *s;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->read_func)(self, &s, 1) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return load_binintx(self, s, 1);
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_binint2(Unpicklerobject *self) {
char *s;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->read_func)(self, &s, 2) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return load_binintx(self, s, 2);
}
static int
load_long(Unpicklerobject *self) {
PyObject *l = 0;
char *end, *s;
int len, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static PyObject *arg = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
UNLESS(s=strndup(s,len)) return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(l = PyLong_FromString(s, &end, 0))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, l) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
free(s);
Py_XDECREF(l);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_float(Unpicklerobject *self) {
PyObject *py_float = 0;
char *endptr, *s;
int len, res = -1;
double d;
if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
UNLESS(s=strndup(s,len)) return -1;
errno = 0;
d = strtod(s, &endptr);
if (errno || (endptr[0] != '\n') || (endptr[1] != '\0')) {
PyErr_SetString(PyExc_ValueError,
"could not convert string to float");
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(py_float = PyFloat_FromDouble(d))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, py_float) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
free(s);
Py_XDECREF(py_float);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
#ifdef FORMAT_1_3
static int
load_binfloat(Unpicklerobject *self) {
PyObject *py_float = 0;
int s, e, res = -1;
long fhi, flo;
double x;
char *p;
if ((*self->read_func)(self, &p, 8) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* First byte */
s = (*p>>7) & 1;
e = (*p & 0x7F) << 4;
p++;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Second byte */
e |= (*p>>4) & 0xF;
fhi = (*p & 0xF) << 24;
p++;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Third byte */
fhi |= (*p & 0xFF) << 16;
p++;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Fourth byte */
fhi |= (*p & 0xFF) << 8;
p++;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Fifth byte */
fhi |= *p & 0xFF;
p++;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Sixth byte */
flo = (*p & 0xFF) << 16;
p++;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Seventh byte */
flo |= (*p & 0xFF) << 8;
p++;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Eighth byte */
flo |= *p & 0xFF;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
x = (double)fhi + (double)flo / 16777216.0; /* 2**24 */
x /= 268435456.0; /* 2**28 */
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* XXX This sadly ignores Inf/NaN */
if (e == 0)
e = -1022;
else {
x += 1.0;
e -= 1023;
}
x = ldexp(x, e);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (s)
x = -x;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(py_float = PyFloat_FromDouble(x))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, py_float) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(py_float);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
#endif
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_string(Unpicklerobject *self) {
PyObject *str = 0;
int len, res = -1;
char *s;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static PyObject *eval_dict = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = (*self->readline_func)(self, &s)) < 0) return -1;
UNLESS(s=strndup(s,len)) return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(eval_dict)
UNLESS(eval_dict = Py_BuildValue("{s{}}", "__builtins__"))
goto finally;
1997-01-06 18:59:08 -04:00
UNLESS(str = PyRun_String(s, Py_eval_input, eval_dict, eval_dict))
1997-04-09 14:36:32 -03:00
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, str) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
free(s);
Py_XDECREF(str);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_binstring(Unpicklerobject *self) {
PyObject *py_string = 0;
long l;
int res = -1;
char *s;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->read_func)(self, &s, 4) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
l = calc_binint(s, 4);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->read_func)(self, &s, l) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(py_string = PyString_FromStringAndSize(s, l))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, py_string) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(py_string);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_short_binstring(Unpicklerobject *self) {
PyObject *py_string = 0;
unsigned char l;
int res = -1;
char *s;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->read_func)(self, &s, 1) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
l = (unsigned char)s[0];
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->read_func)(self, &s, l) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(py_string = PyString_FromStringAndSize(s, l))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, py_string) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(py_string);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_tuple(Unpicklerobject *self) {
PyObject *tup = 0, *slice = 0, *list = 0;
int i, j, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((i = marker(self)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((j = PyList_Size(self->stack)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(slice = PyList_GetSlice(self->stack, i, j))
goto finally;
UNLESS(tup = PySequence_Tuple(slice))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(list = PyList_New(1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(tup);
if (PyList_SetItem(list, 0, tup) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_SetSlice(self->stack, i, j, list) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(tup);
Py_XDECREF(list);
Py_XDECREF(slice);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_empty_tuple(Unpicklerobject *self) {
PyObject *tup = 0;
int res;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(tup=PyTuple_New(0)) return -1;
res=PyList_Append(self->stack, tup);
Py_DECREF(tup);
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_empty_list(Unpicklerobject *self) {
PyObject *list = 0;
int res;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(list=PyList_New(0)) return -1;
res=PyList_Append(self->stack, list);
Py_DECREF(list);
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_empty_dict(Unpicklerobject *self) {
PyObject *dict = 0;
int res;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(dict=PyDict_New()) return -1;
res=PyList_Append(self->stack, dict);
Py_DECREF(dict);
return res;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_list(Unpicklerobject *self) {
PyObject *list = 0, *slice = 0;
int i, j, l, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((i = marker(self)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((j = PyList_Size(self->stack)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(slice = PyList_GetSlice(self->stack, i, j))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if((l=PyList_Size(slice)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if(l) {
UNLESS(list = PyList_New(1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(slice);
if (PyList_SetItem(list, 0, slice) < 0)
goto finally;
if (PyList_SetSlice(self->stack, i, j, list) < 0)
goto finally;
} else {
if(PyList_Append(self->stack,slice) < 0)
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(list);
Py_XDECREF(slice);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_dict(Unpicklerobject *self) {
PyObject *list = 0, *dict = 0, *key = 0, *value = 0;
int i, j, k, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((i = marker(self)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((j = PyList_Size(self->stack)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(dict = PyDict_New())
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
for (k = i; k < j; k += 2) {
UNLESS(key = PyList_GET_ITEM((PyListObject *)self->stack, k))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(value = PyList_GET_ITEM((PyListObject *)self->stack, k + 1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyDict_SetItem(dict, key, value) < 0)
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if(j) {
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(list = PyList_New(1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(dict);
if (PyList_SetItem(list, 0, dict) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_SetSlice(self->stack, i, j, list) < 0)
goto finally;
}
else
if(PyList_Append(self->stack, dict) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(dict);
Py_XDECREF(list);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
static PyObject *
1997-04-09 14:36:32 -03:00
Instance_New(PyObject *cls, PyObject *args)
1997-01-06 18:59:08 -04:00
{
1997-04-09 14:36:32 -03:00
int has_key;
PyObject *safe=0, *r=0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyClass_Check(cls))
if(r=PyInstance_New(cls, args, NULL)) return r;
else goto err;
if ((has_key = cPickle_PyMapping_HasKey(safe_constructors, cls)) < 0)
1997-01-06 18:59:08 -04:00
goto err;
1997-04-09 14:36:32 -03:00
if (!has_key)
if(!(safe = PyObject_GetAttr(cls, __safe_for_unpickling___str)) ||
!PyObject_IsTrue(safe)) {
PyErr_Format(UnpicklingError, "%s is not safe for unpickling", "O", cls);
Py_XDECREF(safe);
return NULL;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if(r=PyObject_CallObject(cls, args)) return r;
err:
1997-01-06 18:59:08 -04:00
{
1997-04-09 14:36:32 -03:00
PyObject *tp, *v, *tb;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
PyErr_Fetch(&tp, &v, &tb);
if(r=Py_BuildValue("OOO",v,cls,args))
{
Py_XDECREF(v);
v=r;
}
PyErr_Restore(tp,v,tb);
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
return NULL;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_obj(Unpicklerobject *self) {
PyObject *class = 0, *slice = 0, *tup = 0, *obj = 0;
int i, len, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((i = marker(self)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
class = PyList_GET_ITEM((PyListObject *)self->stack, i);
Py_INCREF(class);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyList_Size(self->stack)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(slice = PyList_GetSlice(self->stack, i + 1, len))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(tup = PySequence_Tuple(slice))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(obj = Instance_New(class, tup))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (DEL_LIST_SLICE(self->stack, i, len) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, obj) < 0)
goto finally;
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(class);
Py_XDECREF(slice);
Py_XDECREF(tup);
Py_XDECREF(obj);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_inst(Unpicklerobject *self) {
PyObject *arg_tup = 0, *arg_slice = 0, *class = 0, *obj = 0,
*module_name = 0, *class_name = 0;
int i, j, len, res = -1;
char *s;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((i = marker(self)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((j = PyList_Size(self->stack)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(arg_slice = PyList_GetSlice(self->stack, i, j))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(arg_tup = PySequence_Tuple(arg_slice))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (DEL_LIST_SLICE(self->stack, i, j) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = (*self->readline_func)(self, &s)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(module_name = PyString_FromStringAndSize(s, len - 1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = (*self->readline_func)(self, &s)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(class_name = PyString_FromStringAndSize(s, len - 1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(class = find_class(module_name, class_name))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(obj = Instance_New(class, arg_tup))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, obj) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(class);
Py_XDECREF(arg_slice);
Py_XDECREF(arg_tup);
Py_XDECREF(obj);
Py_XDECREF(module_name);
Py_XDECREF(class_name);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_global(Unpicklerobject *self) {
PyObject *class = 0, *module_name = 0, *class_name = 0;
int res = -1, len;
char *s;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = (*self->readline_func)(self, &s)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(module_name = PyString_FromStringAndSize(s, len - 1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = (*self->readline_func)(self, &s)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(class_name = PyString_FromStringAndSize(s, len - 1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(class = find_class(module_name, class_name))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, class) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(class);
Py_XDECREF(module_name);
Py_XDECREF(class_name);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_persid(Unpicklerobject *self) {
PyObject *pid = 0, *pers_load_val = 0;
int len, res = -1;
char *s;
if (self->pers_func) {
if ((len = (*self->readline_func)(self, &s)) < 0)
goto finally;
UNLESS(pid = PyString_FromStringAndSize(s, len - 1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(self->arg)
UNLESS(self->arg = PyTuple_New(1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(pid);
if (PyTuple_SetItem(self->arg, 0, pid) < 0)
goto finally;
UNLESS(pers_load_val =
PyObject_CallObject(self->pers_func, self->arg))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, pers_load_val) < 0)
goto finally;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(pid);
Py_XDECREF(pers_load_val);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_binpersid(Unpicklerobject *self) {
PyObject *pid = 0, *pers_load_val = 0;
int len, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (self->pers_func) {
if ((len = PyList_Size(self->stack)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
pid = PyList_GET_ITEM((PyListObject *)self->stack, len - 1);
Py_INCREF(pid);
if (DEL_LIST_SLICE(self->stack, len - 1, len) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(self->arg)
UNLESS(self->arg = PyTuple_New(1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(pid);
if (PyTuple_SetItem(self->arg, 0, pid) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(pers_load_val =
PyObject_CallObject(self->pers_func, self->arg))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, pers_load_val) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(pid);
Py_XDECREF(pers_load_val);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_pop(Unpicklerobject *self) {
int len;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyList_Size(self->stack)) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((self->num_marks > 0) &&
(self->marks[self->num_marks - 1] == len))
self->num_marks--;
else if (DEL_LIST_SLICE(self->stack, len - 1, len) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return 0;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_pop_mark(Unpicklerobject *self) {
int i, len;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((i = marker(self)) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyList_Size(self->stack)) < 0)
return -1;
if (DEL_LIST_SLICE(self->stack, i, len) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return 0;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_dup(Unpicklerobject *self) {
PyObject *last;
int len;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyList_Size(self->stack)) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(last = PyList_GetItem(self->stack, len - 1))
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, last) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return 0;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_get(Unpicklerobject *self) {
PyObject *py_str = 0, *value = 0;
int len, res = -1;
char *s;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = (*self->readline_func)(self, &s)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(py_str = PyString_FromStringAndSize(s, len - 1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(value = PyDict_GetItem(self->memo, py_str))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, value) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(py_str);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_binget(Unpicklerobject *self) {
PyObject *py_key = 0, *value = 0;
unsigned char key;
int res = -1;
char *s;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->read_func)(self, &s, 1) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
key = (unsigned char)s[0];
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(py_key = PyInt_FromLong((long)key))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(value = PyDict_GetItem(self->memo, py_key))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, value) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(py_key);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_long_binget(Unpicklerobject *self) {
PyObject *py_key = 0, *value = 0;
unsigned char c, *s;
long key;
int res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->read_func)(self, &s, 4) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
c = (unsigned char)s[0];
key = (long)c;
c = (unsigned char)s[1];
key |= (long)c << 8;
c = (unsigned char)s[2];
key |= (long)c << 16;
c = (unsigned char)s[3];
key |= (long)c << 24;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(py_key = PyInt_FromLong(key))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(value = PyDict_GetItem(self->memo, py_key))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, value) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(py_key);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_put(Unpicklerobject *self) {
PyObject *py_str = 0, *value = 0;
int len, res = -1;
char *s;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = (*self->readline_func)(self, &s)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(py_str = PyString_FromStringAndSize(s, len - 1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyList_Size(self->stack)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(value = PyList_GetItem(self->stack, len - 1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyDict_SetItem(self->memo, py_str, value) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(py_str);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_binput(Unpicklerobject *self) {
PyObject *py_key = 0, *value = 0;
unsigned char key, *s;
int len, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->read_func)(self, &s, 1) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
key = (unsigned char)s[0];
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(py_key = PyInt_FromLong((long)key))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyList_Size(self->stack)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(value = PyList_GetItem(self->stack, len - 1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyDict_SetItem(self->memo, py_key, value) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(py_key);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_long_binput(Unpicklerobject *self) {
PyObject *py_key = 0, *value = 0;
long key;
unsigned char c, *s;
int len, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((*self->read_func)(self, &s, 4) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
c = (unsigned char)s[0];
key = (long)c;
c = (unsigned char)s[1];
key |= (long)c << 8;
c = (unsigned char)s[2];
key |= (long)c << 16;
c = (unsigned char)s[3];
key |= (long)c << 24;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(py_key = PyInt_FromLong(key))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyList_Size(self->stack)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(value = PyList_GetItem(self->stack, len - 1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyDict_SetItem(self->memo, py_key, value) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(py_key);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
do_append(Unpicklerobject *self, int x) {
PyObject *value = 0, *list = 0, *append_method = 0;
int len, i;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyList_Size(self->stack)) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(list = PyList_GetItem(self->stack, x - 1))
goto err;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Check(list)) {
PyObject *slice = 0;
int list_len;
UNLESS(slice = PyList_GetSlice(self->stack, x, len))
return -1;
list_len = PyList_Size(list);
if (PyList_SetSlice(list, list_len, list_len, slice) < 0) {
Py_DECREF(slice);
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_DECREF(slice);
}
else {
UNLESS(append_method = PyObject_GetAttr(list, append_str))
return -1;
for (i = x; i < len; i++) {
PyObject *junk;
UNLESS(value = PyList_GetItem(self->stack, i))
return -1;
UNLESS(self->arg)
UNLESS(self->arg = PyTuple_New(1))
goto err;
Py_INCREF(value);
if (PyTuple_SetItem(self->arg, 0, value) < 0)
goto err;
UNLESS(junk = PyObject_CallObject(append_method, self->arg))
goto err;
Py_DECREF(junk);
}
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (DEL_LIST_SLICE(self->stack, x, len) < 0)
goto err;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_XDECREF(append_method);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return 0;
1997-01-06 18:59:08 -04:00
err:
1997-04-09 14:36:32 -03:00
Py_XDECREF(append_method);
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_append(Unpicklerobject *self) {
return do_append(self, PyList_Size(self->stack) - 1);
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_appends(Unpicklerobject *self) {
return do_append(self, marker(self));
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
do_setitems(Unpicklerobject *self, int x) {
PyObject *value = 0, *key = 0, *dict = 0;
int len, i, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyList_Size(self->stack)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(dict = PyList_GetItem(self->stack, x - 1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
for (i = x; i < len; i += 2) {
UNLESS(key = PyList_GetItem(self->stack, i))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(value = PyList_GetItem(self->stack, i + 1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyObject_SetItem(dict, key, value) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if (DEL_LIST_SLICE(self->stack, x, len) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
return res;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
static int
load_setitem(Unpicklerobject *self) {
return do_setitems(self, PyList_Size(self->stack) - 2);
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_setitems(Unpicklerobject *self) {
return do_setitems(self, marker(self));
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_build(Unpicklerobject *self) {
PyObject *value = 0, *inst = 0, *instdict = 0, *d_key = 0, *d_value = 0,
*junk = 0, *__setstate__ = 0;
int len, i, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyList_Size(self->stack)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(value = PyList_GetItem(self->stack, len - 1))
goto finally;
Py_INCREF(value);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (DEL_LIST_SLICE(self->stack, len - 1, len) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(inst = PyList_GetItem(self->stack, len - 2))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(__setstate__ = PyObject_GetAttr(inst, __setstate___str))
{
PyErr_Clear();
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(instdict = PyObject_GetAttr(inst, __dict___str))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
i = 0;
while (PyDict_Next(value, &i, &d_key, &d_value)) {
if (PyObject_SetItem(instdict, d_key, d_value) < 0)
goto finally;
}
}
else {
UNLESS(self->arg)
UNLESS(self->arg = PyTuple_New(1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(value);
if (PyTuple_SetItem(self->arg, 0, value) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(junk = PyObject_CallObject(__setstate__, self->arg))
goto finally;
1997-01-06 18:59:08 -04:00
Py_DECREF(junk);
1997-04-09 14:36:32 -03:00
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(value);
Py_XDECREF(instdict);
Py_XDECREF(__setstate__);
return res;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_mark(Unpicklerobject *self) {
int len;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyList_Size(self->stack)) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (!self->marks_size) {
self->marks_size = 20;
UNLESS(self->marks = (int *)malloc(self->marks_size * sizeof(int))) {
PyErr_NoMemory();
return -1;
}
}
else if ((self->num_marks + 1) >= self->marks_size) {
UNLESS(self->marks = (int *)realloc(self->marks,
(self->marks_size + 20) * sizeof(int))) {
PyErr_NoMemory();
return -1;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
self->marks_size += 20;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
self->marks[self->num_marks++] = len;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return 0;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
load_reduce(Unpicklerobject *self) {
PyObject *callable = 0, *arg_tup = 0, *ob = 0;
int len, res = -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyList_Size(self->stack)) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(arg_tup = PyList_GetItem(self->stack, len - 1))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(callable = PyList_GetItem(self->stack, len - 2))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(ob = Instance_New(callable, arg_tup))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyList_Append(self->stack, ob) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (DEL_LIST_SLICE(self->stack, len - 2, len) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(ob);
return res;
}
static PyObject *
load(Unpicklerobject *self)
{
PyObject *stack = 0, *err = 0, *exc = 0, *val = 0, *tb = 0;
int len;
char *s;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(stack = PyList_New(0))
goto err;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
self->stack = stack;
self->num_marks = 0;
while (1) {
if ((*self->read_func)(self, &s, 1) < 0)
break;
switch (s[0]) {
case NONE:
if (load_none(self) < 0)
break;
continue;
case BININT:
if (load_binint(self) < 0)
break;
continue;
case BININT1:
if (load_binint1(self) < 0)
break;
continue;
case BININT2:
if (load_binint2(self) < 0)
break;
continue;
case INT:
if (load_int(self) < 0)
break;
continue;
case LONG:
if (load_long(self) < 0)
break;
continue;
case FLOAT:
if (load_float(self) < 0)
break;
continue;
#ifdef FORMAT_1_3
case BINFLOAT:
if (load_binfloat(self) < 0)
break;
continue;
#endif
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
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;
case EMPTY_TUPLE:
if (load_empty_tuple(self) < 0)
break;
continue;
case TUPLE:
if (load_tuple(self) < 0)
break;
continue;
case EMPTY_LIST:
if (load_empty_list(self) < 0)
break;
continue;
case LIST:
if (load_list(self) < 0)
break;
continue;
case EMPTY_DICT:
if (load_empty_dict(self) < 0)
break;
continue;
case DICT:
if (load_dict(self) < 0)
break;
continue;
case OBJ:
if (load_obj(self) < 0)
break;
continue;
case INST:
if (load_inst(self) < 0)
break;
continue;
case GLOBAL:
if (load_global(self) < 0)
break;
continue;
case APPEND:
if (load_append(self) < 0)
break;
continue;
case APPENDS:
if (load_appends(self) < 0)
break;
continue;
case BUILD:
if (load_build(self) < 0)
break;
continue;
case DUP:
if (load_dup(self) < 0)
break;
continue;
case BINGET:
if (load_binget(self) < 0)
break;
continue;
case LONG_BINGET:
if (load_long_binget(self) < 0)
break;
continue;
case GET:
if (load_get(self) < 0)
break;
continue;
case MARK:
if (load_mark(self) < 0)
break;
continue;
case BINPUT:
if (load_binput(self) < 0)
break;
continue;
case LONG_BINPUT:
if (load_long_binput(self) < 0)
break;
continue;
case PUT:
if (load_put(self) < 0)
break;
continue;
case POP:
if (load_pop(self) < 0)
break;
continue;
case POP_MARK:
if (load_pop_mark(self) < 0)
break;
continue;
case SETITEM:
if (load_setitem(self) < 0)
break;
continue;
case SETITEMS:
if (load_setitems(self) < 0)
break;
continue;
case STOP:
break;
case PERSID:
if (load_persid(self) < 0)
break;
continue;
case BINPERSID:
if (load_binpersid(self) < 0)
break;
continue;
case REDUCE:
if (load_reduce(self) < 0)
break;
continue;
default:
PyErr_Format(UnpicklingError, "invalid load key, '%s'.",
"c", s[0]);
goto err;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
break;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if ((err = PyErr_Occurred()) == PyExc_EOFError) {
PyErr_SetNone(PyExc_EOFError);
goto err;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (err) goto err;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if ((len = PyList_Size(stack)) < 0) goto err;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(val = PyList_GetItem(stack, len - 1)) goto err;
Py_INCREF(val);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_DECREF(stack);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
self->stack=NULL;
return val;
1997-01-06 18:59:08 -04:00
err:
1997-04-09 14:36:32 -03:00
self->stack=NULL;
Py_XDECREF(stack);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return NULL;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static PyObject *
Unpickler_load(Unpicklerobject *self, PyObject *args) {
UNLESS(PyArg_ParseTuple(args, ""))
return NULL;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return load(self);
}
static struct PyMethodDef Unpickler_methods[] = {
{"load", (PyCFunction)Unpickler_load, 1, ""},
{NULL, NULL} /* sentinel */
1997-01-06 18:59:08 -04:00
};
static Unpicklerobject *
1997-04-09 14:36:32 -03:00
newUnpicklerobject(PyObject *f) {
Unpicklerobject *self;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(self = PyObject_NEW(Unpicklerobject, &Unpicklertype))
return NULL;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
self->file = NULL;
self->arg = NULL;
self->stack = NULL;
self->pers_func = NULL;
self->last_string = NULL;
self->marks = NULL;
self->num_marks = 0;
self->marks_size = 0;
self->buf_size = 0;
1997-01-06 18:59:08 -04:00
self->read = NULL;
1997-04-09 14:36:32 -03:00
self->readline = NULL;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(self->memo = PyDict_New()) {
Py_XDECREF((PyObject *)self);
return NULL;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(f);
self->file = f;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Set read, readline based on type of f */
if (PyFile_Check(f)) {
self->fp = PyFile_AsFile(f);
self->read_func = read_file;
self->readline_func = readline_file;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
else if (PycStringIO_InputCheck(f)) {
self->fp = NULL;
self->read_func = read_cStringIO;
self->readline_func = readline_cStringIO;
}
else {
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
self->fp = NULL;
self->read_func = read_other;
self->readline_func = readline_other;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS((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" );
Py_XDECREF((PyObject *)self);
return NULL;
}
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return self;
1997-01-06 18:59:08 -04:00
}
static PyObject *
1997-04-09 14:36:32 -03:00
get_Unpickler(PyObject *self, PyObject *args) {
PyObject *file;
UNLESS(PyArg_ParseTuple(args, "O", &file))
return NULL;
return (PyObject *)newUnpicklerobject(file);
1997-01-06 18:59:08 -04:00
}
static void
1997-04-09 14:36:32 -03:00
Unpickler_dealloc(Unpicklerobject *self) {
Py_XDECREF(self->readline);
Py_XDECREF(self->read);
Py_XDECREF(self->file);
Py_XDECREF(self->memo);
Py_XDECREF(self->stack);
Py_XDECREF(self->pers_func);
Py_XDECREF(self->arg);
Py_XDECREF(self->last_string);
if (self->marks) {
free(self->marks);
}
if (self->buf_size) {
free(self->buf);
}
PyMem_DEL(self);
1997-01-06 18:59:08 -04:00
}
static PyObject *
1997-04-09 14:36:32 -03:00
Unpickler_getattr(Unpicklerobject *self, char *name) {
if (!strcmp(name, "persistent_load")) {
if (!self->pers_func) {
PyErr_SetString(PyExc_AttributeError, name);
return NULL;
}
Py_INCREF(self->pers_func);
return self->pers_func;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if (!strcmp(name, "memo")) {
if (!self->memo) {
PyErr_SetString(PyExc_AttributeError, name);
return NULL;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(self->memo);
return self->memo;
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
if (!strcmp(name, "stack")) {
if (!self->stack) {
PyErr_SetString(PyExc_AttributeError, name);
return NULL;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_INCREF(self->stack);
return self->stack;
}
if (!strcmp(name, "UnpicklingError")) {
Py_INCREF(UnpicklingError);
return UnpicklingError;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return Py_FindMethod(Unpickler_methods, (PyObject *)self, name);
1997-01-06 18:59:08 -04:00
}
static int
1997-04-09 14:36:32 -03:00
Unpickler_setattr(Unpicklerobject *self, char *name, PyObject *value) {
if (!strcmp(name, "persistent_load")) {
Py_XDECREF(self->pers_func);
self->pers_func = value;
Py_INCREF(value);
return 0;
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
PyErr_SetString(PyExc_AttributeError, name);
return -1;
1997-01-06 18:59:08 -04:00
}
static PyObject *
1997-04-09 14:36:32 -03:00
cpm_dump(PyObject *self, PyObject *args) {
PyObject *ob, *file, *res = NULL;
Picklerobject *pickler = 0;
int bin = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(PyArg_ParseTuple(args, "OO|i", &ob, &file, &bin))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(pickler = newPicklerobject(file, bin))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (dump(pickler, ob) < 0)
goto finally;
Py_INCREF(Py_None);
res = Py_None;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(pickler);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
static PyObject *
1997-04-09 14:36:32 -03:00
cpm_dumps(PyObject *self, PyObject *args) {
PyObject *ob, *file = 0, *res = NULL;
Picklerobject *pickler = 0;
int bin = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(PyArg_ParseTuple(args, "O|i", &ob, &bin))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(file = PycStringIO->NewOutput(128))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(pickler = newPicklerobject(file, bin))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (dump(pickler, ob) < 0)
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = PycStringIO->cgetvalue(file);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(pickler);
Py_XDECREF(file);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
static PyObject *
1997-04-09 14:36:32 -03:00
cpm_load(PyObject *self, PyObject *args) {
Unpicklerobject *unpickler = 0;
PyObject *ob, *res = NULL;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(PyArg_ParseTuple(args, "O", &ob))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(unpickler = newUnpicklerobject(ob))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = load(unpickler);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(unpickler);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
static PyObject *
1997-04-09 14:36:32 -03:00
cpm_loads(PyObject *self, PyObject *args) {
PyObject *ob, *file = 0, *res = NULL;
Unpicklerobject *unpickler = 0;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(PyArg_ParseTuple(args, "O", &ob))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(file = PycStringIO->NewInput(ob))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(unpickler = newUnpicklerobject(file))
goto finally;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
res = load(unpickler);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
finally:
Py_XDECREF(file);
Py_XDECREF(unpickler);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
return res;
1997-01-06 18:59:08 -04:00
}
static char Unpicklertype__doc__[] = "";
1997-04-09 14:36:32 -03:00
static PyTypeObject Unpicklertype_value() {
PyTypeObject Unpicklertype = {
PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
"Unpickler", /*tp_name*/
sizeof(Unpicklerobject), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)Unpickler_dealloc, /*tp_dealloc*/
(printfunc)0, /*tp_print*/
(getattrfunc)Unpickler_getattr, /*tp_getattr*/
(setattrfunc)Unpickler_setattr, /*tp_setattr*/
(cmpfunc)0, /*tp_compare*/
(reprfunc)0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
(hashfunc)0, /*tp_hash*/
(ternaryfunc)0, /*tp_call*/
(reprfunc)0, /*tp_str*/
/* Space for future expansion */
0L,0L,0L,0L,
Unpicklertype__doc__ /* Documentation string */
};
return Unpicklertype;
}
static struct PyMethodDef cPickle_methods[] = {
{"dump", (PyCFunction)cpm_dump, 1, ""},
{"dumps", (PyCFunction)cpm_dumps, 1, ""},
{"load", (PyCFunction)cpm_load, 1, ""},
{"loads", (PyCFunction)cpm_loads, 1, ""},
1997-01-06 18:59:08 -04:00
{"Pickler", (PyCFunction)get_Pickler, 1, ""},
1997-04-09 14:36:32 -03:00
{"Unpickler", (PyCFunction)get_Unpickler, 1, ""},
1997-01-06 18:59:08 -04:00
{ NULL, NULL }
};
1997-04-09 14:36:32 -03:00
#define CHECK_FOR_ERRORS(MESS) \
if(PyErr_Occurred()) { \
PyObject *__sys_exc_type, *__sys_exc_value, *__sys_exc_traceback; \
PyErr_Fetch( &__sys_exc_type, &__sys_exc_value, &__sys_exc_traceback); \
fprintf(stderr, # MESS ":\n\t"); \
PyObject_Print(__sys_exc_type, stderr,0); \
fprintf(stderr,", "); \
PyObject_Print(__sys_exc_value, stderr,0); \
fprintf(stderr,"\n"); \
fflush(stderr); \
Py_FatalError(# MESS); \
}
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
static int
init_stuff(PyObject *module, PyObject *module_dict) {
PyObject *string, *copy_reg;
#define INIT_STR(S) UNLESS(S ## _str=PyString_FromString(#S)) return -1;
INIT_STR(__class__);
INIT_STR(__getinitargs__);
INIT_STR(__dict__);
INIT_STR(__getstate__);
INIT_STR(__setstate__);
INIT_STR(__name__);
INIT_STR(__reduce__);
INIT_STR(write);
INIT_STR(__safe_for_unpickling__);
INIT_STR(append);
INIT_STR(read);
INIT_STR(readline);
UNLESS(builtins = PyImport_ImportModule("__builtin__"))
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(copy_reg = PyImport_ImportModule("copy_reg"))
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(dispatch_table = PyObject_GetAttrString(copy_reg,
"dispatch_table"))
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(safe_constructors = PyObject_GetAttrString(copy_reg,
"safe_constructors"))
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_DECREF(copy_reg);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(string = PyImport_ImportModule("string"))
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(atol_func = PyObject_GetAttrString(string, "atol"))
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Py_DECREF(string);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(empty_tuple = PyTuple_New(0))
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(class_map = PyDict_New())
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(PicklingError = PyString_FromString("cPickle.PicklingError"))
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyDict_SetItemString(module_dict, "PicklingError",
PicklingError) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
UNLESS(UnpicklingError = PyString_FromString("cPickle.UnpicklingError"))
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
if (PyDict_SetItemString(module_dict, "UnpicklingError",
UnpicklingError) < 0)
return -1;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
PycString_IMPORT;
return 0;
1997-01-06 18:59:08 -04:00
}
/* Initialization function for the module (*must* be called initcPickle) */
void
1997-04-09 14:36:32 -03:00
initcPickle() {
PyObject *m, *d;
char *rev="$Revision$";
PyObject *format_version;
PyObject *compatible_formats;
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Create the module and add the functions */
m = Py_InitModule4("cPickle", cPickle_methods,
cPickle_module_documentation,
(PyObject*)NULL,PYTHON_API_VERSION);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
Picklertype=Picklertype_value();
Unpicklertype=Unpicklertype_value();
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
/* Add some symbolic constants to the module */
d = PyModule_GetDict(m);
PyDict_SetItemString(d,"__version__",
PyString_FromStringAndSize(rev+11,strlen(rev+11)-2));
1997-04-09 14:36:32 -03:00
#ifdef FORMAT_1_3
format_version = PyString_FromString("1.3");
compatible_formats = Py_BuildValue("[sss]", "1.0", "1.1", "1.2");
#else
format_version = PyString_FromString("1.2");
compatible_formats = Py_BuildValue("[ss]", "1.0", "1.1");
#endif
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
PyDict_SetItemString(d, "format_version", format_version);
PyDict_SetItemString(d, "compatible_formats", compatible_formats);
1997-01-06 18:59:08 -04:00
1997-04-09 14:36:32 -03:00
init_stuff(m, d);
CHECK_FOR_ERRORS("can't initialize module cPickle");
1997-01-06 18:59:08 -04:00
}
1997-04-09 14:36:32 -03:00
/****************************************************************************
$Log$
Revision 2.6 1997/05/13 18:00:44 guido
Use compile-time test for 64-bit hardware instead of run-time test.
This silences some compilers.
Revision 2.5 1997/05/07 17:46:13 guido
Instead of importing graminit.h whenever one of the three grammar 'root'
symbols is needed, define these in Python.h with a Py_ prefix.
Revision 2.4 1997/04/09 17:47:47 guido
Give PyErr_Format a new name and make it static.
1997-04-09 14:36:32 -03:00
Revision 2.3 1997/04/09 17:36:32 guido
Jim Fulton's version 2.2.
Revision 1.36 1997/03/11 22:05:02 chris
write POP rather than POPMARK in non-binary mode
use put2() in save_reduce() and save_inst() only if state is not a dictionary
removed put2() from save_tuple()
Revision 1.35 1997/03/11 20:03:30 jim
Added log comment at bottom.
****************************************************************************/