static char cPickle_module_documentation[] =

;

#include "Python.h"

#include "cStringIO.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 UNICODE 'V'

#define BINUNICODE 'X'

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

static PyObject *atol_func;

static PyObject *PickleError;

static PyObject *PicklingError;

static PyObject *UnpickleableError;

static PyObject *UnpicklingError;

static PyObject *BadPickleGet;

static PyObject *dispatch_table;

static PyObject *safe_constructors;

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

*copy_reg_str, *dispatch_table_str, *safe_constructors_str, *empty_str;

#ifndef PyList_SET_ITEM

#define PyList_SET_ITEM(op, i, v) (((PyListObject *)(op))->ob_item[i] = (v))

#ifndef PyList_GET_SIZE

#define PyList_GET_SIZE(op) (((PyListObject *)(op))->ob_size)

#ifndef PyTuple_SET_ITEM

#define PyTuple_SET_ITEM(op, i, v) (((PyTupleObject *)(op))->ob_item[i] = (v))

#ifndef PyTuple_GET_SIZE

#define PyTuple_GET_SIZE(op) (((PyTupleObject *)(op))->ob_size)

#ifndef PyString_GET_SIZE

#define PyString_GET_SIZE(op) (((PyStringObject *)(op))->ob_size)

typedef struct {

PyObject_HEAD

int length, size;

PyObject **data;

} Pdata;

static void

Pdata_dealloc(Pdata *self) {

int i;

PyObject **p;

for (i=self->length, p=self->data; --i >= 0; p++) Py_DECREF(*p);

if (self->data) free(self->data);

PyObject_Del(self);

}

static PyTypeObject PdataType = {

PyObject_HEAD_INIT(NULL) 0, "Pdata", sizeof(Pdata), 0,

(destructor)Pdata_dealloc,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0L,0L,0L,0L, ""

};

#define Pdata_Check(O) ((O)->ob_type == &PdataType)

static PyObject *

Pdata_New(void) {

Pdata *self;

UNLESS (self = PyObject_New(Pdata, &PdataType)) return NULL;

self->size=8;

self->length=0;

self->data=malloc(self->size * sizeof(PyObject*));

if (self->data) return (PyObject*)self;

Py_DECREF(self);

return PyErr_NoMemory();

}

static int

stackUnderflow(void) {

PyErr_SetString(UnpicklingError, "unpickling stack underflow");

return -1;

}

static int

Pdata_clear(Pdata *self, int clearto) {

int i;

PyObject **p;

if (clearto < 0) return stackUnderflow();

if (clearto >= self->length) return 0;

for (i=self->length, p=self->data+clearto; --i >= clearto; p++)

Py_DECREF(*p);

self->length=clearto;

return 0;

}

static int

Pdata_grow(Pdata *self) {

if (! self->size) {

PyErr_NoMemory();

return -1;

}

self->size *= 2;

self->data = realloc(self->data, self->size*sizeof(PyObject*));

if (! self->data) {

self->size = 0;

PyErr_NoMemory();

return -1;

}

return 0;

}

#define PDATA_POP(D,V) { \

if ((D)->length) V=D->data[--((D)->length)]; \

else { \

PyErr_SetString(UnpicklingError, "bad pickle data"); \

V=NULL; \

} \

}

static PyObject *

Pdata_popTuple(Pdata *self, int start) {

PyObject *r;

int i, j, l;

l=self->length-start;

UNLESS (r=PyTuple_New(l)) return NULL;

for (i=start, j=0 ; j < l; i++, j++)

PyTuple_SET_ITEM(r, j, self->data[i]);

self->length=start;

return r;

}

static PyObject *

Pdata_popList(Pdata *self, int start) {

PyObject *r;

int i, j, l;

l=self->length-start;

UNLESS (r=PyList_New(l)) return NULL;

for (i=start, j=0 ; j < l; i++, j++)

PyList_SET_ITEM(r, j, self->data[i]);

self->length=start;

return r;

}

#define PDATA_APPEND_(D,O,ER) { \

if (Pdata_Append(((Pdata*)(D)), O) < 0) return ER; \

}

#define PDATA_APPEND(D,O,ER) { \

if (((Pdata*)(D))->length == ((Pdata*)(D))->size && \

Pdata_grow((Pdata*)(D)) < 0) \

return ER; \

Py_INCREF(O); \

((Pdata*)(D))->data[((Pdata*)(D))->length++]=O; \

}

#define PDATA_PUSH(D,O,ER) { \

if (((Pdata*)(D))->length == ((Pdata*)(D))->size && \

Pdata_grow((Pdata*)(D)) < 0) { \

Py_DECREF(O); \

return ER; \

} \

((Pdata*)(D))->data[((Pdata*)(D))->length++]=O; \

}

#define ARG_TUP(self, o) { \

if (self->arg || (self->arg=PyTuple_New(1))) { \

Py_XDECREF(PyTuple_GET_ITEM(self->arg,0)); \

PyTuple_SET_ITEM(self->arg,0,o); \

} \

else { \

Py_DECREF(o); \

} \

}

#define FREE_ARG_TUP(self) { \

if (self->arg->ob_refcnt > 1) { \

Py_DECREF(self->arg); \

self->arg=NULL; \

} \

}

typedef struct Picklerobject {

} Picklerobject;

staticforward PyTypeObject Picklertype;

typedef struct Unpicklerobject {

} Unpicklerobject;

staticforward PyTypeObject Unpicklertype;

static int save(Picklerobject *, PyObject *, int);

static int put2(Picklerobject *, PyObject *);

cPickle_PyMapping_HasKey(PyObject *o, PyObject *key) {

PyObject *v;

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

Py_DECREF(v);

return 1;

}

PyErr_Clear();

return 0;

}

PyObject *

cPickle_ErrFormat(PyObject *ErrType, char *stringformat, char *format, ...)

{

va_list va;

PyObject *args=0, *retval=0;

va_start(va, format);

if (format) args = Py_VaBuildValue(format, va);

va_end(va);

if (format && ! args) return NULL;

if (stringformat && !(retval=PyString_FromString(stringformat))) return NULL;

if (retval) {

if (args) {

PyObject *v;

v=PyString_Format(retval, args);

Py_DECREF(retval);

Py_DECREF(args);

if (! v) return NULL;

retval=v;

}

}

else

if (args) retval=args;

else {

PyErr_SetObject(ErrType,Py_None);

return NULL;

}

PyErr_SetObject(ErrType,retval);

Py_DECREF(retval);

return NULL;

}

static int

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

size_t nbyteswritten;

if (s == NULL) {

return 0;

}

Py_BEGIN_ALLOW_THREADS

nbyteswritten = fwrite(s, sizeof(char), n, self->fp);

Py_END_ALLOW_THREADS

if (nbyteswritten != (size_t)n) {

PyErr_SetFromErrno(PyExc_IOError);

return -1;

}

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;

if (s == NULL) {

UNLESS (self->buf_size) return 0;

UNLESS (py_str =

PyString_FromStringAndSize(self->write_buf, self->buf_size))

return -1;

}

else {

if (self->buf_size && (n + self->buf_size) > WRITE_BUF_SIZE) {

if (write_other(self, NULL, 0) < 0)

return -1;

}

if (n > WRITE_BUF_SIZE) {

UNLESS (py_str =

PyString_FromStringAndSize(s, n))

return -1;

}

else {

memcpy(self->write_buf + self->buf_size, s, n);

self->buf_size += n;

return n;

}

}

if (self->write) {

/* object with write method */

ARG_TUP(self, py_str);

if (self->arg) {

junk = PyObject_CallObject(self->write, self->arg);

FREE_ARG_TUP(self);

}

if (junk) Py_DECREF(junk);

else return -1;

}

else

PDATA_PUSH(self->file, py_str, -1);

self->buf_size = 0;

return n;

}

static int

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

size_t nbytesread;

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;

}

Py_BEGIN_ALLOW_THREADS

nbytesread = fread(self->buf, sizeof(char), n, self->fp);

Py_END_ALLOW_THREADS

if (nbytesread != (size_t)n) {

if (feof(self->fp)) {

PyErr_SetNone(PyExc_EOFError);

return -1;

}

PyErr_SetFromErrno(PyExc_IOError);

return -1;

}

*s = self->buf;

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=0;

UNLESS (bytes = PyInt_FromLong(n)) return -1;

ARG_TUP(self, bytes);

if (self->arg) {

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

FREE_ARG_TUP(self);

}

if (! str) return -1;

Py_XDECREF(self->last_string);

self->last_string = str;

if (! (*s = PyString_AsString(str))) return -1;

return n;

}

static int

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

PyObject *str;

int str_size;

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

return -1;

}

if ((str_size = PyString_Size(str)) < 0)

return -1;

Py_XDECREF(self->last_string);

self->last_string = str;

if (! (*s = PyString_AsString(str)))

return -1;

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, *mv;

long c_value;

char s[30];

size_t len;

UNLESS (mv = PyDict_GetItem(self->memo, id)) {

PyErr_SetObject(PyExc_KeyError, id);

return -1;

}

UNLESS (value = PyTuple_GetItem(mv, 0))

return -1;

UNLESS (PyInt_Check(value)) {

PyErr_SetString(PicklingError, "no int where int expected in memo");

return -1;

}

c_value = PyInt_AS_LONG((PyIntObject*)value);

if (!self->bin) {

s[0] = GET;

sprintf(s + 1, "%ld\n", c_value);

len = strlen(s);

}

else if (Pdata_Check(self->file)) {

if (write_other(self, NULL, 0) < 0) return -1;

PDATA_APPEND(self->file, mv, -1);

return 0;

}

else {

if (c_value < 256) {

s[0] = BINGET;

s[1] = (int)(c_value & 0xff);

len = 2;

}

else {

s[0] = LONG_BINGET;

s[1] = (int)(c_value & 0xff);

s[2] = (int)((c_value >> 8) & 0xff);

s[3] = (int)((c_value >> 16) & 0xff);

s[4] = (int)((c_value >> 24) & 0xff);

len = 5;

}

}

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

return -1;

return 0;

}

static int

put(Picklerobject *self, PyObject *ob) {

if (ob->ob_refcnt < 2 || self->fast)

return 0;

return put2(self, ob);

}

static int

put2(Picklerobject *self, PyObject *ob) {

char c_str[30];

int p;

size_t len;

int res = -1;

PyObject *py_ob_id = 0, *memo_len = 0, *t = 0;

if (self->fast) return 0;

if ((p = PyDict_Size(self->memo)) < 0)

goto finally;

p++; /* Make sure memo keys are positive! */

UNLESS (py_ob_id = PyLong_FromVoidPtr(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;

if (!self->bin) {

c_str[0] = PUT;

sprintf(c_str + 1, "%d\n", p);

len = strlen(c_str);

}

else if (Pdata_Check(self->file)) {

if (write_other(self, NULL, 0) < 0) return -1;

PDATA_APPEND(self->file, memo_len, -1);

res=0; /* Job well done ;) */

goto finally;

}

else {

if (p >= 256) {

c_str[0] = LONG_BINPUT;

c_str[1] = (int)(p & 0xff);

c_str[2] = (int)((p >> 8) & 0xff);

c_str[3] = (int)((p >> 16) & 0xff);

c_str[4] = (int)((p >> 24) & 0xff);

len = 5;

}

else {

c_str[0] = BINPUT;

c_str[1] = p;

len = 2;

}

}

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

goto finally;

res = 0;

finally:

Py_XDECREF(py_ob_id);

Py_XDECREF(memo_len);

Py_XDECREF(t);

return res;

}

#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 *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();

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

if (!j) {

j=1;

name=__main___str;

}

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 > 0x7fffffffL

|| l < -0x80000000L

) {

/* Text-mode pickle, or long too big to fit in the 4-byte

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 {

/* Binary pickle and l fits in a signed 4-byte int. */

c_str[1] = (int)( l & 0xff);

c_str[2] = (int)((l >> 8) & 0xff);

c_str[3] = (int)((l >> 16) & 0xff);

c_str[4] = (int)((l >> 24) & 0xff);

if ((c_str[4] == 0) && (c_str[3] == 0)) {

if (c_str[2] == 0) {

c_str[0] = BININT1;

len = 2;

}

else {

c_str[0] = BININT2;

len = 3;

}

}

else {

c_str[0] = BININT;

len = 5;

}

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

return -1;

}

return 0;

}

static int

save_long(Picklerobject *self, PyObject *args) {

int size, res = -1;

PyObject *repr = 0;

static char l = LONG;

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

if (self->bin) {

int s, e;