/*

cPickle.c,v 1.46 1997/12/04 00:08:07 jim Exp

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, [email protected]

Digital Creations L.C.

(540) 371-6909

*/

static char cPickle_module_documentation[] =

"C implementation and optimization of the Python pickle module\n"

"\n"

"cPickle.c,v 1.46 1997/12/04 00:08:07 jim Exp\n"

;

#include "Python.h"

#include "cStringIO.h"

#include "mymath.h"

#ifndef Py_eval_input

#include <graminit.h>

#define Py_eval_input eval_input

#endif /* Py_eval_input */

#include <errno.h>

#define UNLESS(E) if (!(E))

#define DEL_LIST_SLICE(list, from, to) (PyList_SetSlice(list, from, to, NULL))

#define WRITE_BUF_SIZE 256

#define MARK '('

#define STOP '.'

#define POP '0'

#define POP_MARK '1'

#define DUP '2'

#define FLOAT 'F'

#define BINFLOAT 'G'

#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;

/* atol function from string module */

static PyObject *atol_func;

static PyObject *PicklingError;

static PyObject *UnpicklingError;

static PyObject *dispatch_table;

static PyObject *safe_constructors;

static PyObject *class_map;

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, *__main___str,

*copy_reg_str, *dispatch_table_str, *safe_constructors_str;

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;

PyObject *dispatch_table;

PyObject *class_map;

} Picklerobject;

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;

PyObject *safe_constructors;

PyObject *class_map;

} Unpicklerobject;

static PyTypeObject Unpicklertype;

int

cPickle_PyMapping_HasKey(PyObject *o, PyObject *key) {

PyObject *v;

if((v = PyObject_GetItem(o,key))) {

Py_DECREF(v);

return 1;

}

PyErr_Clear();

return 0;

}

#define PyErr_Format PyErr_JFFormat

static

PyObject *

#ifdef HAVE_STDARG_PROTOTYPES

/* VARARGS 2 */

PyErr_Format(PyObject *ErrType, char *stringformat, char *format, ...) {

#else

/* VARARGS */

PyErr_Format(va_alist) va_dcl {

#endif

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;

if(retval) {

if(args) {

PyObject *v;

v=PyString_Format(retval, args);

Py_DECREF(retval);

Py_DECREF(args);

if(! v) return NULL;

retval=v;

}

}

else

if(args) retval=args;

else {

PyErr_SetObject(ErrType,Py_None);

return NULL;

}

PyErr_SetObject(ErrType,retval);

Py_DECREF(retval);

return NULL;

}

static int

write_file(Picklerobject *self, char *s, int n) {

if (s == NULL) {

return 0;

}

if ((int)fwrite(s, sizeof(char), n, self->fp) != n) {

PyErr_SetFromErrno(PyExc_IOError);

return -1;

}

return n;

}

static int

write_cStringIO(Picklerobject *self, char *s, int n) {

if (s == NULL) {

return 0;

}

if (PycStringIO->cwrite((PyObject *)self->file, s, n) != n) {

return -1;

}

return n;

}

static int

write_none(Picklerobject *self, char *s, int n) {

if (s == NULL) return 0;

return n;

}

static int

write_other(Picklerobject *self, char *s, int n) {

PyObject *py_str = 0, *junk = 0;

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;

}

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;

}

}

UNLESS(self->arg)

UNLESS(self->arg = PyTuple_New(1))

goto finally;

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;

finally:

Py_XDECREF(py_str);

return res;

}

static int

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;

}

if ((int)fread(self->buf, sizeof(char), n, self->fp) != n) {

if (feof(self->fp)) {

PyErr_SetNone(PyExc_EOFError);

return -1;

}

PyErr_SetFromErrno(PyExc_IOError);

return -1;

}

*s = self->buf;

return n;

}

static int

readline_file(Unpicklerobject *self, char **s) {

int i;

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;

}

}

UNLESS(self->buf = (char *)realloc(self->buf,

(self->buf_size * 2) * sizeof(char))) {

PyErr_NoMemory();

return -1;

}

self->buf_size *= 2;

}

}

static int

read_cStringIO(Unpicklerobject *self, char **s, int n) {

char *ptr;

if (PycStringIO->cread((PyObject *)self->file, &ptr, n) != n) {

PyErr_SetNone(PyExc_EOFError);

return -1;

}

*s = ptr;

return n;

}

static int

readline_cStringIO(Unpicklerobject *self, char **s) {

int n;

char *ptr;

if ((n = PycStringIO->creadline((PyObject *)self->file, &ptr)) < 0) {

return -1;

}

*s = ptr;

return n;

}

static int

read_other(Unpicklerobject *self, char **s, int n) {

PyObject *bytes, *str;

int res = -1;

UNLESS(bytes = PyInt_FromLong(n)) {

if (!PyErr_Occurred())

PyErr_SetNone(PyExc_EOFError);

goto finally;

}

UNLESS(self->arg)

UNLESS(self->arg = PyTuple_New(1))

goto finally;

Py_INCREF(bytes);

if (PyTuple_SetItem(self->arg, 0, bytes) < 0)

goto finally;

UNLESS(str = PyObject_CallObject(self->read, self->arg))

goto finally;

Py_XDECREF(self->last_string);

self->last_string = str;

*s = PyString_AsString(str);

res = n;

finally:

Py_XDECREF(bytes);

return res;

}

static int

readline_other(Unpicklerobject *self, char **s) {

PyObject *str;

int str_size;

UNLESS(str = PyObject_CallObject(self->readline, empty_tuple)) {

return -1;

}

str_size = PyString_Size(str);

Py_XDECREF(self->last_string);

self->last_string = str;

*s = PyString_AsString(str);

return str_size;

}

static char *

pystrndup(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;

}

static int

get(Picklerobject *self, PyObject *id) {

PyObject *value = 0;

long c_value;

char s[30];

int len;

UNLESS(value = PyDict_GetItem(self->memo, id))

return -1;

UNLESS(value = PyTuple_GetItem(value, 0))

return -1;

c_value = PyInt_AsLong(value);

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;

}

}

if ((*self->write_func)(self, s, len) < 0)

return -1;

return 0;

}

static int

put(Picklerobject *self, PyObject *ob) {

if (ob->ob_refcnt < 2)

return 0;

return put2(self, ob);

}

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;

}

}

if ((*self->write_func)(self, c_str, len) < 0)

goto finally;

UNLESS(py_ob_id = PyInt_FromLong((long)ob))

goto finally;

UNLESS(memo_len = PyInt_FromLong(p))

goto finally;

UNLESS(t = PyTuple_New(2))

goto finally;

PyTuple_SET_ITEM(t, 0, memo_len);

Py_INCREF(memo_len);

PyTuple_SET_ITEM(t, 1, ob);

Py_INCREF(ob);

if (PyDict_SetItem(self->memo, py_ob_id, t) < 0)

goto finally;

res = 0;

finally:

Py_XDECREF(py_ob_id);

Py_XDECREF(memo_len);

Py_XDECREF(t);

return res;

}

#define PyImport_Import cPickle_Import

static PyObject *

PyImport_Import(PyObject *module_name) {

static PyObject *silly_list=0, *__builtins___str=0, *__import___str;

static PyObject *standard_builtins=0;

PyObject *globals=0, *__import__=0, *__builtins__=0, *r=0;

UNLESS(silly_list) {

UNLESS(__import___str=PyString_FromString("__import__")) return NULL;

UNLESS(__builtins___str=PyString_FromString("__builtins__")) return NULL;

UNLESS(silly_list=Py_BuildValue("[s]","__doc__")) return NULL;

}

if((globals=PyEval_GetGlobals())) {

Py_INCREF(globals);

UNLESS(__builtins__=PyObject_GetItem(globals,__builtins___str)) goto err;

}

else {

PyErr_Clear();

UNLESS(standard_builtins ||

(standard_builtins=PyImport_ImportModule("__builtin__")))

return NULL;

__builtins__=standard_builtins;

Py_INCREF(__builtins__);

UNLESS(globals = Py_BuildValue("{sO}", "__builtins__", __builtins__))

goto err;

}

if(PyDict_Check(__builtins__)) {

UNLESS(__import__=PyObject_GetItem(__builtins__,__import___str)) goto err;

}

else {

UNLESS(__import__=PyObject_GetAttr(__builtins__,__import___str)) goto err;

}

UNLESS(r=PyObject_CallFunction(__import__,"OOOO",

module_name, globals, globals, silly_list))

goto err;

Py_DECREF(globals);

Py_DECREF(__builtins__);

Py_DECREF(__import__);

return r;

err:

Py_XDECREF(globals);

Py_XDECREF(__builtins__);

Py_XDECREF(__import__);

return NULL;

}

static PyObject *

whichmodule(PyObject *class_map, PyObject *global, PyObject *global_name) {

int i, j;

PyObject *module = 0, *modules_dict = 0,

*global_name_attr = 0, *name = 0;

module = PyObject_GetAttrString(global, "__module__");

if (module) return module;

PyErr_Clear();

if ((module = PyDict_GetItem(class_map, global))) {

Py_INCREF(module);

return module;

}

else {

PyErr_Clear();

}

UNLESS(modules_dict = PySys_GetObject("modules"))

return NULL;

i = 0;

while ((j = PyDict_Next(modules_dict, &i, &name, &module))) {

if(PyObject_Compare(name, __main___str)==0) continue;

UNLESS(global_name_attr = PyObject_GetAttr(module, global_name)) {

PyErr_Clear();

continue;

}

if (global_name_attr != global) {

Py_DECREF(global_name_attr);

continue;

}

Py_DECREF(global_name_attr);

break;

}

/* The following implements the rule in pickle.py added in 1.5

that used __main__ if no module is found. I don't actually

like this rule. jlf

*/

if(!j) {

j=1;

name=__main___str;

}

/*

if (!j) {

PyErr_Format(PicklingError, "Could not find module for %s.",

"O", global_name);

return NULL;

}

*/

PyDict_SetItem(class_map, global, name);

Py_INCREF(name);

return name;

}

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

) {

/* 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;

}

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;

}

if ((*self->write_func)(self, c_str, len) < 0)

return -1;

}

return 0;

}

static int

save_long(Picklerobject *self, PyObject *args) {

int size, res = -1;

PyObject *repr = 0;

static char l = LONG;

UNLESS(repr = PyObject_Repr(args))

goto finally;

if ((size = PyString_Size(repr)) < 0)

goto finally;

if ((*self->write_func)(self, &l, 1) < 0)

goto finally;

if ((*self->write_func)(self,

PyString_AS_STRING((PyStringObject *)repr), size) < 0)

goto finally;

if ((*self->write_func)(self, "\n", 1) < 0)

goto finally;

res = 0;

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;

double f;

long fhi, flo;

char str[9], *p = str;

*p = BINFLOAT;

p++;

if (x < 0) {

s = 1;

x = -x;

}

else

s = 0;

f = frexp(x, &e);

/* Normalize f to be in the range [1.0, 2.0) */

if (0.5 <= f && f < 1.0) {

f *= 2.0;

e--;

}

else if (f == 0.0) {

e = 0;

}

else {

PyErr_SetString(PyExc_SystemError,

"frexp() result out of range");

return -1;

}

if (e >= 1024) {

/* XXX 1024 itself is reserved for Inf/NaN */

PyErr_SetString(PyExc_OverflowError,

"float too large to pack with d format");

return -1;

}

else if (e < -1022) {

/* Gradual underflow */

f = ldexp(f, 1022 + e);

e = 0;

}

else {

e += 1023;

f -= 1.0; /* Get rid of leading 1 */

}

/* fhi receives the high 28 bits; flo the low 24 bits (== 52 bits) */

f *= 268435456.0; /* 2**28 */

fhi = (long) floor(f); /* Truncate */

f -= (double)fhi;

f *= 16777216.0; /* 2**24 */

flo = (long) floor(f + 0.5); /* Round */

/* First byte */

*p = (s<<7) | (e>>4);

p++;

/* Second byte */

*p = ((e&0xF)<<4) | (fhi>>24);

p++;

/* Third byte */

*p = (fhi>>16) & 0xFF;

p++;

/* Fourth byte */

*p = (fhi>>8) & 0xFF;

p++;

/* Fifth byte */

*p = fhi & 0xFF;

p++;

/* Sixth byte */

*p = (flo>>16) & 0xFF;

p++;

/* Seventh byte */

*p = (flo>>8) & 0xFF;

p++;

/* Eighth byte */

*p = flo & 0xFF;

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);

if ((*self->write_func)(self, c_str, strlen(c_str)) < 0)

return -1;

}

return 0;

}

static int

save_string(Picklerobject *self, PyObject *args, int doput) {

int size, len;

size = PyString_Size(args);

if (!self->bin) {

PyObject *repr;

char *repr_str;

static char string = STRING;

UNLESS(repr = PyObject_Repr(args))

return -1;

repr_str = PyString_AS_STRING((PyStringObject *)repr);

len = PyString_Size(repr);

if ((*self->write_func)(self, &string, 1) < 0)

return -1;

if ((*self->write_func)(self, repr_str, len) < 0)

return -1;

if ((*self->write_func)(self, "\n", 1) < 0)

return -1;

Py_XDECREF(repr);

}

else {

int i;

char c_str[5];

size = PyString_Size(args);

if (size < 256) {

c_str[0] = SHORT_BINSTRING;

c_str[1] = size;

len = 2;

}

else {

c_str[0] = BINSTRING;

for (i = 1; i < 5; i++)

c_str[i] = (int)(size >> ((i - 1) * 8));

len = 5;

}

if ((*self->write_func)(self, c_str, len) < 0)

return -1;

if ((*self->write_func)(self,

PyString_AS_STRING((PyStringObject *)args), size) < 0)

return -1;

}

if (doput)

if (put(self, args) < 0)

return -1;

return 0;

}

static int

save_tuple(Picklerobject *self, PyObject *args) {