1 #include "Python.h"

     2 #include "cStringIO.h"

     3 #include "structmember.h"

     4 

     5 PyDoc_STRVAR(cPickle_module_documentation,

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

     7 

     8 #ifndef Py_eval_input

     9 #include <graminit.h>

    10 #define Py_eval_input eval_input

    11 #endif /* Py_eval_input */

    12 

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

    14 

    15 #define WRITE_BUF_SIZE 256

    16 

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

    18 #define HIGHEST_PROTOCOL 2

    19 

    20 /*

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

    22  * docs are in pickletools.py.

    23  */

    24 #define MARK        '('

    25 #define STOP        '.'

    26 #define POP         '0'

    27 #define POP_MARK    '1'

    28 #define DUP         '2'

    29 #define FLOAT       'F'

    30 #define BINFLOAT    'G'

    31 #define INT         'I'

    32 #define BININT      'J'

    33 #define BININT1     'K'

    34 #define LONG        'L'

    35 #define BININT2     'M'

    36 #define NONE        'N'

    37 #define PERSID      'P'

    38 #define BINPERSID   'Q'

    39 #define REDUCE      'R'

    40 #define STRING      'S'

    41 #define BINSTRING   'T'

    42 #define SHORT_BINSTRING 'U'

    43 #define UNICODE     'V'

    44 #define BINUNICODE  'X'

    45 #define APPEND      'a'

    46 #define BUILD       'b'

    47 #define GLOBAL      'c'

    48 #define DICT        'd'

    49 #define EMPTY_DICT  '}'

    50 #define APPENDS     'e'

    51 #define GET         'g'

    52 #define BINGET      'h'

    53 #define INST        'i'

    54 #define LONG_BINGET 'j'

    55 #define LIST        'l'

    56 #define EMPTY_LIST  ']'

    57 #define OBJ         'o'

    58 #define PUT         'p'

    59 #define BINPUT      'q'

    60 #define LONG_BINPUT 'r'

    61 #define SETITEM     's'

    62 #define TUPLE       't'

    63 #define EMPTY_TUPLE ')'

    64 #define SETITEMS    'u'

    65 

    66 /* Protocol 2. */

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

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

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

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

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

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

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

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

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

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

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

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

    79 

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

    81  * so that unpicklers written before bools were introduced unpickle them

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

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

    84  */

    85 #undef TRUE

    86 #define TRUE        "I01\n"

    87 #undef FALSE

    88 #define FALSE       "I00\n"

    89 

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

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

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

    93  * would help anything either.

    94  */

    95 #define BATCHSIZE 1000

    96 

    97 static char MARKv = MARK;

    98 

    99 static PyObject *PickleError;

   100 static PyObject *PicklingError;

   101 static PyObject *UnpickleableError;

   102 static PyObject *UnpicklingError;

   103 static PyObject *BadPickleGet;

   104 

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

   106 static PyObject *empty_tuple;

   107 

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

   109 static PyObject *dispatch_table;

   110 

   111 /* For EXT[124] opcodes. */

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

   113 static PyObject *extension_registry;

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

   115 static PyObject *inverted_registry;

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

   117 static PyObject *extension_cache;

   118 

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

   120 static PyObject *two_tuple;

   121 

   122 static PyObject *__class___str, *__getinitargs___str, *__dict___str,

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

   124   *__reduce_ex___str,

   125   *write_str, *append_str,

   126   *read_str, *readline_str, *__main___str, 

   127   *copyreg_str, *dispatch_table_str;

   128 

   129 /*************************************************************************

   130  Internal Data type for pickle data.                                     */

   131 

   132 typedef struct {

   133 	PyObject_HEAD

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

   135 	int size;	/* number of slots in data allocated */

   136 	PyObject **data;

   137 } Pdata;

   138 

   139 static void

   140 Pdata_dealloc(Pdata *self)

   141 {

   142 	int i;

   143 	PyObject **p;

   144 

   145 	for (i = self->length, p = self->data; --i >= 0; p++) {

   146 		Py_DECREF(*p);

   147 	}

   148 	if (self->data)

   149 		free(self->data);

   150 	PyObject_Del(self);

   151 }

   152 

   153 static PyTypeObject PdataType = {

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

   155 	(destructor)Pdata_dealloc,

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

   157 };

   158 

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

   160 

   161 static PyObject *

   162 Pdata_New(void)

   163 {

   164 	Pdata *self;

   165 

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

   167 		return NULL;

   168 	self->size = 8;

   169 	self->length = 0;

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

   171 	if (self->data)

   172 		return (PyObject*)self;

   173 	Py_DECREF(self);

   174 	return PyErr_NoMemory();

   175 }

   176 

   177 static int

   178 stackUnderflow(void)

   179 {

   180 	PyErr_SetString(UnpicklingError, "unpickling stack underflow");

   181 	return -1;

   182 }

   183 

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

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

   186  */

   187 static int

   188 Pdata_clear(Pdata *self, int clearto)

   189 {

   190 	int i;

   191 	PyObject **p;

   192 

   193 	if (clearto < 0) return stackUnderflow();

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

   195 

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

   197 	     --i >= clearto;

   198 	     p++) {

   199 		Py_CLEAR(*p);

   200 	}

   201 	self->length = clearto;

   202 

   203 	return 0;

   204 }

   205 

   206 static int

   207 Pdata_grow(Pdata *self)

   208 {

   209 	int bigger;

   210 	size_t nbytes;

   211 	PyObject **tmp;

   212 

   213 	bigger = self->size << 1;

   214 	if (bigger <= 0)	/* was 0, or new value overflows */

   215 		goto nomemory;

   216 	if ((int)(size_t)bigger != bigger)

   217 		goto nomemory;

   218 	nbytes = (size_t)bigger * sizeof(PyObject *);

   219 	if (nbytes / sizeof(PyObject *) != (size_t)bigger)

   220 		goto nomemory;

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

   222 	if (tmp == NULL)

   223 		goto nomemory;

   224 	self->data = tmp;

   225 	self->size = bigger;

   226 	return 0;

   227 

   228   nomemory:

   229 	PyErr_NoMemory();

   230 	return -1;

   231 }

   232 

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

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

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

   236  */

   237 #define PDATA_POP(D, V) {					\

   238 	if ((D)->length)					\

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

   240 	else {							\

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

   242 		(V) = NULL;					\

   243 	}							\

   244 }

   245 

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

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

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

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

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

   251  * _APPEND pushes a new reference.

   252  */

   253 

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

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

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

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

   258 		Py_DECREF(O);					\

   259 		return ER;					\

   260 	}							\

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

   262 }

   263 

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

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

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

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

   268 		return ER;					\

   269 	Py_INCREF(O);						\

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

   271 }

   272 

   273 

   274 static PyObject *

   275 Pdata_popTuple(Pdata *self, int start)

   276 {

   277 	PyObject *r;

   278 	int i, j, l;

   279 

   280 	l = self->length-start;

   281 	r = PyTuple_New(l);

   282 	if (r == NULL)

   283 		return NULL;

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

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

   286 

   287 	self->length = start;

   288 	return r;

   289 }

   290 

   291 static PyObject *

   292 Pdata_popList(Pdata *self, int start)

   293 {

   294 	PyObject *r;

   295 	int i, j, l;

   296 

   297 	l=self->length-start;

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

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

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

   301 

   302 	self->length=start;

   303 	return r;

   304 }

   305 

   306 /*************************************************************************/

   307 

   308 #define ARG_TUP(self, o) {                          \

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

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

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

   312   }                                                 \

   313   else {                                            \

   314       Py_DECREF(o);                                 \

   315   }                                                 \

   316 }

   317 

   318 #define FREE_ARG_TUP(self) {                        \

   319     if (Py_REFCNT(self->arg) > 1) {                 \

   320       Py_DECREF(self->arg);                         \

   321       self->arg=NULL;                               \

   322     }                                               \

   323   }

   324 

   325 typedef struct Picklerobject {

   326 	PyObject_HEAD

   327 	FILE *fp;

   328 	PyObject *write;

   329 	PyObject *file;

   330 	PyObject *memo;

   331 	PyObject *arg;

   332 	PyObject *pers_func;

   333 	PyObject *inst_pers_func;

   334 

   335 	/* pickle protocol number, >= 0 */

   336 	int proto;

   337 

   338 	/* bool, true if proto > 0 */

   339 	int bin;

   340 

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

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

   343 	char *write_buf;

   344 	int buf_size;

   345 	PyObject *dispatch_table;

   346 	int fast_container; /* count nested container dumps */

   347 	PyObject *fast_memo;

   348 } Picklerobject;

   349 

   350 #ifndef PY_CPICKLE_FAST_LIMIT

   351 #define PY_CPICKLE_FAST_LIMIT 50

   352 #endif

   353 

   354 static PyTypeObject Picklertype;

   355 

   356 typedef struct Unpicklerobject {

   357 	PyObject_HEAD

   358 	FILE *fp;

   359 	PyObject *file;

   360 	PyObject *readline;

   361 	PyObject *read;

   362 	PyObject *memo;

   363 	PyObject *arg;

   364 	Pdata *stack;

   365 	PyObject *mark;

   366 	PyObject *pers_func;

   367 	PyObject *last_string;

   368 	int *marks;

   369 	int num_marks;

   370 	int marks_size;

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

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

   373 	int buf_size;

   374 	char *buf;

   375 	PyObject *find_class;

   376 } Unpicklerobject;

   377 

   378 static PyTypeObject Unpicklertype;

   379 

   380 /* Forward decls that need the above structs */

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

   382 static int put2(Picklerobject *, PyObject *);

   383 

   384 static

   385 PyObject *

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

   387 {

   388 	va_list va;

   389 	PyObject *args=0, *retval=0;

   390 	va_start(va, format);

   391 

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

   393 	va_end(va);

   394 	if (format && ! args) return NULL;

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

   396 		return NULL;

   397 

   398 	if (retval) {

   399 		if (args) {

   400 			PyObject *v;

   401 			v=PyString_Format(retval, args);

   402 			Py_DECREF(retval);

   403 			Py_DECREF(args);

   404 			if (! v) return NULL;

   405 			retval=v;

   406 		}

   407 	}

   408 	else

   409 		if (args) retval=args;

   410 		else {

   411 			PyErr_SetObject(ErrType,Py_None);

   412 			return NULL;

   413 		}

   414 	PyErr_SetObject(ErrType,retval);

   415 	Py_DECREF(retval);

   416 	return NULL;

   417 }

   418 

   419 static int

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

   421 {

   422 	size_t nbyteswritten;

   423 

   424 	if (s == NULL) {

   425 		return 0;

   426 	}

   427 

   428 	if (n > INT_MAX) {

   429 		/* String too large */

   430 		return -1;

   431 	}

   432 

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

   434 	Py_BEGIN_ALLOW_THREADS

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

   436 	Py_END_ALLOW_THREADS

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

   438 	if (nbyteswritten != (size_t)n) {

   439 		PyErr_SetFromErrno(PyExc_IOError);

   440 		return -1;

   441 	}

   442 

   443 	return (int)n;

   444 }

   445 

   446 static int

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

   448 {

   449 	if (s == NULL) {

   450 		return 0;

   451 	}

   452 

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

   454 		return -1;

   455 	}

   456 

   457 	return (int)n;

   458 }

   459 

   460 static int

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

   462 {

   463 	if (s == NULL) return 0;

   464 	if (n > INT_MAX) return -1;

   465 	return (int)n;

   466 }

   467 

   468 static int

   469 write_other(Picklerobject *self, const char *s, Py_ssize_t  _n)

   470 {

   471 	PyObject *py_str = 0, *junk = 0;

   472 	int n;

   473 

   474 	if (_n > INT_MAX)

   475 		return -1;

   476 	n = (int)_n;

   477 	if (s == NULL) {

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

   479 		py_str = PyString_FromStringAndSize(self->write_buf,

   480 						    self->buf_size);

   481 		if (!py_str)

   482 			return -1;

   483 	}

   484 	else {

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

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

   487 				return -1;

   488 		}

   489 

   490 		if (n > WRITE_BUF_SIZE) {

   491 			if (!( py_str =

   492 			       PyString_FromStringAndSize(s, n)))

   493 				return -1;

   494 		}

   495 		else {

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

   497 			self->buf_size += n;

   498 			return n;

   499 		}

   500 	}

   501 

   502 	if (self->write) {

   503 		/* object with write method */

   504 		ARG_TUP(self, py_str);

   505 		if (self->arg) {

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

   507 			FREE_ARG_TUP(self);

   508 		}

   509 		if (junk) Py_DECREF(junk);

   510 		else return -1;

   511 	}

   512 	else

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

   514 

   515 	self->buf_size = 0;

   516 	return n;

   517 }

   518 

   519 

   520 static Py_ssize_t

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

   522 {

   523 	size_t nbytesread;

   524 

   525 	if (self->buf_size == 0) {

   526 		int size;

   527 

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

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

   530 			PyErr_NoMemory();

   531 			return -1;

   532 		}

   533 

   534 		self->buf_size = size;

   535 	}

   536 	else if (n > self->buf_size) {

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

   538 		if (!newbuf)  {

   539 			PyErr_NoMemory();

   540 			return -1;

   541 		}

   542 		self->buf = newbuf;

   543 		self->buf_size = n;

   544 	}

   545 

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

   547 	Py_BEGIN_ALLOW_THREADS

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

   549 	Py_END_ALLOW_THREADS

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

   551 	if (nbytesread != (size_t)n) {

   552 		if (feof(self->fp)) {

   553 			PyErr_SetNone(PyExc_EOFError);

   554 			return -1;

   555 		}

   556 

   557 		PyErr_SetFromErrno(PyExc_IOError);

   558 		return -1;

   559 	}

   560 

   561 	*s = self->buf;

   562 

   563 	return n;

   564 }

   565 

   566 

   567 static Py_ssize_t

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

   569 {

   570 	int i;

   571 

   572 	if (self->buf_size == 0) {

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

   574 			PyErr_NoMemory();

   575 			return -1;

   576 		}

   577 		self->buf_size = 40;

   578 	}

   579 

   580 	i = 0;

   581 	while (1) {

   582 		int bigger;

   583 		char *newbuf;

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

   585 			if (feof(self->fp) ||

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

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

   588 				*s = self->buf;

   589 				return i + 1;

   590 			}

   591 		}

   592 		bigger = self->buf_size << 1;

   593 		if (bigger <= 0) {	/* overflow */

   594 			PyErr_NoMemory();

   595 			return -1;

   596 		}

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

   598 		if (!newbuf)  {

   599 			PyErr_NoMemory();

   600 			return -1;

   601 		}

   602 		self->buf = newbuf;

   603 		self->buf_size = bigger;

   604 	}

   605 }

   606 

   607 

   608 static Py_ssize_t

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

   610 {

   611 	char *ptr;

   612 

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

   614 		PyErr_SetNone(PyExc_EOFError);

   615 		return -1;

   616 	}

   617 

   618 	*s = ptr;

   619 

   620 	return n;

   621 }

   622 

   623 

   624 static Py_ssize_t

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

   626 {

   627 	Py_ssize_t n;

   628 	char *ptr;

   629 

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

   631 		return -1;

   632 	}

   633 

   634 	*s = ptr;

   635 

   636 	return n;

   637 }

   638 

   639 

   640 static Py_ssize_t

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

   642 {

   643 	PyObject *bytes, *str=0;

   644 

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

   646 

   647 	ARG_TUP(self, bytes);

   648 	if (self->arg) {

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

   650 		FREE_ARG_TUP(self);

   651 	}

   652 	if (! str) return -1;

   653 

   654 	Py_XDECREF(self->last_string);

   655 	self->last_string = str;

   656 

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

   658 	return n;

   659 }

   660 

   661 

   662 static Py_ssize_t

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

   664 {

   665 	PyObject *str;

   666 	Py_ssize_t str_size;

   667 

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

   669 		return -1;

   670 	}

   671 

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

   673 		return -1;

   674 

   675 	Py_XDECREF(self->last_string);

   676 	self->last_string = str;

   677 

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

   679 		return -1;

   680 

   681 	return str_size;

   682 }

   683 

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

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

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

   687  */

   688 static char *

   689 pystrndup(const char *s, int n)

   690 {

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

   692 	if (r == NULL)

   693 		return (char*)PyErr_NoMemory();

   694 	memcpy(r, s, n);

   695 	r[n] = 0;

   696 	return r;

   697 }

   698 

   699 

   700 static int

   701 get(Picklerobject *self, PyObject *id)

   702 {

   703 	PyObject *value, *mv;

   704 	long c_value;

   705 	char s[30];

   706 	size_t len;

   707 

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

   709 		PyErr_SetObject(PyExc_KeyError, id);

   710 		return -1;

   711 	}

   712 

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

   714 		return -1;

   715 

   716 	if (!( PyInt_Check(value)))  {

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

   718 		return -1;

   719 	}

   720 	c_value = PyInt_AS_LONG((PyIntObject*)value);

   721 

   722 	if (!self->bin) {

   723 		s[0] = GET;

   724 		PyOS_snprintf(s + 1, sizeof(s) - 1, "%ld\n", c_value);

   725 		len = strlen(s);

   726 	}

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

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

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

   730 		return 0;

   731 	}

   732 	else {

   733 		if (c_value < 256) {

   734 			s[0] = BINGET;

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

   736 			len = 2;

   737 		}

   738 		else {

   739 			s[0] = LONG_BINGET;

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

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

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

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

   744 			len = 5;

   745 		}

   746 	}

   747 

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

   749 		return -1;

   750 

   751 	return 0;

   752 }

   753 

   754 

   755 static int

   756 put(Picklerobject *self, PyObject *ob)

   757 {

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

   759 		return 0;

   760 

   761 	return put2(self, ob);

   762 }

   763 

   764 

   765 static int

   766 put2(Picklerobject *self, PyObject *ob)

   767 {

   768 	char c_str[30];

   769 	int p;

   770 	size_t len;

   771 	int res = -1;

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

   773 

   774 	if (self->fast)

   775 		return 0;

   776 

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

   778 		goto finally;

   779 

   780 	/* Make sure memo keys are positive! */

   781 	/* XXX Why?

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

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

   784 	 * XXX gratuitous differences between the pickling modules.

   785 	 */

   786 	p++;

   787 

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

   789 		goto finally;

   790 

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

   792 		goto finally;

   793 

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

   795 		goto finally;

   796 

   797 	PyTuple_SET_ITEM(t, 0, memo_len);

   798 	Py_INCREF(memo_len);

   799 	PyTuple_SET_ITEM(t, 1, ob);

   800 	Py_INCREF(ob);

   801 

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

   803 		goto finally;

   804 

   805 	if (!self->bin) {

   806 		c_str[0] = PUT;

   807 		PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%d\n", p);

   808 		len = strlen(c_str);

   809 	}

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

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

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

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

   814 		goto finally;

   815 	}

   816 	else {

   817 		if (p >= 256) {

   818 			c_str[0] = LONG_BINPUT;

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

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

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

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

   823 			len = 5;

   824 		}

   825 		else {

   826 			c_str[0] = BINPUT;

   827 			c_str[1] = p;

   828 			len = 2;

   829 		}

   830 	}

   831 

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

   833 		goto finally;

   834 

   835 	res = 0;

   836 

   837   finally:

   838 	Py_XDECREF(py_ob_id);

   839 	Py_XDECREF(memo_len);

   840 	Py_XDECREF(t);

   841 

   842 	return res;

   843 }

   844 

   845 static PyObject *

   846 whichmodule(PyObject *global, PyObject *global_name)

   847 {

   848 	Py_ssize_t i, j;

   849 	PyObject *module = 0, *modules_dict = 0,

   850 		*global_name_attr = 0, *name = 0;

   851 

   852 	module = PyObject_GetAttrString(global, "__module__");

   853 	if (module) 

   854 		return module;

   855 	if (PyErr_ExceptionMatches(PyExc_AttributeError))

   856 		PyErr_Clear();

   857 	else

   858 		return NULL;

   859 

   860 	if (!( modules_dict = PySys_GetObject("modules")))

   861 		return NULL;

   862 

   863 	i = 0;

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

   865 

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

   867 

   868 		global_name_attr = PyObject_GetAttr(module, global_name);

   869 		if (!global_name_attr)  {

   870 			if (PyErr_ExceptionMatches(PyExc_AttributeError))

   871 				PyErr_Clear();

   872 			else

   873 				return NULL;

   874 			continue;

   875 		}

   876 

   877 		if (global_name_attr != global) {

   878 			Py_DECREF(global_name_attr);

   879 			continue;

   880 		}

   881 

   882 		Py_DECREF(global_name_attr);

   883 

   884 		break;

   885 	}

   886 

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

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

   889 	   like this rule. jlf

   890 	*/

   891 	if (!j) {

   892 		j=1;

   893 		name=__main___str;

   894 	}

   895 

   896 	Py_INCREF(name);

   897 	return name;

   898 }

   899 

   900 

   901 static int

   902 fast_save_enter(Picklerobject *self, PyObject *obj)

   903 {

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

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

   906 		PyObject *key = NULL;

   907 		if (self->fast_memo == NULL) {

   908 			self->fast_memo = PyDict_New();

   909 			if (self->fast_memo == NULL) {

   910 				self->fast_container = -1;

   911 				return 0;

   912 			}

   913 		}

   914 		key = PyLong_FromVoidPtr(obj);

   915 		if (key == NULL)

   916 			return 0;

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

   918 			Py_DECREF(key);

   919 			PyErr_Format(PyExc_ValueError,

   920 				     "fast mode: can't pickle cyclic objects "

   921 				     "including object type %s at %p",

   922 				     Py_TYPE(obj)->tp_name, obj);

   923 			self->fast_container = -1;

   924 			return 0;

   925 		}

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

   927 			Py_DECREF(key);

   928 			self->fast_container = -1;

   929 			return 0;

   930 		}

   931 		Py_DECREF(key);

   932 	}

   933 	return 1;

   934 }

   935 

   936 int

   937 fast_save_leave(Picklerobject *self, PyObject *obj)

   938 {

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

   940 		PyObject *key = PyLong_FromVoidPtr(obj);

   941 		if (key == NULL)

   942 			return 0;

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

   944 			Py_DECREF(key);

   945 			return 0;

   946 		}

   947 		Py_DECREF(key);

   948 	}

   949 	return 1;

   950 }

   951 

   952 static int

   953 save_none(Picklerobject *self, PyObject *args)

   954 {

   955 	static char none = NONE;

   956 	if (self->write_func(self, &none, 1) < 0)

   957 		return -1;

   958 

   959 	return 0;

   960 }

   961 

   962 static int

   963 save_bool(Picklerobject *self, PyObject *args)

   964 {

   965 	static const char *buf[2] = {FALSE, TRUE};

   966 	static char len[2] = {sizeof(FALSE)-1, sizeof(TRUE)-1};

   967 	long l = PyInt_AS_LONG((PyIntObject *)args);

   968 

   969 	if (self->proto >= 2) {

   970 		char opcode = l ? NEWTRUE : NEWFALSE;

   971 		if (self->write_func(self, &opcode, 1) < 0)

   972 			return -1;

   973 	}

   974 	else if (self->write_func(self, buf[l], len[l]) < 0)

   975 		return -1;

   976 	return 0;

   977 }

   978 

   979 static int

   980 save_int(Picklerobject *self, PyObject *args)

   981 {

   982 	char c_str[32];

   983 	long l = PyInt_AS_LONG((PyIntObject *)args);

   984 	int len = 0;

   985 

   986 	if (!self->bin

   987 #if SIZEOF_LONG > 4

   988 	    || l >  0x7fffffffL

   989 	    || l < -0x80000000L

   990 #endif

   991 		) {

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

   993 		 * signed BININT format:  store as a string.

   994 		 */

   995 		c_str[0] = INT;

   996 		PyOS_snprintf(c_str + 1, sizeof(c_str) - 1, "%ld\n", l);

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

   998 			return -1;

   999 	}

  1000 	else {

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

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

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

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

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

  1006 

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

  1008 			if (c_str[2] == 0) {

  1009 				c_str[0] = BININT1;

  1010 				len = 2;

  1011 			}

  1012 			else {

  1013 				c_str[0] = BININT2;

  1014 				len = 3;

  1015 			}

  1016 		}

  1017 		else {

  1018 			c_str[0] = BININT;

  1019 			len = 5;

  1020 		}

  1021 

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

  1023 			return -1;

  1024 	}

  1025 

  1026 	return 0;

  1027 }

  1028 

  1029 

  1030 static int

  1031 save_long(Picklerobject *self, PyObject *args)

  1032 {

  1033 	Py_ssize_t size;

  1034 	int res = -1;

  1035 	PyObject *repr = NULL;

  1036 

  1037 	static char l = LONG;

  1038 

  1039 	if (self->proto >= 2) {

  1040 		/* Linear-time pickling. */

  1041 		size_t nbits;

  1042 		size_t nbytes;

  1043 		unsigned char *pdata;

  1044 		char c_str[5];

  1045 		int i;

  1046 		int sign = _PyLong_Sign(args);

  1047 

  1048 		if (sign == 0) {

  1049 			/* It's 0 -- an empty bytestring. */

  1050 			c_str[0] = LONG1;

  1051 			c_str[1] = 0;

  1052 			i = self->write_func(self, c_str, 2);

  1053 			if (i < 0) goto finally;

  1054 			res = 0;

  1055 			goto finally;

  1056 		}

  1057 		nbits = _PyLong_NumBits(args);

  1058 		if (nbits == (size_t)-1 && PyErr_Occurred())

  1059 			goto finally;

  1060 		/* How many bytes do we need?  There are nbits >> 3 full

  1061 		 * bytes of data, and nbits & 7 leftover bits.  If there

  1062 		 * are any leftover bits, then we clearly need another

  1063 		 * byte.  Wnat's not so obvious is that we *probably*

  1064 		 * need another byte even if there aren't any leftovers:

  1065 		 * the most-significant bit of the most-significant byte

  1066 		 * acts like a sign bit, and it's usually got a sense

  1067 		 * opposite of the one we need.  The exception is longs

  1068 		 * of the form -(2**(8*j-1)) for j > 0.  Such a long is

  1069 		 * its own 256's-complement, so has the right sign bit

  1070 		 * even without the extra byte.  That's a pain to check

  1071 		 * for in advance, though, so we always grab an extra

  1072 		 * byte at the start, and cut it back later if possible.

  1073 		 */

  1074 		nbytes = (nbits >> 3) + 1;

  1075 		if (nbytes > INT_MAX) {

  1076 			PyErr_SetString(PyExc_OverflowError, "long too large "

  1077 				"to pickle");

  1078 			goto finally;

  1079 		}

  1080 		repr = PyString_FromStringAndSize(NULL, (int)nbytes);

  1081 		if (repr == NULL) goto finally;

  1082 		pdata = (unsigned char *)PyString_AS_STRING(repr);

  1083 		i = _PyLong_AsByteArray((PyLongObject *)args,

  1084 	 			pdata, nbytes,

  1085 				1 /* little endian */, 1 /* signed */);

  1086 		if (i < 0) goto finally;

  1087 		/* If the long is negative, this may be a byte more than

  1088 		 * needed.  This is so iff the MSB is all redundant sign

  1089 		 * bits.

  1090 		 */

  1091 		if (sign < 0 && nbytes > 1 && pdata[nbytes - 1] == 0xff &&

  1092 		    (pdata[nbytes - 2] & 0x80) != 0)

  1093 			--nbytes;

  1094 

  1095 		if (nbytes < 256) {

  1096 			c_str[0] = LONG1;

  1097 			c_str[1] = (char)nbytes;

  1098 			size = 2;

  1099 		}

  1100 		else {

  1101 			c_str[0] = LONG4;

  1102 			size = (int)nbytes;

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

  1104 				c_str[i] = (char)(size & 0xff);

  1105 				size >>= 8;

  1106 			}

  1107 			size = 5;

  1108 		}

  1109 		i = self->write_func(self, c_str, size);

  1110 		if (i < 0) goto finally;

  1111 		i = self->write_func(self, (char *)pdata, (int)nbytes);

  1112 		if (i < 0) goto finally;

  1113 		res = 0;

  1114 		goto finally;

  1115 	}

  1116 

  1117 	/* proto < 2:  write the repr and newline.  This is quadratic-time

  1118 	 * (in the number of digits), in both directions.

  1119 	 */

  1120 	if (!( repr = PyObject_Repr(args)))

  1121 		goto finally;

  1122 

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

  1124 		goto finally;

  1125 

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

  1127 		goto finally;

  1128 

  1129 	if (self->write_func(self,

  1130 			     PyString_AS_STRING((PyStringObject *)repr),

  1131 			     			size) < 0)

  1132 		goto finally;

  1133 

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

  1135 		goto finally;