#include "Python.h"

#include "cStringIO.h"

#include "structmember.h"

PyDoc_STRVAR(cPickle_module_documentation,

"C implementation and optimization of the Python pickle module.");

#ifndef Py_eval_input

#include <graminit.h>

#define Py_eval_input eval_input

#endif /* Py_eval_input */

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

#define WRITE_BUF_SIZE 256

/* Bump this when new opcodes are added to the pickle protocol. */

#define HIGHEST_PROTOCOL 2

/*

* Note: The UNICODE macro controls the TCHAR meaning of the win32 API. Since

* all headers have already been included here, we can safely redefine it.

*/

#ifdef UNICODE

# undef UNICODE

#endif

/*

* Pickle opcodes. These must be kept in synch with pickle.py. Extensive

* docs are in pickletools.py.

*/

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

/* Protocol 2. */

#define PROTO '\x80' /* identify pickle protocol */

#define NEWOBJ '\x81' /* build object by applying cls.__new__ to argtuple */

#define EXT1 '\x82' /* push object from extension registry; 1-byte index */

#define EXT2 '\x83' /* ditto, but 2-byte index */

#define EXT4 '\x84' /* ditto, but 4-byte index */

#define TUPLE1 '\x85' /* build 1-tuple from stack top */

#define TUPLE2 '\x86' /* build 2-tuple from two topmost stack items */

#define TUPLE3 '\x87' /* build 3-tuple from three topmost stack items */

#define NEWTRUE '\x88' /* push True */

#define NEWFALSE '\x89' /* push False */

#define LONG1 '\x8a' /* push long from < 256 bytes */

#define LONG4 '\x8b' /* push really big long */

/* There aren't opcodes -- they're ways to pickle bools before protocol 2,

* so that unpicklers written before bools were introduced unpickle them

* as ints, but unpicklers after can recognize that bools were intended.

* Note that protocol 2 added direct ways to pickle bools.

*/

#undef TRUE

#define TRUE "I01\n"

#undef FALSE

#define FALSE "I00\n"

/* Keep in synch with pickle.Pickler._BATCHSIZE. This is how many elements

* batch_list/dict() pumps out before doing APPENDS/SETITEMS. Nothing will

* break if this gets out of synch with pickle.py, but it's unclear that

* would help anything either.

*/

#define BATCHSIZE 1000

static char MARKv = MARK;

static PyObject *PickleError;

static PyObject *PicklingError;

static PyObject *UnpickleableError;

static PyObject *UnpicklingError;

static PyObject *BadPickleGet;

/* As the name says, an empty tuple. */

static PyObject *empty_tuple;

/* copy_reg.dispatch_table, {type_object: pickling_function} */

static PyObject *dispatch_table;

/* For EXT[124] opcodes. */

/* copy_reg._extension_registry, {(module_name, function_name): code} */

static PyObject *extension_registry;

/* copy_reg._inverted_registry, {code: (module_name, function_name)} */

static PyObject *inverted_registry;

/* copy_reg._extension_cache, {code: object} */

static PyObject *extension_cache;

/* For looking up name pairs in copy_reg._extension_registry. */

static PyObject *two_tuple;

static PyObject *__class___str, *__getinitargs___str, *__dict___str,

*__getstate___str, *__setstate___str, *__name___str, *__reduce___str,

*__reduce_ex___str,

*write_str, *append_str,

*read_str, *readline_str, *__main___str,

*dispatch_table_str;

/*************************************************************************

Internal Data type for pickle data. */

typedef struct {

PyObject_HEAD

Py_ssize_t length; /* number of initial slots in data currently used */

Py_ssize_t size; /* number of slots in data allocated */

PyObject **data;

} Pdata;

static void

Pdata_dealloc(Pdata *self)

{

Py_ssize_t 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 = {

PyVarObject_HEAD_INIT(NULL, 0) "cPickle.Pdata", sizeof(Pdata), 0,

(destructor)Pdata_dealloc,

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

};

#define Pdata_Check(O) (Py_TYPE(O) == &PdataType)

static PyObject *

Pdata_New(void)

{

Pdata *self;

if (!(self = PyObject_New(Pdata, &PdataType)))

return NULL;

self->size = 8;

self->length = 0;

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

if (self->data)

return (PyObject*)self;

Py_DECREF(self);

return PyErr_NoMemory();

}

static int

stackUnderflow(void)

{

PyErr_SetString(UnpicklingError, "unpickling stack underflow");

return -1;

}

/* Retain only the initial clearto items. If clearto >= the current

* number of items, this is a (non-erroneous) NOP.

*/

static int

Pdata_clear(Pdata *self, Py_ssize_t clearto)

{

Py_ssize_t 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_CLEAR(*p);

}

self->length = clearto;

return 0;

}

static int

Pdata_grow(Pdata *self)

{

Py_ssize_t bigger;

Py_ssize_t nbytes;

PyObject **tmp;

if (self->size > (PY_SSIZE_T_MAX >> 1))

goto nomemory;

bigger = self->size << 1;

if (bigger > (PY_SSIZE_T_MAX / sizeof(PyObject *)))

goto nomemory;

nbytes = bigger * sizeof(PyObject *);

tmp = realloc(self->data, nbytes);

if (tmp == NULL)

goto nomemory;

self->data = tmp;

self->size = bigger;

return 0;

nomemory:

PyErr_NoMemory();

return -1;

}

/* D is a Pdata*. Pop the topmost element and store it into V, which

* must be an lvalue holding PyObject*. On stack underflow, UnpicklingError

* is raised and V is set to NULL. D and V may be evaluated several times.

*/

#define PDATA_POP(D, V) { \

if ((D)->length) \

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

else { \

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

(V) = NULL; \

} \

}

/* PDATA_PUSH and PDATA_APPEND both push rvalue PyObject* O on to Pdata*

* D. If the Pdata stack can't be grown to hold the new value, both

* raise MemoryError and execute "return ER". The difference is in ownership

* of O after: _PUSH transfers ownership of O from the caller to the stack

* (no incref of O is done, and in case of error O is decrefed), while

* _APPEND pushes a new reference.

*/

/* Push O on stack D, giving ownership of O to the stack. */

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

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

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

Py_DECREF(O); \

return ER; \

} \

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

}

/* Push O on stack D, pushing a new reference. */

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

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

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

return ER; \

Py_INCREF(O); \

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

}

static PyObject *

Pdata_popTuple(Pdata *self, Py_ssize_t start)

{

PyObject *r;

Py_ssize_t i, j, l;

l = self->length-start;

r = PyTuple_New(l);

if (r == NULL)

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, Py_ssize_t start)

{

PyObject *r;

Py_ssize_t i, j, l;

l=self->length-start;

if (!( r=PyList_New(l))) return NULL;

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

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

self->length=start;

return r;

}

/*************************************************************************/

#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 (Py_REFCNT(self->arg) > 1) { \

Py_CLEAR(self->arg); \

} \

}

typedef struct Picklerobject {

PyObject_HEAD

FILE *fp;

PyObject *write;

PyObject *file;

PyObject *memo;

PyObject *arg;

PyObject *pers_func;

PyObject *inst_pers_func;

/* pickle protocol number, >= 0 */

int proto;

/* bool, true if proto > 0 */

int bin;

int fast; /* Fast mode doesn't save in memo, don't use if circ ref */

Py_ssize_t (*write_func)(struct Picklerobject *, const char *, Py_ssize_t);

char *write_buf;

Py_ssize_t buf_size;

PyObject *dispatch_table;

int fast_container; /* count nested container dumps */

PyObject *fast_memo;

} Picklerobject;

#ifndef PY_CPICKLE_FAST_LIMIT

#define PY_CPICKLE_FAST_LIMIT 50

#endif

static PyTypeObject Picklertype;

typedef struct Unpicklerobject {

PyObject_HEAD

FILE *fp;

PyObject *file;

PyObject *readline;

PyObject *read;

PyObject *memo;

PyObject *arg;

Pdata *stack;

PyObject *mark;

PyObject *pers_func;

PyObject *last_string;

Py_ssize_t *marks;

Py_ssize_t num_marks;

Py_ssize_t marks_size;

Py_ssize_t (*read_func)(struct Unpicklerobject *, char **, Py_ssize_t);

Py_ssize_t (*readline_func)(struct Unpicklerobject *, char **);

Py_ssize_t buf_size;

char *buf;

PyObject *find_class;

} Unpicklerobject;

static PyTypeObject Unpicklertype;

/* Forward decls that need the above structs */

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

static int put2(Picklerobject *, PyObject *);

static

PyObject *

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

{

va_list va;

PyObject *args=0, *retval=0;

va_start(va, format);

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

va_end(va);

if (format && ! args) return NULL;

if (stringformat && !(retval=PyString_FromString(stringformat)))

return NULL;

if (retval) {

if (args) {

PyObject *v;

v=PyString_Format(retval, args);

Py_DECREF(retval);

Py_DECREF(args);

if (! v) return NULL;

retval=v;

}

}

else

if (args) retval=args;

else {

PyErr_SetObject(ErrType,Py_None);

return NULL;

}

PyErr_SetObject(ErrType,retval);

Py_DECREF(retval);

return NULL;

}

static Py_ssize_t

write_file(Picklerobject *self, const char *s, Py_ssize_t n)

{

size_t nbyteswritten;

if (s == NULL) {

return 0;

}

PyFile_IncUseCount((PyFileObject *)self->file);

Py_BEGIN_ALLOW_THREADS

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

Py_END_ALLOW_THREADS

PyFile_DecUseCount((PyFileObject *)self->file);

if (nbyteswritten != (size_t)n) {

PyErr_SetFromErrno(PyExc_IOError);

return -1;

}

return n;

}

static Py_ssize_t

write_cStringIO(Picklerobject *self, const char *s, Py_ssize_t n)

{

Py_ssize_t len = n;

if (s == NULL) {

return 0;

}

while (n > INT_MAX) {

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

return -1;

}

n -= INT_MAX;

}

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

return -1;

}

return len;

}

static Py_ssize_t

write_none(Picklerobject *self, const char *s, Py_ssize_t n)

{

if (s == NULL) return 0;

return n;

}

static Py_ssize_t

write_other(Picklerobject *self, const char *s, Py_ssize_t n)

{

PyObject *py_str = 0, *junk = 0;

if (s == NULL) {

if (!( self->buf_size )) return 0;

py_str = PyString_FromStringAndSize(self->write_buf,

self->buf_size);

if (!py_str)

return -1;

}

else {

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

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

return -1;

}

if (n > WRITE_BUF_SIZE) {

if (!( py_str =

PyString_FromStringAndSize(s, n)))

return -1;

}

else {

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

self->buf_size += n;

return n;

}

}

if (self->write) {

/* object with write method */

ARG_TUP(self, py_str);

if (self->arg) {

junk = PyObject_Call(self->write, self->arg, NULL);

FREE_ARG_TUP(self);

}

if (junk) Py_DECREF(junk);

else return -1;

}

else

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

self->buf_size = 0;

return n;

}

static Py_ssize_t

read_file(Unpicklerobject *self, char **s, Py_ssize_t n)

{

size_t nbytesread;

if (self->buf_size == 0) {

Py_ssize_t size;

size = ((n < 32) ? 32 : n);

if (!( self->buf = (char *)malloc(size))) {

PyErr_NoMemory();

return -1;

}

self->buf_size = size;

}

else if (n > self->buf_size) {

char *newbuf = (char *)realloc(self->buf, n);

if (!newbuf) {

PyErr_NoMemory();

return -1;

}

self->buf = newbuf;

self->buf_size = n;

}

PyFile_IncUseCount((PyFileObject *)self->file);

Py_BEGIN_ALLOW_THREADS

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

Py_END_ALLOW_THREADS

PyFile_DecUseCount((PyFileObject *)self->file);

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 Py_ssize_t

readline_file(Unpicklerobject *self, char **s)

{

Py_ssize_t i;

if (self->buf_size == 0) {

if (!( self->buf = (char *)malloc(40))) {

PyErr_NoMemory();

return -1;

}

self->buf_size = 40;

}

i = 0;

while (1) {

Py_ssize_t bigger;

char *newbuf;

for (; i < (self->buf_size - 1); i++) {

if (feof(self->fp) ||

(self->buf[i] = getc(self->fp)) == '\n') {

self->buf[i + 1] = '\0';

*s = self->buf;

return i + 1;

}

}

if (self->buf_size > (PY_SSIZE_T_MAX >> 1)) {

PyErr_NoMemory();

return -1;

}

bigger = self->buf_size << 1;

newbuf = (char *)realloc(self->buf, bigger);

if (newbuf == NULL) {

PyErr_NoMemory();

return -1;

}

self->buf = newbuf;

self->buf_size = bigger;

}

}

static Py_ssize_t

read_cStringIO(Unpicklerobject *self, char **s, Py_ssize_t n)

{

Py_ssize_t len = n;

char *start, *end = NULL;

while (1) {

int k;

char *ptr;

if (n > INT_MAX)

k = INT_MAX;

else

k = (int)n;

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

PyErr_SetNone(PyExc_EOFError);

return -1;

}

if (end == NULL)

start = ptr;

else if (ptr != end) {

/* non-continuous area */

return -1;

}

if (n <= INT_MAX)

break;

end = ptr + INT_MAX;

n -= INT_MAX;

}

*s = start;

return len;

}

static Py_ssize_t

readline_cStringIO(Unpicklerobject *self, char **s)

{

Py_ssize_t n = 0;

char *start = NULL, *end = NULL;

while (1) {

int k;

char *ptr;

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

return -1;

}

n += k;

if (end == NULL)

start = ptr;

else if (ptr != end) {

/* non-continuous area */

return -1;

}

if (k == 0 || ptr[k - 1] == '\n')

break;

end = ptr + k;

}

*s = start;

return n;

}

static Py_ssize_t

read_other(Unpicklerobject *self, char **s, Py_ssize_t n)

{

PyObject *bytes, *str=0;

if (!( bytes = PyInt_FromSsize_t(n))) return -1;

ARG_TUP(self, bytes);

if (self->arg) {

str = PyObject_Call(self->read, self->arg, NULL);

FREE_ARG_TUP(self);

}

if (! str) return -1;

Py_XSETREF(self->last_string, str);

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

if (PyString_GET_SIZE(str) != n) {

PyErr_SetNone(PyExc_EOFError);

return -1;

}

return n;

}

static Py_ssize_t

readline_other(Unpicklerobject *self, char **s)

{

PyObject *str;

Py_ssize_t str_size;

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

return -1;

}

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

return -1;

Py_XSETREF(self->last_string, str);

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

return -1;

return str_size;

}

/* Copy the first n bytes from s into newly malloc'ed memory, plus a

* trailing 0 byte. Return a pointer to that, or NULL if out of memory.

* The caller is responsible for free()'ing the return value.

*/

static char *

pystrndup(const char *s, Py_ssize_t n)

{

char *r = (char *)malloc(n+1);

if (r == NULL)

return (char*)PyErr_NoMemory();

memcpy(r, s, n);

r[n] = 0;

return r;

}

static int

get(Picklerobject *self, PyObject *id)

{

PyObject *value, *mv;

Py_ssize_t c_value;

char s[30];

size_t len;

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

PyErr_SetObject(PyExc_KeyError, id);

return -1;

}

if (!( value = PyTuple_GetItem(mv, 0)))

return -1;

if (!( PyInt_Check(value))) {

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

return -1;

}

c_value = PyInt_AS_LONG((PyIntObject*)value);

if (!self->bin) {

s[0] = GET;

PyOS_snprintf(s + 1, sizeof(s) - 1,

"%" PY_FORMAT_SIZE_T "d\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 if (c_value < 0x7fffffffL) {

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;

}

else { /* unlikely */

PyErr_SetString(PicklingError,

"memo id too large for LONG_BINGET");

return -1;

}

}

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

return -1;

return 0;

}

static int

put(Picklerobject *self, PyObject *ob)

{

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

return 0;

return put2(self, ob);

}

static int

put2(Picklerobject *self, PyObject *ob)

{

char c_str[30];

Py_ssize_t len, p;

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;

/* Make sure memo keys are positive! */

/* XXX Why?

* XXX And does "positive" really mean non-negative?

* XXX pickle.py starts with PUT index 0, not 1. This makes for

* XXX gratuitous differences between the pickling modules.

*/

p++;

if (!( py_ob_id = PyLong_FromVoidPtr(ob)))

goto finally;

if (!( memo_len = PyInt_FromLong(p)))

goto finally;

if (!( t = PyTuple_New(2)))

goto finally;

PyTuple_SET_ITEM(t, 0, memo_len);

Py_INCREF(memo_len);

PyTuple_SET_ITEM(t, 1, ob);

Py_INCREF(ob);

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

goto finally;

if (!self->bin) {

c_str[0] = PUT;

PyOS_snprintf(c_str + 1, sizeof(c_str) - 1,

"%" PY_FORMAT_SIZE_T "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] = BINPUT;

c_str[1] = p;

len = 2;

}

else if (p < 0x7fffffffL) {

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 { /* unlikely */

PyErr_SetString(PicklingError,

"memo id too large for LONG_BINPUT");

goto finally;

}

}

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;

}

static PyObject *

whichmodule(PyObject *global, PyObject *global_name)

{

Py_ssize_t i, j;

PyObject *module = 0, *modules_dict = 0,

*global_name_attr = 0, *name = 0;

module = PyObject_GetAttrString(global, "__module__");

if (module)

return module;

if (PyErr_ExceptionMatches(PyExc_AttributeError))

PyErr_Clear();

else

return NULL;

if (!( 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;

global_name_attr = PyObject_GetAttr(module, global_name);

if (!global_name_attr) {

if (PyErr_ExceptionMatches(PyExc_AttributeError))

PyErr_Clear();

else

return NULL;

continue;

}

if (global_name_attr != global) {

Py_DECREF(global_name_attr);

continue;

}

Py_DECREF(global_name_attr);

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

name=__main___str;

}

Py_INCREF(name);

return name;

}

static int

fast_save_enter(Picklerobject *self, PyObject *obj)

{

/* if fast_container < 0, we're doing an error exit. */

if (++self->fast_container >= PY_CPICKLE_FAST_LIMIT) {

PyObject *key = NULL;

if (self->fast_memo == NULL) {

self->fast_memo = PyDict_New();

if (self->fast_memo == NULL) {

self->fast_container = -1;

return 0;

}

}

key = PyLong_FromVoidPtr(obj);

if (key == NULL)

return 0;

if (PyDict_GetItem(self->fast_memo, key)) {

Py_DECREF(key);

PyErr_Format(PyExc_ValueError,

"fast mode: can't pickle cyclic objects "

"including object type %s at %p",

Py_TYPE(obj)->tp_name, obj);

self->fast_container = -1;

return 0;

}

if (PyDict_SetItem(self->fast_memo, key, Py_None) < 0) {

Py_DECREF(key);

self->fast_container = -1;

return 0;

}

Py_DECREF(key);

}

return 1;

}

int

fast_save_leave(Picklerobject *self, PyObject *obj)

{

if (self->fast_container-- >= PY_CPICKLE_FAST_LIMIT) {

PyObject *key = PyLong_FromVoidPtr(obj);

if (key == NULL)

return 0;

if (PyDict_DelItem(self->fast_memo, key) < 0) {

Py_DECREF(key);

return 0;

}

Py_DECREF(key);

}