Back to index

python3.2  3.2.2
Classes | Defines | Typedefs | Enumerations | Functions | Variables
_pickle.c File Reference
#include "Python.h"
#include "structmember.h"

Go to the source code of this file.

Classes

struct  Pdata
struct  PyMemoEntry
struct  PyMemoTable
struct  PicklerObject
struct  UnpicklerObject
struct  PicklerMemoProxyObject
struct  UnpicklerMemoProxyObject

Defines

#define TRUE   "I01\n"
#define FALSE   "I00\n"
#define PDATA_POP(D, V)   do { (V) = Pdata_pop((D)); } while (0)
#define PDATA_PUSH(D, O, ER)
#define PDATA_APPEND(D, O, ER)
#define MT_MINSIZE   8
#define PERTURB_SHIFT   5
#define ARG_TUP(self, obj)
#define FREE_ARG_TUP(self)
#define OP(opcode, load_func)   case opcode: if (load_func(self) < 0) break; continue;
#define OP_ARG(opcode, load_func, arg)   case opcode: if (load_func(self, (arg)) < 0) break; continue;

Typedefs

typedef struct PicklerObject PicklerObject
typedef struct UnpicklerObject UnpicklerObject

Enumerations

enum  { HIGHEST_PROTOCOL = 3, DEFAULT_PROTOCOL = 3 }
enum  opcode {
  MARK = '(', STOP = '.', POP = '0', POP_MARK = '1',
  DUP = '2', FLOAT = 'F', INT = 'I', BININT = 'J',
  BININT1 = 'K', LONG = 'L', BININT2 = 'M', NONE = 'N',
  PERSID = 'P', BINPERSID = 'Q', REDUCE = 'R', STRING = 'S',
  BINSTRING = 'T', SHORT_BINSTRING = 'U', UNICODE = 'V', BINUNICODE = 'X',
  APPEND = 'a', BUILD = 'b', GLOBAL = 'c', DICT = 'd',
  EMPTY_DICT = '}', APPENDS = 'e', GET = 'g', BINGET = 'h',
  INST = 'i', LONG_BINGET = 'j', LIST = 'l', EMPTY_LIST = ']',
  OBJ = 'o', PUT = 'p', BINPUT = 'q', LONG_BINPUT = 'r',
  SETITEM = 's', TUPLE = 't', EMPTY_TUPLE = ')', SETITEMS = 'u',
  BINFLOAT = 'G', PROTO = '\x80', NEWOBJ = '\x81', EXT1 = '\x82',
  EXT2 = '\x83', EXT4 = '\x84', TUPLE1 = '\x85', TUPLE2 = '\x86',
  TUPLE3 = '\x87', NEWTRUE = '\x88', NEWFALSE = '\x89', LONG1 = '\x8a',
  LONG4 = '\x8b', BINBYTES = 'B', SHORT_BINBYTES = 'C'
}
enum  {
  BATCHSIZE = 1000, FAST_NESTING_LIMIT = 50, WRITE_BUF_SIZE = 4096, MAX_WRITE_BUF_SIZE = 64 * 1024,
  PREFETCH = 8192 * 16
}

Functions

 PyDoc_STRVAR (pickle_module_doc,"Optimized C implementation for the Python pickle module.")
static int stack_underflow (void)
static void Pdata_dealloc (Pdata *self)
static PyObjectPdata_New (void)
static int Pdata_clear (Pdata *self, int clearto)
static int Pdata_grow (Pdata *self)
static PyObjectPdata_pop (Pdata *self)
static int Pdata_push (Pdata *self, PyObject *obj)
static PyObjectPdata_poptuple (Pdata *self, Py_ssize_t start)
static PyObjectPdata_poplist (Pdata *self, Py_ssize_t start)
static int save (PicklerObject *, PyObject *, int)
static int save_reduce (PicklerObject *, PyObject *, PyObject *)
static PyMemoTablePyMemoTable_New (void)
static PyMemoTablePyMemoTable_Copy (PyMemoTable *self)
static Py_ssize_t PyMemoTable_Size (PyMemoTable *self)
static int PyMemoTable_Clear (PyMemoTable *self)
static void PyMemoTable_Del (PyMemoTable *self)
static PyMemoEntry_PyMemoTable_Lookup (PyMemoTable *self, PyObject *key)
static int _PyMemoTable_ResizeTable (PyMemoTable *self, Py_ssize_t min_size)
static longPyMemoTable_Get (PyMemoTable *self, PyObject *key)
static int PyMemoTable_Set (PyMemoTable *self, PyObject *key, long value)
static PyObject_Pickler_FastCall (PicklerObject *self, PyObject *func, PyObject *arg)
static int _Pickler_ClearBuffer (PicklerObject *self)
static PyObject_Pickler_GetString (PicklerObject *self)
static int _Pickler_FlushToFile (PicklerObject *self)
static int _Pickler_Write (PicklerObject *self, const char *s, Py_ssize_t n)
static PicklerObject_Pickler_New (void)
static int _Pickler_SetProtocol (PicklerObject *self, PyObject *proto_obj, PyObject *fix_imports_obj)
static int _Pickler_SetOutputStream (PicklerObject *self, PyObject *file)
static PyObject_Unpickler_FastCall (UnpicklerObject *self, PyObject *func, PyObject *arg)
static Py_ssize_t _Unpickler_SetStringInput (UnpicklerObject *self, PyObject *input)
static int _Unpickler_SkipConsumed (UnpicklerObject *self)
static Py_ssize_t _Unpickler_ReadFromFile (UnpicklerObject *self, Py_ssize_t n)
static Py_ssize_t _Unpickler_Read (UnpicklerObject *self, char **s, Py_ssize_t n)
static Py_ssize_t _Unpickler_CopyLine (UnpicklerObject *self, char *line, Py_ssize_t len, char **result)
static Py_ssize_t _Unpickler_Readline (UnpicklerObject *self, char **result)
static int _Unpickler_ResizeMemoList (UnpicklerObject *self, Py_ssize_t new_size)
static PyObject_Unpickler_MemoGet (UnpicklerObject *self, Py_ssize_t idx)
static int _Unpickler_MemoPut (UnpicklerObject *self, Py_ssize_t idx, PyObject *value)
static PyObject ** _Unpickler_NewMemo (Py_ssize_t new_size)
static void _Unpickler_MemoCleanup (UnpicklerObject *self)
static UnpicklerObject_Unpickler_New (void)
static int _Unpickler_SetInputStream (UnpicklerObject *self, PyObject *file)
static int _Unpickler_SetInputEncoding (UnpicklerObject *self, const char *encoding, const char *errors)
static int memo_get (PicklerObject *self, PyObject *key)
static int memo_put (PicklerObject *self, PyObject *obj)
static PyObjectwhichmodule (PyObject *global, PyObject *global_name)
static int fast_save_enter (PicklerObject *self, PyObject *obj)
static int fast_save_leave (PicklerObject *self, PyObject *obj)
static int save_none (PicklerObject *self, PyObject *obj)
static int save_bool (PicklerObject *self, PyObject *obj)
static int save_int (PicklerObject *self, long x)
static int save_long (PicklerObject *self, PyObject *obj)
static int save_float (PicklerObject *self, PyObject *obj)
static int save_bytes (PicklerObject *self, PyObject *obj)
static PyObjectraw_unicode_escape (const Py_UNICODE *s, Py_ssize_t size)
static int save_unicode (PicklerObject *self, PyObject *obj)
static int store_tuple_elements (PicklerObject *self, PyObject *t, int len)
static int save_tuple (PicklerObject *self, PyObject *obj)
static int batch_list (PicklerObject *self, PyObject *iter)
static int batch_list_exact (PicklerObject *self, PyObject *obj)
static int save_list (PicklerObject *self, PyObject *obj)
static int batch_dict (PicklerObject *self, PyObject *iter)
static int batch_dict_exact (PicklerObject *self, PyObject *obj)
static int save_dict (PicklerObject *self, PyObject *obj)
static int save_global (PicklerObject *self, PyObject *obj, PyObject *name)
static int save_pers (PicklerObject *self, PyObject *obj, PyObject *func)
static int dump (PicklerObject *self, PyObject *obj)
 PyDoc_STRVAR (Pickler_clear_memo_doc,"clear_memo() -> None. Clears the pickler's \"memo\".""\n""The memo is the data structure that remembers which objects the\n""pickler has already seen, so that shared or recursive objects are\n""pickled by reference and not by value. This method is useful when\n""re-using picklers.")
static PyObjectPickler_clear_memo (PicklerObject *self)
 PyDoc_STRVAR (Pickler_dump_doc,"dump(obj) -> None. Write a pickled representation of obj to the open file.")
static PyObjectPickler_dump (PicklerObject *self, PyObject *args)
static void Pickler_dealloc (PicklerObject *self)
static int Pickler_traverse (PicklerObject *self, visitproc visit, void *arg)
static int Pickler_clear (PicklerObject *self)
 PyDoc_STRVAR (Pickler_doc,"Pickler(file, protocol=None)""\n""This takes a binary file for writing a pickle data stream.\n""\n""The optional protocol argument tells the pickler to use the\n""given protocol; supported protocols are 0, 1, 2, 3. The default\n""protocol is 3; a backward-incompatible protocol designed for\n""Python 3.0.\n""\n""Specifying a negative protocol version selects the highest\n""protocol version supported. The higher the protocol used, the\n""more recent the version of Python needed to read the pickle\n""produced.\n""\n""The file argument must have a write() method that accepts a single\n""bytes argument. It can thus be a file object opened for binary\n""writing, a io.BytesIO instance, or any other custom object that\n""meets this interface.\n""\n""If fix_imports is True and protocol is less than 3, pickle will try to\n""map the new Python 3.x names to the old module names used in Python\n""2.x, so that the pickle data stream is readable with Python 2.x.\n")
static int Pickler_init (PicklerObject *self, PyObject *args, PyObject *kwds)
 PyDoc_STRVAR (pmp_clear_doc,"memo.clear() -> None. Remove all items from memo.")
static PyObjectpmp_clear (PicklerMemoProxyObject *self)
 PyDoc_STRVAR (pmp_copy_doc,"memo.copy() -> new_memo. Copy the memo to a new object.")
static PyObjectpmp_copy (PicklerMemoProxyObject *self)
 PyDoc_STRVAR (pmp_reduce_doc,"memo.__reduce__(). Pickling support.")
static PyObjectpmp_reduce (PicklerMemoProxyObject *self, PyObject *args)
static void PicklerMemoProxy_dealloc (PicklerMemoProxyObject *self)
static int PicklerMemoProxy_traverse (PicklerMemoProxyObject *self, visitproc visit, void *arg)
static int PicklerMemoProxy_clear (PicklerMemoProxyObject *self)
static PyObjectPicklerMemoProxy_New (PicklerObject *pickler)
static PyObjectPickler_get_memo (PicklerObject *self)
static int Pickler_set_memo (PicklerObject *self, PyObject *obj)
static PyObjectPickler_get_persid (PicklerObject *self)
static int Pickler_set_persid (PicklerObject *self, PyObject *value)
static PyObjectfind_class (UnpicklerObject *self, PyObject *module_name, PyObject *global_name)
static int marker (UnpicklerObject *self)
static int load_none (UnpicklerObject *self)
static int bad_readline (void)
static int load_int (UnpicklerObject *self)
static int load_bool (UnpicklerObject *self, PyObject *boolean)
static long calc_binint (char *bytes, int size)
static int load_binintx (UnpicklerObject *self, char *s, int size)
static int load_binint (UnpicklerObject *self)
static int load_binint1 (UnpicklerObject *self)
static int load_binint2 (UnpicklerObject *self)
static int load_long (UnpicklerObject *self)
static int load_counted_long (UnpicklerObject *self, int size)
static int load_float (UnpicklerObject *self)
static int load_binfloat (UnpicklerObject *self)
static int load_string (UnpicklerObject *self)
static int load_binbytes (UnpicklerObject *self)
static int load_short_binbytes (UnpicklerObject *self)
static int load_binstring (UnpicklerObject *self)
static int load_short_binstring (UnpicklerObject *self)
static int load_unicode (UnpicklerObject *self)
static int load_binunicode (UnpicklerObject *self)
static int load_tuple (UnpicklerObject *self)
static int load_counted_tuple (UnpicklerObject *self, int len)
static int load_empty_list (UnpicklerObject *self)
static int load_empty_dict (UnpicklerObject *self)
static int load_list (UnpicklerObject *self)
static int load_dict (UnpicklerObject *self)
static PyObjectinstantiate (PyObject *cls, PyObject *args)
static int load_obj (UnpicklerObject *self)
static int load_inst (UnpicklerObject *self)
static int load_newobj (UnpicklerObject *self)
static int load_global (UnpicklerObject *self)
static int load_persid (UnpicklerObject *self)
static int load_binpersid (UnpicklerObject *self)
static int load_pop (UnpicklerObject *self)
static int load_pop_mark (UnpicklerObject *self)
static int load_dup (UnpicklerObject *self)
static int load_get (UnpicklerObject *self)
static int load_binget (UnpicklerObject *self)
static int load_long_binget (UnpicklerObject *self)
static int load_extension (UnpicklerObject *self, int nbytes)
static int load_put (UnpicklerObject *self)
static int load_binput (UnpicklerObject *self)
static int load_long_binput (UnpicklerObject *self)
static int do_append (UnpicklerObject *self, int x)
static int load_append (UnpicklerObject *self)
static int load_appends (UnpicklerObject *self)
static int do_setitems (UnpicklerObject *self, int x)
static int load_setitem (UnpicklerObject *self)
static int load_setitems (UnpicklerObject *self)
static int load_build (UnpicklerObject *self)
static int load_mark (UnpicklerObject *self)
static int load_reduce (UnpicklerObject *self)
static int load_proto (UnpicklerObject *self)
static PyObjectload (UnpicklerObject *self)
 PyDoc_STRVAR (Unpickler_load_doc,"load() -> object. Load a pickle.""\n""Read a pickled object representation from the open file object given in\n""the constructor, and return the reconstituted object hierarchy specified\n""therein.\n")
static PyObjectUnpickler_load (UnpicklerObject *self)
 PyDoc_STRVAR (Unpickler_find_class_doc,"find_class(module_name, global_name) -> object.\n""\n""Return an object from a specified module, importing the module if\n""necessary. Subclasses may override this method (e.g. to restrict\n""unpickling of arbitrary classes and functions).\n""\n""This method is called whenever a class or a function object is\n""needed. Both arguments passed are str objects.\n")
static PyObjectUnpickler_find_class (UnpicklerObject *self, PyObject *args)
static void Unpickler_dealloc (UnpicklerObject *self)
static int Unpickler_traverse (UnpicklerObject *self, visitproc visit, void *arg)
static int Unpickler_clear (UnpicklerObject *self)
 PyDoc_STRVAR (Unpickler_doc,"Unpickler(file, *, encoding='ASCII', errors='strict')""\n""This takes a binary file for reading a pickle data stream.\n""\n""The protocol version of the pickle is detected automatically, so no\n""proto argument is needed.\n""\n""The file-like object must have two methods, a read() method\n""that takes an integer argument, and a readline() method that\n""requires no arguments. Both methods should return bytes.\n""Thus file-like object can be a binary file object opened for\n""reading, a BytesIO object, or any other custom object that\n""meets this interface.\n""\n""Optional keyword arguments are *fix_imports*, *encoding* and *errors*,\n""which are used to control compatiblity support for pickle stream\n""generated by Python 2.x. If *fix_imports* is True, pickle will try to\n""map the old Python 2.x names to the new names used in Python 3.x. The\n""*encoding* and *errors* tell pickle how to decode 8-bit string\n""instances pickled by Python 2.x; these default to 'ASCII' and\n""'strict', respectively.\n")
static int Unpickler_init (UnpicklerObject *self, PyObject *args, PyObject *kwds)
 PyDoc_STRVAR (ump_clear_doc,"memo.clear() -> None. Remove all items from memo.")
static PyObjectump_clear (UnpicklerMemoProxyObject *self)
 PyDoc_STRVAR (ump_copy_doc,"memo.copy() -> new_memo. Copy the memo to a new object.")
static PyObjectump_copy (UnpicklerMemoProxyObject *self)
 PyDoc_STRVAR (ump_reduce_doc,"memo.__reduce__(). Pickling support.")
static PyObjectump_reduce (UnpicklerMemoProxyObject *self, PyObject *args)
static void UnpicklerMemoProxy_dealloc (UnpicklerMemoProxyObject *self)
static int UnpicklerMemoProxy_traverse (UnpicklerMemoProxyObject *self, visitproc visit, void *arg)
static int UnpicklerMemoProxy_clear (UnpicklerMemoProxyObject *self)
static PyObjectUnpicklerMemoProxy_New (UnpicklerObject *unpickler)
static PyObjectUnpickler_get_memo (UnpicklerObject *self)
static int Unpickler_set_memo (UnpicklerObject *self, PyObject *obj)
static PyObjectUnpickler_get_persload (UnpicklerObject *self)
static int Unpickler_set_persload (UnpicklerObject *self, PyObject *value)
 PyDoc_STRVAR (pickle_dump_doc,"dump(obj, file, protocol=None, *, fix_imports=True) -> None\n""\n""Write a pickled representation of obj to the open file object file. This\n""is equivalent to ``Pickler(file, protocol).dump(obj)``, but may be more\n""efficient.\n""\n""The optional protocol argument tells the pickler to use the given protocol;\n""supported protocols are 0, 1, 2, 3. The default protocol is 3; a\n""backward-incompatible protocol designed for Python 3.0.\n""\n""Specifying a negative protocol version selects the highest protocol version\n""supported. The higher the protocol used, the more recent the version of\n""Python needed to read the pickle produced.\n""\n""The file argument must have a write() method that accepts a single bytes\n""argument. It can thus be a file object opened for binary writing, a\n""io.BytesIO instance, or any other custom object that meets this interface.\n""\n""If fix_imports is True and protocol is less than 3, pickle will try to\n""map the new Python 3.x names to the old module names used in Python 2.x,\n""so that the pickle data stream is readable with Python 2.x.\n")
static PyObjectpickle_dump (PyObject *self, PyObject *args, PyObject *kwds)
 PyDoc_STRVAR (pickle_dumps_doc,"dumps(obj, protocol=None, *, fix_imports=True) -> bytes\n""\n""Return the pickled representation of the object as a bytes\n""object, instead of writing it to a file.\n""\n""The optional protocol argument tells the pickler to use the given protocol;\n""supported protocols are 0, 1, 2, 3. The default protocol is 3; a\n""backward-incompatible protocol designed for Python 3.0.\n""\n""Specifying a negative protocol version selects the highest protocol version\n""supported. The higher the protocol used, the more recent the version of\n""Python needed to read the pickle produced.\n""\n""If fix_imports is True and *protocol* is less than 3, pickle will try to\n""map the new Python 3.x names to the old module names used in Python 2.x,\n""so that the pickle data stream is readable with Python 2.x.\n")
static PyObjectpickle_dumps (PyObject *self, PyObject *args, PyObject *kwds)
 PyDoc_STRVAR (pickle_load_doc,"load(file, *, fix_imports=True, encoding='ASCII', errors='strict') -> object\n""\n""Read a pickled object representation from the open file object file and\n""return the reconstituted object hierarchy specified therein. This is\n""equivalent to ``Unpickler(file).load()``, but may be more efficient.\n""\n""The protocol version of the pickle is detected automatically, so no protocol\n""argument is needed. Bytes past the pickled object's representation are\n""ignored.\n""\n""The argument file must have two methods, a read() method that takes an\n""integer argument, and a readline() method that requires no arguments. Both\n""methods should return bytes. Thus *file* can be a binary file object opened\n""for reading, a BytesIO object, or any other custom object that meets this\n""interface.\n""\n""Optional keyword arguments are fix_imports, encoding and errors,\n""which are used to control compatiblity support for pickle stream generated\n""by Python 2.x. If fix_imports is True, pickle will try to map the old\n""Python 2.x names to the new names used in Python 3.x. The encoding and\n""errors tell pickle how to decode 8-bit string instances pickled by Python\n""2.x; these default to 'ASCII' and 'strict', respectively.\n")
static PyObjectpickle_load (PyObject *self, PyObject *args, PyObject *kwds)
 PyDoc_STRVAR (pickle_loads_doc,"loads(input, *, fix_imports=True, encoding='ASCII', errors='strict') -> object\n""\n""Read a pickled object hierarchy from a bytes object and return the\n""reconstituted object hierarchy specified therein\n""\n""The protocol version of the pickle is detected automatically, so no protocol\n""argument is needed. Bytes past the pickled object's representation are\n""ignored.\n""\n""Optional keyword arguments are fix_imports, encoding and errors, which\n""are used to control compatiblity support for pickle stream generated\n""by Python 2.x. If fix_imports is True, pickle will try to map the old\n""Python 2.x names to the new names used in Python 3.x. The encoding and\n""errors tell pickle how to decode 8-bit string instances pickled by Python\n""2.x; these default to 'ASCII' and 'strict', respectively.\n")
static PyObjectpickle_loads (PyObject *self, PyObject *args, PyObject *kwds)
static int initmodule (void)
PyMODINIT_FUNC PyInit__pickle (void)

Variables

static PyObjectPickleError = NULL
static PyObjectPicklingError = NULL
static PyObjectUnpicklingError = NULL
static PyObjectdispatch_table = NULL
static PyObjectextension_registry = NULL
static PyObjectinverted_registry = NULL
static PyObjectextension_cache = NULL
static PyObjectname_mapping_2to3 = NULL
static PyObjectimport_mapping_2to3 = NULL
static PyObjectname_mapping_3to2 = NULL
static PyObjectimport_mapping_3to2 = NULL
static PyObjectempty_tuple = NULL
static PyObjecttwo_tuple = NULL
static PyTypeObject Pdata_Type
static PyTypeObject Pickler_Type
static PyTypeObject Unpickler_Type
static const Py_ssize_t READ_WHOLE_LINE = -1
static struct PyMethodDef []
static PyMethodDef picklerproxy_methods []
static PyTypeObject PicklerMemoProxyType
static PyMemberDef Pickler_members []
static PyGetSetDef Pickler_getsets []
static PyMethodDef unpicklerproxy_methods []
static PyTypeObject UnpicklerMemoProxyType
static PyGetSetDef Unpickler_getsets []
static struct PyModuleDef

Class Documentation

struct Pdata

Definition at line 147 of file _pickle.c.

Collaboration diagram for Pdata:
Class Members
Py_ssize_t allocated
PyObject_VAR_HEAD PyObject ** data
struct PyMemoEntry

Definition at line 304 of file _pickle.c.

Collaboration diagram for PyMemoEntry:
Class Members
PyObject * me_key
long me_value
struct PyMemoTable

Definition at line 309 of file _pickle.c.

Collaboration diagram for PyMemoTable:
Class Members
Py_ssize_t mt_allocated
Py_ssize_t mt_mask
PyMemoEntry * mt_table
Py_ssize_t mt_used
struct PicklerObject

Definition at line 316 of file _pickle.c.

Collaboration diagram for PicklerObject:
Class Members
PyObject * arg
int bin
int buf_size
int fast
PyObject * fast_memo
int fast_nesting
int fix_imports
Py_ssize_t max_output_len
PyObject_HEAD PyMemoTable * memo
PyObject * output_buffer
Py_ssize_t output_len
PyObject * pers_func
int proto
PyObject * write
struct UnpicklerObject

Definition at line 344 of file _pickle.c.

Collaboration diagram for UnpicklerObject:
Class Members
PyObject * arg
Py_buffer buffer
char * encoding
char * errors
int fix_imports
char * input_buffer
Py_ssize_t input_len
char * input_line
int * marks
Py_ssize_t marks_size
PyObject ** memo
Py_ssize_t memo_size
Py_ssize_t next_read_idx
Py_ssize_t num_marks
PyObject * peek
PyObject * pers_func
Py_ssize_t prefetched_idx
int proto
PyObject * read
PyObject * readline
PyObject_HEAD Pdata * stack
struct PicklerMemoProxyObject

Definition at line 3444 of file _pickle.c.

Collaboration diagram for PicklerMemoProxyObject:
Class Members
PyObject_HEAD PicklerObject * pickler
struct UnpicklerMemoProxyObject

Definition at line 5586 of file _pickle.c.

Collaboration diagram for UnpicklerMemoProxyObject:
Class Members
PyObject_HEAD UnpicklerObject * unpickler

Define Documentation

#define ARG_TUP (   self,
  obj 
)
Value:
do {                             \
        if ((self)->arg || ((self)->arg=PyTuple_New(1))) {  \
            Py_XDECREF(PyTuple_GET_ITEM((self)->arg, 0));   \
            PyTuple_SET_ITEM((self)->arg, 0, (obj));        \
        }                                                   \
        else {                                              \
            Py_DECREF((obj));                               \
        }                                                   \
    } while (0)

Definition at line 612 of file _pickle.c.

#define FALSE   "I00\n"

Definition at line 85 of file _pickle.c.

#define FREE_ARG_TUP (   self)
Value:
do {                 \
        if ((self)->arg->ob_refcnt > 1)         \
            Py_CLEAR((self)->arg);              \
    } while (0)

Definition at line 622 of file _pickle.c.

#define MT_MINSIZE   8

Definition at line 394 of file _pickle.c.

#define OP (   opcode,
  load_func 
)    case opcode: if (load_func(self) < 0) break; continue;
#define OP_ARG (   opcode,
  load_func,
  arg 
)    case opcode: if (load_func(self, (arg)) < 0) break; continue;
#define PDATA_APPEND (   D,
  O,
  ER 
)
Value:
do {                             \
        Py_INCREF((O));                                         \
        if (Pdata_push((D), (O)) < 0) return (ER); } while(0)

Definition at line 266 of file _pickle.c.

#define PDATA_POP (   D,
 
)    do { (V) = Pdata_pop((D)); } while (0)

Definition at line 249 of file _pickle.c.

#define PDATA_PUSH (   D,
  O,
  ER 
)
Value:
do {                               \
        if (Pdata_push((D), (O)) < 0) return (ER); } while(0)

Definition at line 262 of file _pickle.c.

#define PERTURB_SHIFT   5

Definition at line 395 of file _pickle.c.

#define TRUE   "I01\n"

Definition at line 83 of file _pickle.c.


Typedef Documentation

typedef struct PicklerObject PicklerObject

Enumeration Type Documentation

anonymous enum
Enumerator:
HIGHEST_PROTOCOL 
DEFAULT_PROTOCOL 

Definition at line 8 of file _pickle.c.

anonymous enum
Enumerator:
BATCHSIZE 
FAST_NESTING_LIMIT 
WRITE_BUF_SIZE 
MAX_WRITE_BUF_SIZE 
PREFETCH 

Definition at line 87 of file _pickle.c.

     {
   /* 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. */
    BATCHSIZE = 1000,

    /* Nesting limit until Pickler, when running in "fast mode", starts
       checking for self-referential data-structures. */
    FAST_NESTING_LIMIT = 50,

    /* Initial size of the write buffer of Pickler. */
    WRITE_BUF_SIZE = 4096,

    /* Maximum size of the write buffer of Pickler when pickling to a
       stream.  This is ignored for in-memory pickling. */
    MAX_WRITE_BUF_SIZE = 64 * 1024,

    /* Prefetch size when unpickling (disabled on unpeekable streams) */
    PREFETCH = 8192 * 16
};
enum opcode
Enumerator:
MARK 
STOP 
POP 
POP_MARK 
DUP 
FLOAT 
INT 
BININT 
BININT1 
LONG 
BININT2 
NONE 
PERSID 
BINPERSID 
REDUCE 
STRING 
BINSTRING 
SHORT_BINSTRING 
UNICODE 
BINUNICODE 
APPEND 
BUILD 
GLOBAL 
DICT 
EMPTY_DICT 
APPENDS 
GET 
BINGET 
INST 
LONG_BINGET 
LIST 
EMPTY_LIST 
OBJ 
PUT 
BINPUT 
LONG_BINPUT 
SETITEM 
TUPLE 
EMPTY_TUPLE 
SETITEMS 
BINFLOAT 
PROTO 
NEWOBJ 
EXT1 
EXT2 
EXT4 
TUPLE1 
TUPLE2 
TUPLE3 
NEWTRUE 
NEWFALSE 
LONG1 
LONG4 
BINBYTES 
SHORT_BINBYTES 

Definition at line 15 of file _pickle.c.

            {
    MARK            = '(',
    STOP            = '.',
    POP             = '0',
    POP_MARK        = '1',
    DUP             = '2',
    FLOAT           = 'F',
    INT             = 'I',
    BININT          = 'J',
    BININT1         = 'K',
    LONG            = 'L',
    BININT2         = 'M',
    NONE            = 'N',
    PERSID          = 'P',
    BINPERSID       = 'Q',
    REDUCE          = 'R',
    STRING          = 'S',
    BINSTRING       = 'T',
    SHORT_BINSTRING = 'U',
    UNICODE         = 'V',
    BINUNICODE      = 'X',
    APPEND          = 'a',
    BUILD           = 'b',
    GLOBAL          = 'c',
    DICT            = 'd',
    EMPTY_DICT      = '}',
    APPENDS         = 'e',
    GET             = 'g',
    BINGET          = 'h',
    INST            = 'i',
    LONG_BINGET     = 'j',
    LIST            = 'l',
    EMPTY_LIST      = ']',
    OBJ             = 'o',
    PUT             = 'p',
    BINPUT          = 'q',
    LONG_BINPUT     = 'r',
    SETITEM         = 's',
    TUPLE           = 't',
    EMPTY_TUPLE     = ')',
    SETITEMS        = 'u',
    BINFLOAT        = 'G',

    /* Protocol 2. */
    PROTO       = '\x80',
    NEWOBJ      = '\x81',
    EXT1        = '\x82',
    EXT2        = '\x83',
    EXT4        = '\x84',
    TUPLE1      = '\x85',
    TUPLE2      = '\x86',
    TUPLE3      = '\x87',
    NEWTRUE     = '\x88',
    NEWFALSE    = '\x89',
    LONG1       = '\x8a',
    LONG4       = '\x8b',

    /* Protocol 3 (Python 3.x) */
    BINBYTES       = 'B',
    SHORT_BINBYTES = 'C'
};

Function Documentation

static int _Pickler_ClearBuffer ( PicklerObject self) [static]

Definition at line 663 of file _pickle.c.

{
    Py_CLEAR(self->output_buffer);
    self->output_buffer =
        PyBytes_FromStringAndSize(NULL, self->max_output_len);
    if (self->output_buffer == NULL)
        return -1;
    self->output_len = 0;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* _Pickler_FastCall ( PicklerObject self,
PyObject func,
PyObject arg 
) [static]

Definition at line 650 of file _pickle.c.

{
    PyObject *result = NULL;

    ARG_TUP(self, arg);
    if (self->arg) {
        result = PyObject_Call(func, self->arg, NULL);
        FREE_ARG_TUP(self);
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int _Pickler_FlushToFile ( PicklerObject self) [static]

Definition at line 688 of file _pickle.c.

{
    PyObject *output, *result;

    assert(self->write != NULL);

    output = _Pickler_GetString(self);
    if (output == NULL)
        return -1;

    result = _Pickler_FastCall(self, self->write, output);
    Py_XDECREF(result);
    return (result == NULL) ? -1 : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* _Pickler_GetString ( PicklerObject self) [static]

Definition at line 675 of file _pickle.c.

{
    PyObject *output_buffer = self->output_buffer;

    assert(self->output_buffer != NULL);
    self->output_buffer = NULL;
    /* Resize down to exact size */
    if (_PyBytes_Resize(&output_buffer, self->output_len) < 0)
        return NULL;
    return output_buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PicklerObject* _Pickler_New ( void  ) [static]

Definition at line 758 of file _pickle.c.

{
    PicklerObject *self;

    self = PyObject_GC_New(PicklerObject, &Pickler_Type);
    if (self == NULL)
        return NULL;

    self->pers_func = NULL;
    self->arg = NULL;
    self->write = NULL;
    self->proto = 0;
    self->bin = 0;
    self->fast = 0;
    self->fast_nesting = 0;
    self->fix_imports = 0;
    self->fast_memo = NULL;

    self->memo = PyMemoTable_New();
    if (self->memo == NULL) {
        Py_DECREF(self);
        return NULL;
    }
    self->max_output_len = WRITE_BUF_SIZE;
    self->output_len = 0;
    self->output_buffer = PyBytes_FromStringAndSize(NULL,
                                                    self->max_output_len);
    if (self->output_buffer == NULL) {
        Py_DECREF(self);
        return NULL;
    }
    return self;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int _Pickler_SetOutputStream ( PicklerObject self,
PyObject file 
) [static]

Definition at line 827 of file _pickle.c.

{
    assert(file != NULL);
    self->write = PyObject_GetAttrString(file, "write");
    if (self->write == NULL) {
        if (PyErr_ExceptionMatches(PyExc_AttributeError))
            PyErr_SetString(PyExc_TypeError,
                            "file must have a 'write' attribute");
        return -1;
    }

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int _Pickler_SetProtocol ( PicklerObject self,
PyObject proto_obj,
PyObject fix_imports_obj 
) [static]

Definition at line 793 of file _pickle.c.

{
    long proto = 0;
    int fix_imports;

    if (proto_obj == NULL || proto_obj == Py_None)
        proto = DEFAULT_PROTOCOL;
    else {
        proto = PyLong_AsLong(proto_obj);
        if (proto == -1 && PyErr_Occurred())
            return -1;
    }
    if (proto < 0)
        proto = HIGHEST_PROTOCOL;
    if (proto > HIGHEST_PROTOCOL) {
        PyErr_Format(PyExc_ValueError, "pickle protocol must be <= %d",
                     HIGHEST_PROTOCOL);
        return -1;
    }
    fix_imports = PyObject_IsTrue(fix_imports_obj);
    if (fix_imports == -1)
        return -1;
    
    self->proto = proto;
    self->bin = proto > 0;
    self->fix_imports = fix_imports && proto < 3;

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int _Pickler_Write ( PicklerObject self,
const char *  s,
Py_ssize_t  n 
) [static]

Definition at line 704 of file _pickle.c.

{
    Py_ssize_t i, required;
    char *buffer;

    assert(s != NULL);

    required = self->output_len + n;
    if (required > self->max_output_len) {
        if (self->write != NULL && required > MAX_WRITE_BUF_SIZE) {
            /* XXX This reallocates a new buffer every time, which is a bit
               wasteful. */
            if (_Pickler_FlushToFile(self) < 0)
                return -1;
            if (_Pickler_ClearBuffer(self) < 0)
                return -1;
        }
        if (self->write != NULL && n > MAX_WRITE_BUF_SIZE) {
            /* we already flushed above, so the buffer is empty */
            PyObject *result;
            /* XXX we could spare an intermediate copy and pass
               a memoryview instead */
            PyObject *output = PyBytes_FromStringAndSize(s, n);
            if (s == NULL)
                return -1;
            result = _Pickler_FastCall(self, self->write, output);
            Py_XDECREF(result);
            return (result == NULL) ? -1 : 0;
        }
        else {
            if (self->output_len >= PY_SSIZE_T_MAX / 2 - n) {
                PyErr_NoMemory();
                return -1;
            }
            self->max_output_len = (self->output_len + n) * 2;
            if (_PyBytes_Resize(&self->output_buffer, self->max_output_len) < 0)
                return -1;
        }
    }
    buffer = PyBytes_AS_STRING(self->output_buffer);
    if (n < 8) {
        /* This is faster than memcpy when the string is short. */
        for (i = 0; i < n; i++) {
            buffer[self->output_len + i] = s[i];
        }
    }
    else {
        memcpy(buffer + self->output_len, s, n);
    }
    self->output_len += n;
    return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyMemoEntry* _PyMemoTable_Lookup ( PyMemoTable self,
PyObject key 
) [static]

Definition at line 482 of file _pickle.c.

{
    size_t i;
    size_t perturb;
    size_t mask = (size_t)self->mt_mask;
    PyMemoEntry *table = self->mt_table;
    PyMemoEntry *entry;
    Py_hash_t hash = (Py_hash_t)key >> 3;

    i = hash & mask;
    entry = &table[i];
    if (entry->me_key == NULL || entry->me_key == key)
        return entry;

    for (perturb = hash; ; perturb >>= PERTURB_SHIFT) {
        i = (i << 2) + i + perturb + 1;
        entry = &table[i & mask];
        if (entry->me_key == NULL || entry->me_key == key)
            return entry;
    }
    assert(0);  /* Never reached */
    return NULL;
}

Here is the caller graph for this function:

static int _PyMemoTable_ResizeTable ( PyMemoTable self,
Py_ssize_t  min_size 
) [static]

Definition at line 508 of file _pickle.c.

{
    PyMemoEntry *oldtable = NULL;
    PyMemoEntry *oldentry, *newentry;
    Py_ssize_t new_size = MT_MINSIZE;
    Py_ssize_t to_process;

    assert(min_size > 0);

    /* Find the smallest valid table size >= min_size. */
    while (new_size < min_size && new_size > 0)
        new_size <<= 1;
    if (new_size <= 0) {
        PyErr_NoMemory();
        return -1;
    }
    /* new_size needs to be a power of two. */
    assert((new_size & (new_size - 1)) == 0);

    /* Allocate new table. */
    oldtable = self->mt_table;
    self->mt_table = PyMem_MALLOC(new_size * sizeof(PyMemoEntry));
    if (self->mt_table == NULL) {
        PyMem_FREE(oldtable);
        PyErr_NoMemory();
        return -1;
    }
    self->mt_allocated = new_size;
    self->mt_mask = new_size - 1;
    memset(self->mt_table, 0, sizeof(PyMemoEntry) * new_size);

    /* Copy entries from the old table. */
    to_process = self->mt_used;
    for (oldentry = oldtable; to_process > 0; oldentry++) {
        if (oldentry->me_key != NULL) {
            to_process--;
            /* newentry is a pointer to a chunk of the new
               mt_table, so we're setting the key:value pair
               in-place. */
            newentry = _PyMemoTable_Lookup(self, oldentry->me_key);
            newentry->me_key = oldentry->me_key;
            newentry->me_value = oldentry->me_value;
        }
    }

    /* Deallocate the old table. */
    PyMem_FREE(oldtable);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Py_ssize_t _Unpickler_CopyLine ( UnpicklerObject self,
char *  line,
Py_ssize_t  len,
char **  result 
) [static]

Definition at line 1002 of file _pickle.c.

{
    char *input_line = PyMem_Realloc(self->input_line, len + 1);
    if (input_line == NULL)
        return -1;

    memcpy(input_line, line, len);
    input_line[len] = '\0';
    self->input_line = input_line;
    *result = self->input_line;
    return len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* _Unpickler_FastCall ( UnpicklerObject self,
PyObject func,
PyObject arg 
) [static]

Definition at line 843 of file _pickle.c.

{
    PyObject *result = NULL;

    ARG_TUP(self, arg);
    if (self->arg) {
        result = PyObject_Call(func, self->arg, NULL);
        FREE_ARG_TUP(self);
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void _Unpickler_MemoCleanup ( UnpicklerObject self) [static]

Definition at line 1112 of file _pickle.c.

{
    Py_ssize_t i;
    PyObject **memo = self->memo;

    if (self->memo == NULL)
        return;
    self->memo = NULL;
    i = self->memo_size;
    while (--i >= 0) {
        Py_XDECREF(memo[i]);
    }
    PyMem_FREE(memo);
}

Here is the caller graph for this function:

static PyObject* _Unpickler_MemoGet ( UnpicklerObject self,
Py_ssize_t  idx 
) [static]

Definition at line 1073 of file _pickle.c.

{
    if (idx < 0 || idx >= self->memo_size)
        return NULL;

    return self->memo[idx];
}

Here is the caller graph for this function:

static int _Unpickler_MemoPut ( UnpicklerObject self,
Py_ssize_t  idx,
PyObject value 
) [static]

Definition at line 1084 of file _pickle.c.

{
    PyObject *old_item;

    if (idx >= self->memo_size) {
        if (_Unpickler_ResizeMemoList(self, idx * 2) < 0)
            return -1;
        assert(idx < self->memo_size);
    }
    Py_INCREF(value);
    old_item = self->memo[idx];
    self->memo[idx] = value;
    Py_XDECREF(old_item);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static UnpicklerObject* _Unpickler_New ( void  ) [static]

Definition at line 1128 of file _pickle.c.

{
    UnpicklerObject *self;

    self = PyObject_GC_New(UnpicklerObject, &Unpickler_Type);
    if (self == NULL)
        return NULL;

    self->stack = (Pdata *)Pdata_New();
    if (self->stack == NULL) {
        Py_DECREF(self);
        return NULL;
    }
    memset(&self->buffer, 0, sizeof(Py_buffer));

    self->memo_size = 32;
    self->memo = _Unpickler_NewMemo(self->memo_size);
    if (self->memo == NULL) {
        Py_DECREF(self);
        return NULL;
    }

    self->arg = NULL;
    self->pers_func = NULL;
    self->input_buffer = NULL;
    self->input_line = NULL;
    self->input_len = 0;
    self->next_read_idx = 0;
    self->prefetched_idx = 0;
    self->read = NULL;
    self->readline = NULL;
    self->peek = NULL;
    self->encoding = NULL;
    self->errors = NULL;
    self->marks = NULL;
    self->num_marks = 0;
    self->marks_size = 0;
    self->proto = 0;
    self->fix_imports = 0;

    return self;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject** _Unpickler_NewMemo ( Py_ssize_t  new_size) [static]

Definition at line 1101 of file _pickle.c.

{
    PyObject **memo = PyMem_MALLOC(new_size * sizeof(PyObject *));
    if (memo == NULL)
        return NULL;
    memset(memo, 0, new_size * sizeof(PyObject *));
    return memo;
}

Here is the caller graph for this function:

static Py_ssize_t _Unpickler_Read ( UnpicklerObject self,
char **  s,
Py_ssize_t  n 
) [static]

Definition at line 976 of file _pickle.c.

{
    Py_ssize_t num_read;

    if (self->next_read_idx + n <= self->input_len) {
        *s = self->input_buffer + self->next_read_idx;
        self->next_read_idx += n;
        return n;
    }
    if (!self->read) {
        PyErr_Format(PyExc_EOFError, "Ran out of input");
        return -1;
    }
    num_read = _Unpickler_ReadFromFile(self, n);
    if (num_read < 0)
        return -1;
    if (num_read < n) {
        PyErr_Format(PyExc_EOFError, "Ran out of input");
        return -1;
    }
    *s = self->input_buffer;
    self->next_read_idx = n;
    return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Py_ssize_t _Unpickler_ReadFromFile ( UnpicklerObject self,
Py_ssize_t  n 
) [static]

Definition at line 906 of file _pickle.c.

{
    PyObject *data;
    Py_ssize_t read_size, prefetched_size = 0;

    assert(self->read != NULL);
    
    if (_Unpickler_SkipConsumed(self) < 0)
        return -1;

    if (n == READ_WHOLE_LINE)
        data = PyObject_Call(self->readline, empty_tuple, NULL);
    else {
        PyObject *len = PyLong_FromSsize_t(n);
        if (len == NULL)
            return -1;
        data = _Unpickler_FastCall(self, self->read, len);
    }
    if (data == NULL)
        return -1;

    /* Prefetch some data without advancing the file pointer, if possible */
    if (self->peek) {
        PyObject *len, *prefetched;
        len = PyLong_FromSsize_t(PREFETCH);
        if (len == NULL) {
            Py_DECREF(data);
            return -1;
        }
        prefetched = _Unpickler_FastCall(self, self->peek, len);
        if (prefetched == NULL) {
            if (PyErr_ExceptionMatches(PyExc_NotImplementedError)) {
                /* peek() is probably not supported by the given file object */
                PyErr_Clear();
                Py_CLEAR(self->peek);
            }
            else {
                Py_DECREF(data);
                return -1;
            }
        }
        else {
            assert(PyBytes_Check(prefetched));
            prefetched_size = PyBytes_GET_SIZE(prefetched);
            PyBytes_ConcatAndDel(&data, prefetched);
            if (data == NULL)
                return -1;
        }
    }

    read_size = _Unpickler_SetStringInput(self, data) - prefetched_size;
    Py_DECREF(data);
    self->prefetched_idx = read_size;
    return read_size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Py_ssize_t _Unpickler_Readline ( UnpicklerObject self,
char **  result 
) [static]

Definition at line 1021 of file _pickle.c.

{
    Py_ssize_t i, num_read;

    for (i = self->next_read_idx; i < self->input_len; i++) {
        if (self->input_buffer[i] == '\n') {
            char *line_start = self->input_buffer + self->next_read_idx;
            num_read = i - self->next_read_idx + 1;
            self->next_read_idx = i + 1;
            return _Unpickler_CopyLine(self, line_start, num_read, result);
        }
    }
    if (self->read) {
        num_read = _Unpickler_ReadFromFile(self, READ_WHOLE_LINE);
        if (num_read < 0)
            return -1;
        self->next_read_idx = num_read;
        return _Unpickler_CopyLine(self, self->input_buffer, num_read, result);
    }
 
    /* If we get here, we've run off the end of the input string. Return the
       remaining string and let the caller figure it out. */
    *result = self->input_buffer + self->next_read_idx;
    num_read = i - self->next_read_idx;
    self->next_read_idx = i;
    return num_read;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int _Unpickler_ResizeMemoList ( UnpicklerObject self,
Py_ssize_t  new_size 
) [static]

Definition at line 1052 of file _pickle.c.

{
    Py_ssize_t i;
    PyObject **memo;

    assert(new_size > self->memo_size);

    memo = PyMem_REALLOC(self->memo, new_size * sizeof(PyObject *));
    if (memo == NULL) {
        PyErr_NoMemory();
        return -1;
    }
    self->memo = memo;
    for (i = self->memo_size; i < new_size; i++)
        self->memo[i] = NULL;
    self->memo_size = new_size;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int _Unpickler_SetInputEncoding ( UnpicklerObject self,
const char *  encoding,
const char *  errors 
) [static]

Definition at line 1200 of file _pickle.c.

{
    if (encoding == NULL)
        encoding = "ASCII";
    if (errors == NULL)
        errors = "strict";

    self->encoding = strdup(encoding);
    self->errors = strdup(errors);
    if (self->encoding == NULL || self->errors == NULL) {
        PyErr_NoMemory();
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int _Unpickler_SetInputStream ( UnpicklerObject self,
PyObject file 
) [static]

Definition at line 1174 of file _pickle.c.

{
    self->peek = PyObject_GetAttrString(file, "peek");
    if (self->peek == NULL) {
        if (PyErr_ExceptionMatches(PyExc_AttributeError))
            PyErr_Clear();
        else
            return -1;
    }
    self->read = PyObject_GetAttrString(file, "read");
    self->readline = PyObject_GetAttrString(file, "readline");
    if (self->readline == NULL || self->read == NULL) {
        if (PyErr_ExceptionMatches(PyExc_AttributeError))
            PyErr_SetString(PyExc_TypeError,
                            "file must have 'read' and 'readline' attributes");
        Py_CLEAR(self->read);
        Py_CLEAR(self->readline);
        Py_CLEAR(self->peek);
        return -1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Py_ssize_t _Unpickler_SetStringInput ( UnpicklerObject self,
PyObject input 
) [static]

Definition at line 858 of file _pickle.c.

{
    if (self->buffer.buf != NULL)
        PyBuffer_Release(&self->buffer);
    if (PyObject_GetBuffer(input, &self->buffer, PyBUF_CONTIG_RO) < 0)
        return -1;
    self->input_buffer = self->buffer.buf;
    self->input_len = self->buffer.len;
    self->next_read_idx = 0;
    self->prefetched_idx = self->input_len;
    return self->input_len;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int _Unpickler_SkipConsumed ( UnpicklerObject self) [static]

Definition at line 872 of file _pickle.c.

{
    Py_ssize_t consumed = self->next_read_idx - self->prefetched_idx;

    if (consumed > 0) {
        PyObject *r;
        assert(self->peek);  /* otherwise we did something wrong */
        /* This makes an useless copy... */
        r = PyObject_CallFunction(self->read, "n", consumed);
        if (r == NULL)
            return -1;
        Py_DECREF(r);
        self->prefetched_idx = self->next_read_idx;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int bad_readline ( void  ) [static]

Definition at line 3799 of file _pickle.c.

{
    PyErr_SetString(UnpicklingError, "pickle data was truncated");
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int batch_dict ( PicklerObject self,
PyObject iter 
) [static]

Definition at line 2282 of file _pickle.c.

{
    PyObject *obj = NULL;
    PyObject *firstitem = NULL;
    int i, n;

    const char mark_op = MARK;
    const char setitem_op = SETITEM;
    const char setitems_op = SETITEMS;

    assert(iter != NULL);

    if (self->proto == 0) {
        /* SETITEMS isn't available; do one at a time. */
        for (;;) {
            obj = PyIter_Next(iter);
            if (obj == NULL) {
                if (PyErr_Occurred())
                    return -1;
                break;
            }
            if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 2) {
                PyErr_SetString(PyExc_TypeError, "dict items "
                                "iterator must return 2-tuples");
                return -1;
            }
            i = save(self, PyTuple_GET_ITEM(obj, 0), 0);
            if (i >= 0)
                i = save(self, PyTuple_GET_ITEM(obj, 1), 0);
            Py_DECREF(obj);
            if (i < 0)
                return -1;
            if (_Pickler_Write(self, &setitem_op, 1) < 0)
                return -1;
        }
        return 0;
    }

    /* proto > 0:  write in batches of BATCHSIZE. */
    do {
        /* Get first item */
        firstitem = PyIter_Next(iter);
        if (firstitem == NULL) {
            if (PyErr_Occurred())
                goto error;

            /* nothing more to add */
            break;
        }
        if (!PyTuple_Check(firstitem) || PyTuple_Size(firstitem) != 2) {
            PyErr_SetString(PyExc_TypeError, "dict items "
                                "iterator must return 2-tuples");
            goto error;
        }

        /* Try to get a second item */
        obj = PyIter_Next(iter);
        if (obj == NULL) {
            if (PyErr_Occurred())
                goto error;

            /* Only one item to write */
            if (save(self, PyTuple_GET_ITEM(firstitem, 0), 0) < 0)
                goto error;
            if (save(self, PyTuple_GET_ITEM(firstitem, 1), 0) < 0)
                goto error;
            if (_Pickler_Write(self, &setitem_op, 1) < 0)
                goto error;
            Py_CLEAR(firstitem);
            break;
        }

        /* More than one item to write */

        /* Pump out MARK, items, SETITEMS. */
        if (_Pickler_Write(self, &mark_op, 1) < 0)
            goto error;

        if (save(self, PyTuple_GET_ITEM(firstitem, 0), 0) < 0)
            goto error;
        if (save(self, PyTuple_GET_ITEM(firstitem, 1), 0) < 0)
            goto error;
        Py_CLEAR(firstitem);
        n = 1;

        /* Fetch and save up to BATCHSIZE items */
        while (obj) {
            if (!PyTuple_Check(obj) || PyTuple_Size(obj) != 2) {
                PyErr_SetString(PyExc_TypeError, "dict items "
                    "iterator must return 2-tuples");
                goto error;
            }
            if (save(self, PyTuple_GET_ITEM(obj, 0), 0) < 0 ||
                save(self, PyTuple_GET_ITEM(obj, 1), 0) < 0)
                goto error;
            Py_CLEAR(obj);
            n += 1;

            if (n == BATCHSIZE)
                break;

            obj = PyIter_Next(iter);
            if (obj == NULL) {
                if (PyErr_Occurred())
                    goto error;
                break;
            }
        }

        if (_Pickler_Write(self, &setitems_op, 1) < 0)
            goto error;

    } while (n == BATCHSIZE);
    return 0;

  error:
    Py_XDECREF(firstitem);
    Py_XDECREF(obj);
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int batch_dict_exact ( PicklerObject self,
PyObject obj 
) [static]

Definition at line 2413 of file _pickle.c.

{
    PyObject *key = NULL, *value = NULL;
    int i;
    Py_ssize_t dict_size, ppos = 0;

    const char mark_op = MARK;
    const char setitem_op = SETITEM;
    const char setitems_op = SETITEMS;

    assert(obj != NULL);
    assert(self->proto > 0);

    dict_size = PyDict_Size(obj);

    /* Special-case len(d) == 1 to save space. */
    if (dict_size == 1) {
        PyDict_Next(obj, &ppos, &key, &value);
        if (save(self, key, 0) < 0)
            return -1;
        if (save(self, value, 0) < 0)
            return -1;
        if (_Pickler_Write(self, &setitem_op, 1) < 0)
            return -1;
        return 0;
    }

    /* Write in batches of BATCHSIZE. */
    do {
        i = 0;
        if (_Pickler_Write(self, &mark_op, 1) < 0)
            return -1;
        while (PyDict_Next(obj, &ppos, &key, &value)) {
            if (save(self, key, 0) < 0)
                return -1;
            if (save(self, value, 0) < 0)
                return -1;
            if (++i == BATCHSIZE)
                break;
        }
        if (_Pickler_Write(self, &setitems_op, 1) < 0)
            return -1;
        if (PyDict_Size(obj) != dict_size) {
            PyErr_Format(
                PyExc_RuntimeError,
                "dictionary changed size during iteration");
            return -1;
        }

    } while (i == BATCHSIZE);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int batch_list ( PicklerObject self,
PyObject iter 
) [static]

Definition at line 2047 of file _pickle.c.

{
    PyObject *obj = NULL;
    PyObject *firstitem = NULL;
    int i, n;

    const char mark_op = MARK;
    const char append_op = APPEND;
    const char appends_op = APPENDS;

    assert(iter != NULL);

    /* XXX: I think this function could be made faster by avoiding the
       iterator interface and fetching objects directly from list using
       PyList_GET_ITEM.
    */

    if (self->proto == 0) {
        /* APPENDS isn't available; do one at a time. */
        for (;;) {
            obj = PyIter_Next(iter);
            if (obj == NULL) {
                if (PyErr_Occurred())
                    return -1;
                break;
            }
            i = save(self, obj, 0);
            Py_DECREF(obj);
            if (i < 0)
                return -1;
            if (_Pickler_Write(self, &append_op, 1) < 0)
                return -1;
        }
        return 0;
    }

    /* proto > 0:  write in batches of BATCHSIZE. */
    do {
        /* Get first item */
        firstitem = PyIter_Next(iter);
        if (firstitem == NULL) {
            if (PyErr_Occurred())
                goto error;

            /* nothing more to add */
            break;
        }

        /* Try to get a second item */
        obj = PyIter_Next(iter);
        if (obj == NULL) {
            if (PyErr_Occurred())
                goto error;

            /* Only one item to write */
            if (save(self, firstitem, 0) < 0)
                goto error;
            if (_Pickler_Write(self, &append_op, 1) < 0)
                goto error;
            Py_CLEAR(firstitem);
            break;
        }

        /* More than one item to write */

        /* Pump out MARK, items, APPENDS. */
        if (_Pickler_Write(self, &mark_op, 1) < 0)
            goto error;

        if (save(self, firstitem, 0) < 0)
            goto error;
        Py_CLEAR(firstitem);
        n = 1;

        /* Fetch and save up to BATCHSIZE items */
        while (obj) {
            if (save(self, obj, 0) < 0)
                goto error;
            Py_CLEAR(obj);
            n += 1;

            if (n == BATCHSIZE)
                break;

            obj = PyIter_Next(iter);
            if (obj == NULL) {
                if (PyErr_Occurred())
                    goto error;
                break;
            }
        }

        if (_Pickler_Write(self, &appends_op, 1) < 0)
            goto error;

    } while (n == BATCHSIZE);
    return 0;

  error:
    Py_XDECREF(firstitem);
    Py_XDECREF(obj);
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int batch_list_exact ( PicklerObject self,
PyObject obj 
) [static]

Definition at line 2163 of file _pickle.c.

{
    PyObject *item = NULL;
    int this_batch, total;

    const char append_op = APPEND;
    const char appends_op = APPENDS;
    const char mark_op = MARK;

    assert(obj != NULL);
    assert(self->proto > 0);
    assert(PyList_CheckExact(obj));

    if (PyList_GET_SIZE(obj) == 1) {
        item = PyList_GET_ITEM(obj, 0);
        if (save(self, item, 0) < 0)
            return -1;
        if (_Pickler_Write(self, &append_op, 1) < 0)
            return -1;
        return 0;
    }

    /* Write in batches of BATCHSIZE. */
    total = 0;
    do {
        this_batch = 0;
        if (_Pickler_Write(self, &mark_op, 1) < 0)
            return -1;
        while (total < PyList_GET_SIZE(obj)) {
            item = PyList_GET_ITEM(obj, total);
            if (save(self, item, 0) < 0)
                return -1;
            total++;
            if (++this_batch == BATCHSIZE)
                break;
        }
        if (_Pickler_Write(self, &appends_op, 1) < 0)
            return -1;

    } while (total < PyList_GET_SIZE(obj));

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static long calc_binint ( char *  bytes,
int  size 
) [static]

Definition at line 3864 of file _pickle.c.

{
    unsigned char *s = (unsigned char *)bytes;
    int i = size;
    long x = 0;

    for (i = 0; i < size; i++) {
        x |= (long)s[i] << (i * 8);
    }

    /* Unlike BININT1 and BININT2, BININT (more accurately BININT4)
     * is signed, so on a box with longs bigger than 4 bytes we need
     * to extend a BININT's sign bit to the full width.
     */
    if (SIZEOF_LONG > 4 && size == 4) {
        x |= -(x & (1L << 31));
    }

    return x;
}

Here is the caller graph for this function:

static int do_append ( UnpicklerObject self,
int  x 
) [static]

Definition at line 4872 of file _pickle.c.

{
    PyObject *value;
    PyObject *list;
    int len, i;

    len = Py_SIZE(self->stack);
    if (x > len || x <= 0)
        return stack_underflow();
    if (len == x)  /* nothing to do */
        return 0;

    list = self->stack->data[x - 1];

    if (PyList_Check(list)) {
        PyObject *slice;
        Py_ssize_t list_len;

        slice = Pdata_poplist(self->stack, x);
        if (!slice)
            return -1;
        list_len = PyList_GET_SIZE(list);
        i = PyList_SetSlice(list, list_len, list_len, slice);
        Py_DECREF(slice);
        return i;
    }
    else {
        PyObject *append_func;

        append_func = PyObject_GetAttrString(list, "append");
        if (append_func == NULL)
            return -1;
        for (i = x; i < len; i++) {
            PyObject *result;

            value = self->stack->data[i];
            result = _Unpickler_FastCall(self, append_func, value);
            if (result == NULL) {
                Pdata_clear(self->stack, i + 1);
                Py_SIZE(self->stack) = x;
                return -1;
            }
            Py_DECREF(result);
        }
        Py_SIZE(self->stack) = x;
    }

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int do_setitems ( UnpicklerObject self,
int  x 
) [static]

Definition at line 4935 of file _pickle.c.

{
    PyObject *value, *key;
    PyObject *dict;
    int len, i;
    int status = 0;

    len = Py_SIZE(self->stack);
    if (x > len || x <= 0)
        return stack_underflow();
    if (len == x)  /* nothing to do */
        return 0;
    if ((len - x) % 2 != 0) { 
        /* Currupt or hostile pickle -- we never write one like this. */
        PyErr_SetString(UnpicklingError, "odd number of items for SETITEMS");
        return -1;
    }

    /* Here, dict does not actually need to be a PyDict; it could be anything
       that supports the __setitem__ attribute. */
    dict = self->stack->data[x - 1];

    for (i = x + 1; i < len; i += 2) {
        key = self->stack->data[i - 1];
        value = self->stack->data[i];
        if (PyObject_SetItem(dict, key, value) < 0) {
            status = -1;
            break;
        }
    }

    Pdata_clear(self->stack, x);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int dump ( PicklerObject self,
PyObject obj 
) [static]

Definition at line 3236 of file _pickle.c.

{
    const char stop_op = STOP;

    if (self->proto >= 2) {
        char header[2];

        header[0] = PROTO;
        assert(self->proto >= 0 && self->proto < 256);
        header[1] = (unsigned char)self->proto;
        if (_Pickler_Write(self, header, 2) < 0)
            return -1;
    }

    if (save(self, obj, 0) < 0 ||
        _Pickler_Write(self, &stop_op, 1) < 0)
        return -1;

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int fast_save_enter ( PicklerObject self,
PyObject obj 
) [static]

Definition at line 1403 of file _pickle.c.

{
    /* if fast_nesting < 0, we're doing an error exit. */
    if (++self->fast_nesting >= FAST_NESTING_LIMIT) {
        PyObject *key = NULL;
        if (self->fast_memo == NULL) {
            self->fast_memo = PyDict_New();
            if (self->fast_memo == NULL) {
                self->fast_nesting = -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 %.200s at %p",
                         obj->ob_type->tp_name, obj);
            self->fast_nesting = -1;
            return 0;
        }
        if (PyDict_SetItem(self->fast_memo, key, Py_None) < 0) {
            Py_DECREF(key);
            self->fast_nesting = -1;
            return 0;
        }
        Py_DECREF(key);
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int fast_save_leave ( PicklerObject self,
PyObject obj 
) [static]

Definition at line 1438 of file _pickle.c.

{
    if (self->fast_nesting-- >= FAST_NESTING_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);
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* find_class ( UnpicklerObject self,
PyObject module_name,
PyObject global_name 
) [static]

Definition at line 3774 of file _pickle.c.

{
    return PyObject_CallMethod((PyObject *)self, "find_class", "OO",
                               module_name, global_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int initmodule ( void  ) [static]

Definition at line 6187 of file _pickle.c.

{
    PyObject *copyreg = NULL;
    PyObject *compat_pickle = NULL;

    /* XXX: We should ensure that the types of the dictionaries imported are
       exactly PyDict objects. Otherwise, it is possible to crash the pickle
       since we use the PyDict API directly to access these dictionaries. */

    copyreg = PyImport_ImportModule("copyreg");
    if (!copyreg)
        goto error;
    dispatch_table = PyObject_GetAttrString(copyreg, "dispatch_table");
    if (!dispatch_table)
        goto error;
    extension_registry = \
        PyObject_GetAttrString(copyreg, "_extension_registry");
    if (!extension_registry)
        goto error;
    inverted_registry = PyObject_GetAttrString(copyreg, "_inverted_registry");
    if (!inverted_registry)
        goto error;
    extension_cache = PyObject_GetAttrString(copyreg, "_extension_cache");
    if (!extension_cache)
        goto error;
    Py_CLEAR(copyreg);

    /* Load the 2.x -> 3.x stdlib module mapping tables */
    compat_pickle = PyImport_ImportModule("_compat_pickle");
    if (!compat_pickle)
        goto error;
    name_mapping_2to3 = PyObject_GetAttrString(compat_pickle, "NAME_MAPPING");
    if (!name_mapping_2to3)
        goto error;
    if (!PyDict_CheckExact(name_mapping_2to3)) {
        PyErr_Format(PyExc_RuntimeError,
                     "_compat_pickle.NAME_MAPPING should be a dict, not %.200s",
                     Py_TYPE(name_mapping_2to3)->tp_name);
        goto error;
    }
    import_mapping_2to3 = PyObject_GetAttrString(compat_pickle,
                                                 "IMPORT_MAPPING");
    if (!import_mapping_2to3)
        goto error;
    if (!PyDict_CheckExact(import_mapping_2to3)) {
        PyErr_Format(PyExc_RuntimeError,
                     "_compat_pickle.IMPORT_MAPPING should be a dict, "
                     "not %.200s", Py_TYPE(import_mapping_2to3)->tp_name);
        goto error;
    }
    /* ... and the 3.x -> 2.x mapping tables */
    name_mapping_3to2 = PyObject_GetAttrString(compat_pickle,
                                               "REVERSE_NAME_MAPPING");
    if (!name_mapping_3to2)
        goto error;
    if (!PyDict_CheckExact(name_mapping_3to2)) {
        PyErr_Format(PyExc_RuntimeError,
                     "_compat_pickle.REVERSE_NAME_MAPPING should be a dict, "
                     "not %.200s", Py_TYPE(name_mapping_3to2)->tp_name);
        goto error;
    }
    import_mapping_3to2 = PyObject_GetAttrString(compat_pickle,
                                                 "REVERSE_IMPORT_MAPPING");
    if (!import_mapping_3to2)
        goto error;
    if (!PyDict_CheckExact(import_mapping_3to2)) {
        PyErr_Format(PyExc_RuntimeError,
                     "_compat_pickle.REVERSE_IMPORT_MAPPING should be a dict, "
                     "not %.200s", Py_TYPE(import_mapping_3to2)->tp_name);
        goto error;
    }
    Py_CLEAR(compat_pickle);

    empty_tuple = PyTuple_New(0);
    if (empty_tuple == NULL)
        goto error;
    two_tuple = PyTuple_New(2);
    if (two_tuple == NULL)
        goto error;
    /* We use this temp container with no regard to refcounts, or to
     * keeping containees alive.  Exempt from GC, because we don't
     * want anything looking at two_tuple() by magic.
     */
    PyObject_GC_UnTrack(two_tuple);

    return 0;

  error:
    Py_CLEAR(copyreg);
    Py_CLEAR(dispatch_table);
    Py_CLEAR(extension_registry);
    Py_CLEAR(inverted_registry);
    Py_CLEAR(extension_cache);
    Py_CLEAR(compat_pickle);
    Py_CLEAR(name_mapping_2to3);
    Py_CLEAR(import_mapping_2to3);
    Py_CLEAR(name_mapping_3to2);
    Py_CLEAR(import_mapping_3to2);
    Py_CLEAR(empty_tuple);
    Py_CLEAR(two_tuple);
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* instantiate ( PyObject cls,
PyObject args 
) [static]

Definition at line 4351 of file _pickle.c.

{
    PyObject *result = NULL;
    /* Caller must assure args are a tuple.  Normally, args come from
       Pdata_poptuple which packs objects from the top of the stack
       into a newly created tuple. */
    assert(PyTuple_Check(args));
    if (Py_SIZE(args) > 0 || !PyType_Check(cls) ||
        PyObject_HasAttrString(cls, "__getinitargs__")) {
        result = PyObject_CallObject(cls, args);
    }
    else {
        result = PyObject_CallMethod(cls, "__new__", "O", cls);
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* load ( UnpicklerObject self) [static]

Definition at line 5181 of file _pickle.c.

{
    PyObject *err;
    PyObject *value = NULL;
    char *s;

    self->num_marks = 0;
    if (Py_SIZE(self->stack))
        Pdata_clear(self->stack, 0);

    /* Convenient macros for the dispatch while-switch loop just below. */
#define OP(opcode, load_func) \
    case opcode: if (load_func(self) < 0) break; continue;

#define OP_ARG(opcode, load_func, arg) \
    case opcode: if (load_func(self, (arg)) < 0) break; continue;

    while (1) {
        if (_Unpickler_Read(self, &s, 1) < 0)
            break;

        switch ((enum opcode)s[0]) {
        OP(NONE, load_none)
        OP(BININT, load_binint)
        OP(BININT1, load_binint1)
        OP(BININT2, load_binint2)
        OP(INT, load_int)
        OP(LONG, load_long)
        OP_ARG(LONG1, load_counted_long, 1)
        OP_ARG(LONG4, load_counted_long, 4)
        OP(FLOAT, load_float)
        OP(BINFLOAT, load_binfloat)
        OP(BINBYTES, load_binbytes)
        OP(SHORT_BINBYTES, load_short_binbytes)
        OP(BINSTRING, load_binstring)
        OP(SHORT_BINSTRING, load_short_binstring)
        OP(STRING, load_string)
        OP(UNICODE, load_unicode)
        OP(BINUNICODE, load_binunicode)
        OP_ARG(EMPTY_TUPLE, load_counted_tuple, 0)
        OP_ARG(TUPLE1, load_counted_tuple, 1)
        OP_ARG(TUPLE2, load_counted_tuple, 2)
        OP_ARG(TUPLE3, load_counted_tuple, 3)
        OP(TUPLE, load_tuple)
        OP(EMPTY_LIST, load_empty_list)
        OP(LIST, load_list)
        OP(EMPTY_DICT, load_empty_dict)
        OP(DICT, load_dict)
        OP(OBJ, load_obj)
        OP(INST, load_inst)
        OP(NEWOBJ, load_newobj)
        OP(GLOBAL, load_global)
        OP(APPEND, load_append)
        OP(APPENDS, load_appends)
        OP(BUILD, load_build)
        OP(DUP, load_dup)
        OP(BINGET, load_binget)
        OP(LONG_BINGET, load_long_binget)
        OP(GET, load_get)
        OP(MARK, load_mark)
        OP(BINPUT, load_binput)
        OP(LONG_BINPUT, load_long_binput)
        OP(PUT, load_put)
        OP(POP, load_pop)
        OP(POP_MARK, load_pop_mark)
        OP(SETITEM, load_setitem)
        OP(SETITEMS, load_setitems)
        OP(PERSID, load_persid)
        OP(BINPERSID, load_binpersid)
        OP(REDUCE, load_reduce)
        OP(PROTO, load_proto)
        OP_ARG(EXT1, load_extension, 1)
        OP_ARG(EXT2, load_extension, 2)
        OP_ARG(EXT4, load_extension, 4)
        OP_ARG(NEWTRUE, load_bool, Py_True)
        OP_ARG(NEWFALSE, load_bool, Py_False)

        case STOP:
            break;

        case '\0':
            PyErr_SetNone(PyExc_EOFError);
            return NULL;

        default:
            PyErr_Format(UnpicklingError,
                         "invalid load key, '%c'.", s[0]);
            return NULL;
        }

        break;                  /* and we are done! */
    }

    if (_Unpickler_SkipConsumed(self) < 0)
        return NULL;

    /* XXX: It is not clear what this is actually for. */
    if ((err = PyErr_Occurred())) {
        if (err == PyExc_EOFError) {
            PyErr_SetNone(PyExc_EOFError);
        }
        return NULL;
    }

    PDATA_POP(self->stack, value);
    return value;
}

Here is the caller graph for this function:

static int load_append ( UnpicklerObject self) [static]

Definition at line 4923 of file _pickle.c.

{
    return do_append(self, Py_SIZE(self->stack) - 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_appends ( UnpicklerObject self) [static]

Definition at line 4929 of file _pickle.c.

{
    return do_append(self, marker(self));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_binbytes ( UnpicklerObject self) [static]

Definition at line 4099 of file _pickle.c.

{
    PyObject *bytes;
    long x;
    char *s;

    if (_Unpickler_Read(self, &s, 4) < 0)
        return -1;

    x = calc_binint(s, 4);
    if (x < 0) {
        PyErr_SetString(UnpicklingError, 
                        "BINBYTES pickle has negative byte count");
        return -1;
    }

    if (_Unpickler_Read(self, &s, x) < 0)
        return -1;
    bytes = PyBytes_FromStringAndSize(s, x);
    if (bytes == NULL)
        return -1;

    PDATA_PUSH(self->stack, bytes, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_binfloat ( UnpicklerObject self) [static]

Definition at line 4027 of file _pickle.c.

{
    PyObject *value;
    double x;
    char *s;

    if (_Unpickler_Read(self, &s, 8) < 0)
        return -1;

    x = _PyFloat_Unpack8((unsigned char *)s, 0);
    if (x == -1.0 && PyErr_Occurred())
        return -1;

    if ((value = PyFloat_FromDouble(x)) == NULL)
        return -1;

    PDATA_PUSH(self->stack, value, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_binget ( UnpicklerObject self) [static]

Definition at line 4680 of file _pickle.c.

{
    PyObject *value;
    Py_ssize_t idx;
    char *s;

    if (_Unpickler_Read(self, &s, 1) < 0)
        return -1;

    idx = Py_CHARMASK(s[0]);

    value = _Unpickler_MemoGet(self, idx);
    if (value == NULL) {
        PyObject *key = PyLong_FromSsize_t(idx);
        if (!PyErr_Occurred())
            PyErr_SetObject(PyExc_KeyError, key);
        Py_DECREF(key);
        return -1;
    }

    PDATA_APPEND(self->stack, value, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_binint ( UnpicklerObject self) [static]

Definition at line 3901 of file _pickle.c.

{
    char *s;

    if (_Unpickler_Read(self, &s, 4) < 0)
        return -1;

    return load_binintx(self, s, 4);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_binint1 ( UnpicklerObject self) [static]

Definition at line 3912 of file _pickle.c.

{
    char *s;

    if (_Unpickler_Read(self, &s, 1) < 0)
        return -1;

    return load_binintx(self, s, 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_binint2 ( UnpicklerObject self) [static]

Definition at line 3923 of file _pickle.c.

{
    char *s;

    if (_Unpickler_Read(self, &s, 2) < 0)
        return -1;

    return load_binintx(self, s, 2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_binintx ( UnpicklerObject self,
char *  s,
int  size 
) [static]

Definition at line 3886 of file _pickle.c.

{
    PyObject *value;
    long x;

    x = calc_binint(s, size);

    if ((value = PyLong_FromLong(x)) == NULL)
        return -1;

    PDATA_PUSH(self->stack, value, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_binpersid ( UnpicklerObject self) [static]

Definition at line 4568 of file _pickle.c.

{
    PyObject *pid;

    if (self->pers_func) {
        PDATA_POP(self->stack, pid);
        if (pid == NULL)
            return -1;

        /* Ugh... this does not leak since _Unpickler_FastCall() steals the
           reference to pid first. */
        pid = _Unpickler_FastCall(self, self->pers_func, pid);
        if (pid == NULL)
            return -1;

        PDATA_PUSH(self->stack, pid, -1);
        return 0;
    }
    else {
        PyErr_SetString(UnpicklingError,
                        "A load persistent id instruction was encountered,\n"
                        "but no persistent_load function was specified.");
        return -1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_binput ( UnpicklerObject self) [static]

Definition at line 4831 of file _pickle.c.

{
    PyObject *value;
    Py_ssize_t idx;
    char *s;

    if (_Unpickler_Read(self, &s, 1) < 0)
        return -1;

    if (Py_SIZE(self->stack) <= 0)
        return stack_underflow();
    value = self->stack->data[Py_SIZE(self->stack) - 1];

    idx = Py_CHARMASK(s[0]);

    return _Unpickler_MemoPut(self, idx, value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_binstring ( UnpicklerObject self) [static]

Definition at line 4149 of file _pickle.c.

{
    PyObject *str;
    long x;
    char *s;

    if (_Unpickler_Read(self, &s, 4) < 0)
        return -1;

    x = calc_binint(s, 4);
    if (x < 0) {
        PyErr_SetString(UnpicklingError, 
                        "BINSTRING pickle has negative byte count");
        return -1;
    }

    if (_Unpickler_Read(self, &s, x) < 0)
        return -1;

    /* Convert Python 2.x strings to unicode. */
    str = PyUnicode_Decode(s, x, self->encoding, self->errors);
    if (str == NULL)
        return -1;

    PDATA_PUSH(self->stack, str, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_binunicode ( UnpicklerObject self) [static]

Definition at line 4222 of file _pickle.c.

{
    PyObject *str;
    long size;
    char *s;

    if (_Unpickler_Read(self, &s, 4) < 0)
        return -1;

    size = calc_binint(s, 4);
    if (size < 0) {
        PyErr_SetString(UnpicklingError, 
                        "BINUNICODE pickle has negative byte count");
        return -1;
    }

    if (_Unpickler_Read(self, &s, size) < 0)
        return -1;

    str = PyUnicode_DecodeUTF8(s, size, "surrogatepass");
    if (str == NULL)
        return -1;

    PDATA_PUSH(self->stack, str, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_bool ( UnpicklerObject self,
PyObject boolean 
) [static]

Definition at line 3851 of file _pickle.c.

{
    assert(boolean == Py_True || boolean == Py_False);
    PDATA_APPEND(self->stack, boolean, -1);
    return 0;
}

Here is the caller graph for this function:

static int load_build ( UnpicklerObject self) [static]

Definition at line 4983 of file _pickle.c.

{
    PyObject *state, *inst, *slotstate;
    PyObject *setstate;
    int status = 0;

    /* Stack is ... instance, state.  We want to leave instance at
     * the stack top, possibly mutated via instance.__setstate__(state).
     */
    if (Py_SIZE(self->stack) < 2)
        return stack_underflow();

    PDATA_POP(self->stack, state);
    if (state == NULL)
        return -1;

    inst = self->stack->data[Py_SIZE(self->stack) - 1];

    setstate = PyObject_GetAttrString(inst, "__setstate__");
    if (setstate == NULL) {
        if (PyErr_ExceptionMatches(PyExc_AttributeError))
            PyErr_Clear();
        else {
            Py_DECREF(state);
            return -1;
        }
    }
    else {
        PyObject *result;

        /* The explicit __setstate__ is responsible for everything. */
        /* Ugh... this does not leak since _Unpickler_FastCall() steals the
           reference to state first. */
        result = _Unpickler_FastCall(self, setstate, state);
        Py_DECREF(setstate);
        if (result == NULL)
            return -1;
        Py_DECREF(result);
        return 0;
    }

    /* A default __setstate__.  First see whether state embeds a
     * slot state dict too (a proto 2 addition).
     */
    if (PyTuple_Check(state) && Py_SIZE(state) == 2) {
        PyObject *tmp = state;

        state = PyTuple_GET_ITEM(tmp, 0);
        slotstate = PyTuple_GET_ITEM(tmp, 1);
        Py_INCREF(state);
        Py_INCREF(slotstate);
        Py_DECREF(tmp);
    }
    else
        slotstate = NULL;

    /* Set inst.__dict__ from the state dict (if any). */
    if (state != Py_None) {
        PyObject *dict;
        PyObject *d_key, *d_value;
        Py_ssize_t i;

        if (!PyDict_Check(state)) {
            PyErr_SetString(UnpicklingError, "state is not a dictionary");
            goto error;
        }
        dict = PyObject_GetAttrString(inst, "__dict__");
        if (dict == NULL)
            goto error;

        i = 0;
        while (PyDict_Next(state, &i, &d_key, &d_value)) {
            /* normally the keys for instance attributes are
               interned.  we should try to do that here. */
            Py_INCREF(d_key);
            if (PyUnicode_CheckExact(d_key))
                PyUnicode_InternInPlace(&d_key);
            if (PyObject_SetItem(dict, d_key, d_value) < 0) {
                Py_DECREF(d_key);
                goto error;
            }
            Py_DECREF(d_key);
        }
        Py_DECREF(dict);
    }

    /* Also set instance attributes from the slotstate dict (if any). */
    if (slotstate != NULL) {
        PyObject *d_key, *d_value;
        Py_ssize_t i;

        if (!PyDict_Check(slotstate)) {
            PyErr_SetString(UnpicklingError,
                            "slot state is not a dictionary");
            goto error;
        }
        i = 0;
        while (PyDict_Next(slotstate, &i, &d_key, &d_value)) {
            if (PyObject_SetAttr(inst, d_key, d_value) < 0)
                goto error;
        }
    }

    if (0) {
  error:
        status = -1;
    }

    Py_DECREF(state);
    Py_XDECREF(slotstate);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_counted_long ( UnpicklerObject self,
int  size 
) [static]

Definition at line 3964 of file _pickle.c.

{
    PyObject *value;
    char *nbytes;
    char *pdata;

    assert(size == 1 || size == 4);
    if (_Unpickler_Read(self, &nbytes, size) < 0)
        return -1;

    size = calc_binint(nbytes, size);
    if (size < 0) {
        /* Corrupt or hostile pickle -- we never write one like this */
        PyErr_SetString(UnpicklingError,
                        "LONG pickle has negative byte count");
        return -1;
    }

    if (size == 0)
        value = PyLong_FromLong(0L);
    else {
        /* Read the raw little-endian bytes and convert. */
        if (_Unpickler_Read(self, &pdata, size) < 0)
            return -1;
        value = _PyLong_FromByteArray((unsigned char *)pdata, (size_t)size,
                                      1 /* little endian */ , 1 /* signed */ );
    }
    if (value == NULL)
        return -1;
    PDATA_PUSH(self->stack, value, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_counted_tuple ( UnpicklerObject self,
int  len 
) [static]

Definition at line 4266 of file _pickle.c.

{
    PyObject *tuple;

    tuple = PyTuple_New(len);
    if (tuple == NULL)
        return -1;

    while (--len >= 0) {
        PyObject *item;

        PDATA_POP(self->stack, item);
        if (item == NULL)
            return -1;
        PyTuple_SET_ITEM(tuple, len, item);
    }
    PDATA_PUSH(self->stack, tuple, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_dict ( UnpicklerObject self) [static]

Definition at line 4325 of file _pickle.c.

{
    PyObject *dict, *key, *value;
    int i, j, k;

    if ((i = marker(self)) < 0)
        return -1;
    j = Py_SIZE(self->stack);

    if ((dict = PyDict_New()) == NULL)
        return -1;

    for (k = i + 1; k < j; k += 2) {
        key = self->stack->data[k - 1];
        value = self->stack->data[k];
        if (PyDict_SetItem(dict, key, value) < 0) {
            Py_DECREF(dict);
            return -1;
        }
    }
    Pdata_clear(self->stack, i);
    PDATA_PUSH(self->stack, dict, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_dup ( UnpicklerObject self) [static]

Definition at line 4632 of file _pickle.c.

{
    PyObject *last;
    int len;

    if ((len = Py_SIZE(self->stack)) <= 0)
        return stack_underflow();
    last = self->stack->data[len - 1];
    PDATA_APPEND(self->stack, last, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_empty_dict ( UnpicklerObject self) [static]

Definition at line 4298 of file _pickle.c.

{
    PyObject *dict;

    if ((dict = PyDict_New()) == NULL)
        return -1;
    PDATA_PUSH(self->stack, dict, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_empty_list ( UnpicklerObject self) [static]

Definition at line 4287 of file _pickle.c.

{
    PyObject *list;

    if ((list = PyList_New(0)) == NULL)
        return -1;
    PDATA_PUSH(self->stack, list, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_extension ( UnpicklerObject self,
int  nbytes 
) [static]

Definition at line 4736 of file _pickle.c.

{
    char *codebytes;            /* the nbytes bytes after the opcode */
    long code;                  /* calc_binint returns long */
    PyObject *py_code;          /* code as a Python int */
    PyObject *obj;              /* the object to push */
    PyObject *pair;             /* (module_name, class_name) */
    PyObject *module_name, *class_name;

    assert(nbytes == 1 || nbytes == 2 || nbytes == 4);
    if (_Unpickler_Read(self, &codebytes, nbytes) < 0)
        return -1;
    code = calc_binint(codebytes, nbytes);
    if (code <= 0) {            /* note that 0 is forbidden */
        /* Corrupt or hostile pickle. */
        PyErr_SetString(UnpicklingError, "EXT specifies code <= 0");
        return -1;
    }

    /* Look for the code in the cache. */
    py_code = PyLong_FromLong(code);
    if (py_code == NULL)
        return -1;
    obj = PyDict_GetItem(extension_cache, py_code);
    if (obj != NULL) {
        /* Bingo. */
        Py_DECREF(py_code);
        PDATA_APPEND(self->stack, obj, -1);
        return 0;
    }

    /* Look up the (module_name, class_name) pair. */
    pair = PyDict_GetItem(inverted_registry, py_code);
    if (pair == NULL) {
        Py_DECREF(py_code);
        PyErr_Format(PyExc_ValueError, "unregistered extension "
                     "code %ld", code);
        return -1;
    }
    /* Since the extension registry is manipulable via Python code,
     * confirm that pair is really a 2-tuple of strings.
     */
    if (!PyTuple_Check(pair) || PyTuple_Size(pair) != 2 ||
        !PyUnicode_Check(module_name = PyTuple_GET_ITEM(pair, 0)) ||
        !PyUnicode_Check(class_name = PyTuple_GET_ITEM(pair, 1))) {
        Py_DECREF(py_code);
        PyErr_Format(PyExc_ValueError, "_inverted_registry[%ld] "
                     "isn't a 2-tuple of strings", code);
        return -1;
    }
    /* Load the object. */
    obj = find_class(self, module_name, class_name);
    if (obj == NULL) {
        Py_DECREF(py_code);
        return -1;
    }
    /* Cache code -> obj. */
    code = PyDict_SetItem(extension_cache, py_code, obj);
    Py_DECREF(py_code);
    if (code < 0) {
        Py_DECREF(obj);
        return -1;
    }
    PDATA_PUSH(self->stack, obj, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_float ( UnpicklerObject self) [static]

Definition at line 3998 of file _pickle.c.

{
    PyObject *value;
    char *endptr, *s;
    Py_ssize_t len;
    double d;

    if ((len = _Unpickler_Readline(self, &s)) < 0)
        return -1;
    if (len < 2)
        return bad_readline();

    errno = 0;
    d = PyOS_string_to_double(s, &endptr, PyExc_OverflowError);
    if (d == -1.0 && PyErr_Occurred())
        return -1;
    if ((endptr[0] != '\n') && (endptr[0] != '\0')) {
        PyErr_SetString(PyExc_ValueError, "could not convert string to float");
        return -1;
    }
    value = PyFloat_FromDouble(d);
    if (value == NULL)
        return -1;

    PDATA_PUSH(self->stack, value, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_get ( UnpicklerObject self) [static]

Definition at line 4645 of file _pickle.c.

{
    PyObject *key, *value;
    Py_ssize_t idx;
    Py_ssize_t len;
    char *s;

    if ((len = _Unpickler_Readline(self, &s)) < 0)
        return -1;
    if (len < 2)
        return bad_readline();

    key = PyLong_FromString(s, NULL, 10);
    if (key == NULL)
        return -1;
    idx = PyLong_AsSsize_t(key);
    if (idx == -1 && PyErr_Occurred()) {
        Py_DECREF(key);
        return -1;
    }

    value = _Unpickler_MemoGet(self, idx);
    if (value == NULL) {
        if (!PyErr_Occurred())
            PyErr_SetObject(PyExc_KeyError, key);
        Py_DECREF(key);
        return -1;
    }
    Py_DECREF(key);

    PDATA_APPEND(self->stack, value, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_global ( UnpicklerObject self) [static]

Definition at line 4498 of file _pickle.c.

{
    PyObject *global = NULL;
    PyObject *module_name;
    PyObject *global_name;
    Py_ssize_t len;
    char *s;

    if ((len = _Unpickler_Readline(self, &s)) < 0)
        return -1;
    if (len < 2)
        return bad_readline();
    module_name = PyUnicode_DecodeUTF8(s, len - 1, "strict");
    if (!module_name)
        return -1;

    if ((len = _Unpickler_Readline(self, &s)) >= 0) {
        if (len < 2) {
            Py_DECREF(module_name);
            return bad_readline();
        }
        global_name = PyUnicode_DecodeUTF8(s, len - 1, "strict");
        if (global_name) {
            global = find_class(self, module_name, global_name);
            Py_DECREF(global_name);
        }
    }
    Py_DECREF(module_name);

    if (global == NULL)
        return -1;
    PDATA_PUSH(self->stack, global, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_inst ( UnpicklerObject self) [static]

Definition at line 4395 of file _pickle.c.

{
    PyObject *cls = NULL;
    PyObject *args = NULL;
    PyObject *obj = NULL;
    PyObject *module_name;
    PyObject *class_name;
    Py_ssize_t len;
    int i;
    char *s;

    if ((i = marker(self)) < 0)
        return -1;
    if ((len = _Unpickler_Readline(self, &s)) < 0)
        return -1;
    if (len < 2)
        return bad_readline();

    /* Here it is safe to use PyUnicode_DecodeASCII(), even though non-ASCII
       identifiers are permitted in Python 3.0, since the INST opcode is only
       supported by older protocols on Python 2.x. */
    module_name = PyUnicode_DecodeASCII(s, len - 1, "strict");
    if (module_name == NULL)
        return -1;

    if ((len = _Unpickler_Readline(self, &s)) >= 0) {
        if (len < 2)
            return bad_readline();
        class_name = PyUnicode_DecodeASCII(s, len - 1, "strict");
        if (class_name != NULL) {
            cls = find_class(self, module_name, class_name);
            Py_DECREF(class_name);
        }
    }
    Py_DECREF(module_name);

    if (cls == NULL)
        return -1;

    if ((args = Pdata_poptuple(self->stack, i)) != NULL) {
        obj = instantiate(cls, args);
        Py_DECREF(args);
    }
    Py_DECREF(cls);

    if (obj == NULL)
        return -1;

    PDATA_PUSH(self->stack, obj, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_int ( UnpicklerObject self) [static]

Definition at line 3806 of file _pickle.c.

{
    PyObject *value;
    char *endptr, *s;
    Py_ssize_t len;
    long x;

    if ((len = _Unpickler_Readline(self, &s)) < 0)
        return -1;
    if (len < 2)
        return bad_readline();

    errno = 0;
    /* XXX: Should the base argument of strtol() be explicitly set to 10? 
       XXX(avassalotti): Should this uses PyOS_strtol()? */
    x = strtol(s, &endptr, 0);

    if (errno || (*endptr != '\n' && *endptr != '\0')) {
        /* Hm, maybe we've got something long.  Let's try reading
         * it as a Python long object. */
        errno = 0;
        /* XXX: Same thing about the base here. */
        value = PyLong_FromString(s, NULL, 0);
        if (value == NULL) {
            PyErr_SetString(PyExc_ValueError,
                            "could not convert string to int");
            return -1;
        }
    }
    else {
        if (len == 3 && (x == 0 || x == 1)) {
            if ((value = PyBool_FromLong(x)) == NULL)
                return -1;
        }
        else {
            if ((value = PyLong_FromLong(x)) == NULL)
                return -1;
        }
    }

    PDATA_PUSH(self->stack, value, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_list ( UnpicklerObject self) [static]

Definition at line 4309 of file _pickle.c.

{
    PyObject *list;
    int i;

    if ((i = marker(self)) < 0)
        return -1;

    list = Pdata_poplist(self->stack, i);
    if (list == NULL)
        return -1;
    PDATA_PUSH(self->stack, list, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_long ( UnpicklerObject self) [static]

Definition at line 3934 of file _pickle.c.

{
    PyObject *value;
    char *s;
    Py_ssize_t len;

    if ((len = _Unpickler_Readline(self, &s)) < 0)
        return -1;
    if (len < 2)
        return bad_readline();

    /* s[len-2] will usually be 'L' (and s[len-1] is '\n'); we need to remove
       the 'L' before calling PyLong_FromString.  In order to maintain
       compatibility with Python 3.0.0, we don't actually *require*
       the 'L' to be present. */
    if (s[len-2] == 'L')
        s[len-2] = '\0';
    /* XXX: Should the base argument explicitly set to 10? */
    value = PyLong_FromString(s, NULL, 0);
    if (value == NULL)
        return -1;

    PDATA_PUSH(self->stack, value, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_long_binget ( UnpicklerObject self) [static]

Definition at line 4705 of file _pickle.c.

{
    PyObject *value;
    Py_ssize_t idx;
    char *s;

    if (_Unpickler_Read(self, &s, 4) < 0)
        return -1;

    idx =  (long)Py_CHARMASK(s[0]);
    idx |= (long)Py_CHARMASK(s[1]) << 8;
    idx |= (long)Py_CHARMASK(s[2]) << 16;
    idx |= (long)Py_CHARMASK(s[3]) << 24;

    value = _Unpickler_MemoGet(self, idx);
    if (value == NULL) {
        PyObject *key = PyLong_FromSsize_t(idx);
        if (!PyErr_Occurred())
            PyErr_SetObject(PyExc_KeyError, key);
        Py_DECREF(key);
        return -1;
    }

    PDATA_APPEND(self->stack, value, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_long_binput ( UnpicklerObject self) [static]

Definition at line 4850 of file _pickle.c.

{
    PyObject *value;
    Py_ssize_t idx;
    char *s;

    if (_Unpickler_Read(self, &s, 4) < 0)
        return -1;

    if (Py_SIZE(self->stack) <= 0)
        return stack_underflow();
    value = self->stack->data[Py_SIZE(self->stack) - 1];

    idx =  (long)Py_CHARMASK(s[0]);
    idx |= (long)Py_CHARMASK(s[1]) << 8;
    idx |= (long)Py_CHARMASK(s[2]) << 16;
    idx |= (long)Py_CHARMASK(s[3]) << 24;

    return _Unpickler_MemoPut(self, idx, value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_mark ( UnpicklerObject self) [static]

Definition at line 5097 of file _pickle.c.

{

    /* Note that we split the (pickle.py) stack into two stacks, an
     * object stack and a mark stack. Here we push a mark onto the
     * mark stack.
     */

    if ((self->num_marks + 1) >= self->marks_size) {
        size_t alloc;
        int *marks;

        /* Use the size_t type to check for overflow. */
        alloc = ((size_t)self->num_marks << 1) + 20;
        if (alloc > PY_SSIZE_T_MAX || 
            alloc <= ((size_t)self->num_marks + 1)) {
            PyErr_NoMemory();
            return -1;
        }

        if (self->marks == NULL)
            marks = (int *)PyMem_Malloc(alloc * sizeof(int));
        else
            marks = (int *)PyMem_Realloc(self->marks, alloc * sizeof(int));
        if (marks == NULL) {
            PyErr_NoMemory();
            return -1;
        }
        self->marks = marks;
        self->marks_size = (Py_ssize_t)alloc;
    }

    self->marks[self->num_marks++] = Py_SIZE(self->stack);

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_newobj ( UnpicklerObject self) [static]

Definition at line 4448 of file _pickle.c.

{
    PyObject *args = NULL;
    PyObject *clsraw = NULL;
    PyTypeObject *cls;          /* clsraw cast to its true type */
    PyObject *obj;

    /* Stack is ... cls argtuple, and we want to call
     * cls.__new__(cls, *argtuple).
     */
    PDATA_POP(self->stack, args);
    if (args == NULL)
        goto error;
    if (!PyTuple_Check(args)) {
        PyErr_SetString(UnpicklingError, "NEWOBJ expected an arg " "tuple.");
        goto error;
    }

    PDATA_POP(self->stack, clsraw);
    cls = (PyTypeObject *)clsraw;
    if (cls == NULL)
        goto error;
    if (!PyType_Check(cls)) {
        PyErr_SetString(UnpicklingError, "NEWOBJ class argument "
                        "isn't a type object");
        goto error;
    }
    if (cls->tp_new == NULL) {
        PyErr_SetString(UnpicklingError, "NEWOBJ class argument "
                        "has NULL tp_new");
        goto error;
    }

    /* Call __new__. */
    obj = cls->tp_new(cls, args, NULL);
    if (obj == NULL)
        goto error;

    Py_DECREF(args);
    Py_DECREF(clsraw);
    PDATA_PUSH(self->stack, obj, -1);
    return 0;

  error:
    Py_XDECREF(args);
    Py_XDECREF(clsraw);
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_none ( UnpicklerObject self) [static]

Definition at line 3792 of file _pickle.c.

{
    PDATA_APPEND(self->stack, Py_None, -1);
    return 0;
}

Here is the caller graph for this function:

static int load_obj ( UnpicklerObject self) [static]

Definition at line 4369 of file _pickle.c.

{
    PyObject *cls, *args, *obj = NULL;
    int i;

    if ((i = marker(self)) < 0)
        return -1;

    args = Pdata_poptuple(self->stack, i + 1);
    if (args == NULL)
        return -1;

    PDATA_POP(self->stack, cls);
    if (cls) {
        obj = instantiate(cls, args);
        Py_DECREF(cls);
    }
    Py_DECREF(args);
    if (obj == NULL)
        return -1;

    PDATA_PUSH(self->stack, obj, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_persid ( UnpicklerObject self) [static]

Definition at line 4534 of file _pickle.c.

{
    PyObject *pid;
    Py_ssize_t len;
    char *s;

    if (self->pers_func) {
        if ((len = _Unpickler_Readline(self, &s)) < 0)
            return -1;
        if (len < 2)
            return bad_readline();

        pid = PyBytes_FromStringAndSize(s, len - 1);
        if (pid == NULL)
            return -1;

        /* Ugh... this does not leak since _Unpickler_FastCall() steals the
           reference to pid first. */
        pid = _Unpickler_FastCall(self, self->pers_func, pid);
        if (pid == NULL)
            return -1;

        PDATA_PUSH(self->stack, pid, -1);
        return 0;
    }
    else {
        PyErr_SetString(UnpicklingError,
                        "A load persistent id instruction was encountered,\n"
                        "but no persistent_load function was specified.");
        return -1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_pop ( UnpicklerObject self) [static]

Definition at line 4595 of file _pickle.c.

{
    int len = Py_SIZE(self->stack);

    /* Note that we split the (pickle.py) stack into two stacks,
     * an object stack and a mark stack. We have to be clever and
     * pop the right one. We do this by looking at the top of the
     * mark stack first, and only signalling a stack underflow if
     * the object stack is empty and the mark stack doesn't match
     * our expectations.
     */
    if (self->num_marks > 0 && self->marks[self->num_marks - 1] == len) {
        self->num_marks--;
    } else if (len > 0) {
        len--;
        Py_DECREF(self->stack->data[len]);
        Py_SIZE(self->stack) = len;
    } else {
        return stack_underflow();
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_pop_mark ( UnpicklerObject self) [static]

Definition at line 4619 of file _pickle.c.

{
    int i;

    if ((i = marker(self)) < 0)
        return -1;

    Pdata_clear(self->stack, i);

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_proto ( UnpicklerObject self) [static]

Definition at line 5162 of file _pickle.c.

{
    char *s;
    int i;

    if (_Unpickler_Read(self, &s, 1) < 0)
        return -1;

    i = (unsigned char)s[0];
    if (i <= HIGHEST_PROTOCOL) {
        self->proto = i;
        return 0;
    }

    PyErr_Format(PyExc_ValueError, "unsupported pickle protocol: %d", i);
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_put ( UnpicklerObject self) [static]

Definition at line 4804 of file _pickle.c.

{
    PyObject *key, *value;
    Py_ssize_t idx;
    Py_ssize_t len;
    char *s;

    if ((len = _Unpickler_Readline(self, &s)) < 0)
        return -1;
    if (len < 2)
        return bad_readline();
    if (Py_SIZE(self->stack) <= 0)
        return stack_underflow();
    value = self->stack->data[Py_SIZE(self->stack) - 1];

    key = PyLong_FromString(s, NULL, 10);
    if (key == NULL)
        return -1;
    idx = PyLong_AsSsize_t(key);
    Py_DECREF(key);
    if (idx == -1 && PyErr_Occurred())
        return -1;

    return _Unpickler_MemoPut(self, idx, value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_reduce ( UnpicklerObject self) [static]

Definition at line 5135 of file _pickle.c.

{
    PyObject *callable = NULL;
    PyObject *argtup = NULL;
    PyObject *obj = NULL;

    PDATA_POP(self->stack, argtup);
    if (argtup == NULL)
        return -1;
    PDATA_POP(self->stack, callable);
    if (callable) {
        obj = PyObject_CallObject(callable, argtup);
        Py_DECREF(callable);
    }
    Py_DECREF(argtup);

    if (obj == NULL)
        return -1;

    PDATA_PUSH(self->stack, obj, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_setitem ( UnpicklerObject self) [static]

Definition at line 4971 of file _pickle.c.

{
    return do_setitems(self, Py_SIZE(self->stack) - 2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_setitems ( UnpicklerObject self) [static]

Definition at line 4977 of file _pickle.c.

{
    return do_setitems(self, marker(self));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_short_binbytes ( UnpicklerObject self) [static]

Definition at line 4126 of file _pickle.c.

{
    PyObject *bytes;
    unsigned char x;
    char *s;

    if (_Unpickler_Read(self, &s, 1) < 0)
        return -1;

    x = (unsigned char)s[0];

    if (_Unpickler_Read(self, &s, x) < 0)
        return -1;

    bytes = PyBytes_FromStringAndSize(s, x);
    if (bytes == NULL)
        return -1;

    PDATA_PUSH(self->stack, bytes, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_short_binstring ( UnpicklerObject self) [static]

Definition at line 4178 of file _pickle.c.

{
    PyObject *str;
    unsigned char x;
    char *s;

    if (_Unpickler_Read(self, &s, 1) < 0)
        return -1;

    x = (unsigned char)s[0];

    if (_Unpickler_Read(self, &s, x) < 0)
        return -1;

    /* Convert Python 2.x strings to unicode. */
    str = PyUnicode_Decode(s, x, self->encoding, self->errors);
    if (str == NULL)
        return -1;

    PDATA_PUSH(self->stack, str, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_string ( UnpicklerObject self) [static]

Definition at line 4048 of file _pickle.c.

{
    PyObject *bytes;
    PyObject *str = NULL;
    Py_ssize_t len;
    char *s, *p;

    if ((len = _Unpickler_Readline(self, &s)) < 0)
        return -1;
    if (len < 3)
        return bad_readline();
    if ((s = strdup(s)) == NULL) {
        PyErr_NoMemory();
        return -1;
    }

    /* Strip outermost quotes */
    while (s[len - 1] <= ' ')
        len--;
    if (s[0] == '"' && s[len - 1] == '"') {
        s[len - 1] = '\0';
        p = s + 1;
        len -= 2;
    }
    else if (s[0] == '\'' && s[len - 1] == '\'') {
        s[len - 1] = '\0';
        p = s + 1;
        len -= 2;
    }
    else {
        free(s);
        PyErr_SetString(PyExc_ValueError, "insecure string pickle");
        return -1;
    }

    /* Use the PyBytes API to decode the string, since that is what is used
       to encode, and then coerce the result to Unicode. */
    bytes = PyBytes_DecodeEscape(p, len, NULL, 0, NULL);
    free(s);
    if (bytes == NULL)
        return -1;
    str = PyUnicode_FromEncodedObject(bytes, self->encoding, self->errors);
    Py_DECREF(bytes);
    if (str == NULL)
        return -1;

    PDATA_PUSH(self->stack, str, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_tuple ( UnpicklerObject self) [static]

Definition at line 4250 of file _pickle.c.

{
    PyObject *tuple;
    int i;

    if ((i = marker(self)) < 0)
        return -1;

    tuple = Pdata_poptuple(self->stack, i);
    if (tuple == NULL)
        return -1;
    PDATA_PUSH(self->stack, tuple, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int load_unicode ( UnpicklerObject self) [static]

Definition at line 4202 of file _pickle.c.

{
    PyObject *str;
    Py_ssize_t len;
    char *s;

    if ((len = _Unpickler_Readline(self, &s)) < 0)
        return -1;
    if (len < 1)
        return bad_readline();

    str = PyUnicode_DecodeRawUnicodeEscape(s, len - 1, NULL);
    if (str == NULL)
        return -1;

    PDATA_PUSH(self->stack, str, -1);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int marker ( UnpicklerObject self) [static]

Definition at line 3781 of file _pickle.c.

{
    if (self->num_marks < 1) {
        PyErr_SetString(UnpicklingError, "could not find MARK");
        return -1;
    }

    return self->marks[--self->num_marks];
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int memo_get ( PicklerObject self,
PyObject key 
) [static]

Definition at line 1220 of file _pickle.c.

{
    long *value;
    char pdata[30];
    int len;

    value = PyMemoTable_Get(self->memo, key);
    if (value == NULL)  {
        PyErr_SetObject(PyExc_KeyError, key);
        return -1;
    }

    if (!self->bin) {
        pdata[0] = GET;
        PyOS_snprintf(pdata + 1, sizeof(pdata) - 1, "%ld\n", *value);
        len = (int)strlen(pdata);
    }
    else {
        if (*value < 256) {
            pdata[0] = BINGET;
            pdata[1] = (unsigned char)(*value & 0xff);
            len = 2;
        }
        else if (*value <= 0xffffffffL) {
            pdata[0] = LONG_BINGET;
            pdata[1] = (unsigned char)(*value & 0xff);
            pdata[2] = (unsigned char)((*value >> 8) & 0xff);
            pdata[3] = (unsigned char)((*value >> 16) & 0xff);
            pdata[4] = (unsigned char)((*value >> 24) & 0xff);
            len = 5;
        }
        else { /* unlikely */
            PyErr_SetString(PicklingError,
                            "memo id too large for LONG_BINGET");
            return -1;
        }
    }

    if (_Pickler_Write(self, pdata, len) < 0)
        return -1;

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int memo_put ( PicklerObject self,
PyObject obj 
) [static]

Definition at line 1267 of file _pickle.c.

{
    long x;
    char pdata[30];
    int len;
    int status = 0;

    if (self->fast)
        return 0;

    x = PyMemoTable_Size(self->memo);
    if (PyMemoTable_Set(self->memo, obj, x) < 0)
        goto error;

    if (!self->bin) {
        pdata[0] = PUT;
        PyOS_snprintf(pdata + 1, sizeof(pdata) - 1, "%ld\n", x);
        len = strlen(pdata);
    }
    else {
        if (x < 256) {
            pdata[0] = BINPUT;
            pdata[1] = (unsigned char)x;
            len = 2;
        }
        else if (x <= 0xffffffffL) {
            pdata[0] = LONG_BINPUT;
            pdata[1] = (unsigned char)(x & 0xff);
            pdata[2] = (unsigned char)((x >> 8) & 0xff);
            pdata[3] = (unsigned char)((x >> 16) & 0xff);
            pdata[4] = (unsigned char)((x >> 24) & 0xff);
            len = 5;
        }
        else { /* unlikely */
            PyErr_SetString(PicklingError,
                            "memo id too large for LONG_BINPUT");
            return -1;
        }
    }

    if (_Pickler_Write(self, pdata, len) < 0)
        goto error;

    if (0) {
  error:
        status = -1;
    }

    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int Pdata_clear ( Pdata self,
int  clearto 
) [static]

Definition at line 193 of file _pickle.c.

{
    int i = Py_SIZE(self);

    if (clearto < 0)
        return stack_underflow();
    if (clearto >= i)
        return 0;

    while (--i >= clearto) {
        Py_CLEAR(self->data[i]);
    }
    Py_SIZE(self) = clearto;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void Pdata_dealloc ( Pdata self) [static]

Definition at line 154 of file _pickle.c.

{
    int i = Py_SIZE(self);
    while (--i >= 0) {
        Py_DECREF(self->data[i]);
    }
    PyMem_FREE(self->data);
    PyObject_Del(self);
}
static int Pdata_grow ( Pdata self) [static]

Definition at line 210 of file _pickle.c.

{
    PyObject **data = self->data;
    Py_ssize_t allocated = self->allocated;
    Py_ssize_t new_allocated;

    new_allocated = (allocated >> 3) + 6;
    /* check for integer overflow */
    if (new_allocated > PY_SSIZE_T_MAX - allocated)
        goto nomemory;
    new_allocated += allocated;
    if (new_allocated > (PY_SSIZE_T_MAX / sizeof(PyObject *)))
        goto nomemory;
    data = PyMem_REALLOC(data, new_allocated * sizeof(PyObject *));
    if (data == NULL)
        goto nomemory;

    self->data = data;
    self->allocated = new_allocated;
    return 0;

  nomemory:
    PyErr_NoMemory();
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* Pdata_New ( void  ) [static]

Definition at line 173 of file _pickle.c.

{
    Pdata *self;

    if (!(self = PyObject_New(Pdata, &Pdata_Type)))
        return NULL;
    Py_SIZE(self) = 0;
    self->allocated = 8;
    self->data = PyMem_MALLOC(self->allocated * sizeof(PyObject *));
    if (self->data)
        return (PyObject *)self;
    Py_DECREF(self);
    return PyErr_NoMemory();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* Pdata_pop ( Pdata self) [static]

Definition at line 241 of file _pickle.c.

{
    if (Py_SIZE(self) == 0) {
        PyErr_SetString(UnpicklingError, "bad pickle data");
        return NULL;
    }
    return self->data[--Py_SIZE(self)];
}

Here is the call graph for this function:

static PyObject* Pdata_poplist ( Pdata self,
Py_ssize_t  start 
) [static]

Definition at line 288 of file _pickle.c.

{
    PyObject *list;
    Py_ssize_t len, i, j;

    len = Py_SIZE(self) - start;
    list = PyList_New(len);
    if (list == NULL)
        return NULL;
    for (i = start, j = 0; j < len; i++, j++)
        PyList_SET_ITEM(list, j, self->data[i]);

    Py_SIZE(self) = start;
    return list;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* Pdata_poptuple ( Pdata self,
Py_ssize_t  start 
) [static]

Definition at line 271 of file _pickle.c.

{
    PyObject *tuple;
    Py_ssize_t len, i, j;

    len = Py_SIZE(self) - start;
    tuple = PyTuple_New(len);
    if (tuple == NULL)
        return NULL;
    for (i = start, j = 0; j < len; i++, j++)
        PyTuple_SET_ITEM(tuple, j, self->data[i]);

    Py_SIZE(self) = start;
    return tuple;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int Pdata_push ( Pdata self,
PyObject obj 
) [static]

Definition at line 252 of file _pickle.c.

{
    if (Py_SIZE(self) == self->allocated && Pdata_grow(self) < 0) {
        return -1;
    }
    self->data[Py_SIZE(self)++] = obj;
    return 0;
}

Here is the call graph for this function:

static PyObject* pickle_dump ( PyObject self,
PyObject args,
PyObject kwds 
) [static]

Definition at line 5936 of file _pickle.c.

{
    static char *kwlist[] = {"obj", "file", "protocol", "fix_imports", 0};
    PyObject *obj;
    PyObject *file;
    PyObject *proto = NULL;
    PyObject *fix_imports = Py_True;
    PicklerObject *pickler;

    /* fix_imports is a keyword-only argument.  */
    if (Py_SIZE(args) > 3) {
        PyErr_Format(PyExc_TypeError,
                     "pickle.dump() takes at most 3 positional "
                     "argument (%zd given)", Py_SIZE(args));
        return NULL;
    }

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO:dump", kwlist,
                                     &obj, &file, &proto, &fix_imports))
        return NULL;

    pickler = _Pickler_New();
    if (pickler == NULL)
        return NULL;

    if (_Pickler_SetProtocol(pickler, proto, fix_imports) < 0)
        goto error;

    if (_Pickler_SetOutputStream(pickler, file) < 0)
        goto error;

    if (dump(pickler, obj) < 0)
        goto error;

    if (_Pickler_FlushToFile(pickler) < 0)
        goto error;

    Py_DECREF(pickler);
    Py_RETURN_NONE;

  error:
    Py_XDECREF(pickler);
    return NULL;
}

Here is the call graph for this function:

static PyObject* pickle_dumps ( PyObject self,
PyObject args,
PyObject kwds 
) [static]

Definition at line 6000 of file _pickle.c.

{
    static char *kwlist[] = {"obj", "protocol", "fix_imports", 0};
    PyObject *obj;
    PyObject *proto = NULL;
    PyObject *result;
    PyObject *fix_imports = Py_True;
    PicklerObject *pickler;

    /* fix_imports is a keyword-only argument.  */
    if (Py_SIZE(args) > 2) {
        PyErr_Format(PyExc_TypeError,
                     "pickle.dumps() takes at most 2 positional "
                     "argument (%zd given)", Py_SIZE(args));
        return NULL;
    }

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO:dumps", kwlist,
                                     &obj, &proto, &fix_imports))
        return NULL;

    pickler = _Pickler_New();
    if (pickler == NULL)
        return NULL;

    if (_Pickler_SetProtocol(pickler, proto, fix_imports) < 0)
        goto error;

    if (dump(pickler, obj) < 0)
        goto error;

    result = _Pickler_GetString(pickler);
    Py_DECREF(pickler);
    return result;

  error:
    Py_XDECREF(pickler);
    return NULL;
}

Here is the call graph for this function:

static PyObject* pickle_load ( PyObject self,
PyObject args,
PyObject kwds 
) [static]

Definition at line 6065 of file _pickle.c.

{
    static char *kwlist[] = {"file", "fix_imports", "encoding", "errors", 0};
    PyObject *file;
    PyObject *fix_imports = Py_True;
    PyObject *result;
    char *encoding = NULL;
    char *errors = NULL;
    UnpicklerObject *unpickler;

    /* fix_imports, encoding and errors are a keyword-only argument.  */
    if (Py_SIZE(args) != 1) {
        PyErr_Format(PyExc_TypeError,
                     "pickle.load() takes exactly one positional "
                     "argument (%zd given)", Py_SIZE(args));
        return NULL;
    }

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|Oss:load", kwlist,
                                     &file, &fix_imports, &encoding, &errors))
        return NULL;

    unpickler = _Unpickler_New();
    if (unpickler == NULL)
        return NULL;

    if (_Unpickler_SetInputStream(unpickler, file) < 0)
        goto error;

    if (_Unpickler_SetInputEncoding(unpickler, encoding, errors) < 0)
        goto error;

    unpickler->fix_imports = PyObject_IsTrue(fix_imports);
    if (unpickler->fix_imports == -1)
        goto error;

    result = load(unpickler);
    Py_DECREF(unpickler);
    return result;

  error:
    Py_XDECREF(unpickler);
    return NULL;
}

Here is the call graph for this function:

static PyObject* pickle_loads ( PyObject self,
PyObject args,
PyObject kwds 
) [static]

Definition at line 6128 of file _pickle.c.

{
    static char *kwlist[] = {"input", "fix_imports", "encoding", "errors", 0};
    PyObject *input;
    PyObject *fix_imports = Py_True;
    PyObject *result;
    char *encoding = NULL;
    char *errors = NULL;
    UnpicklerObject *unpickler;

    /* fix_imports, encoding and errors are a keyword-only argument.  */
    if (Py_SIZE(args) != 1) {
        PyErr_Format(PyExc_TypeError,
                     "pickle.loads() takes exactly one positional "
                     "argument (%zd given)", Py_SIZE(args));
        return NULL;
    }

    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|Oss:loads", kwlist,
                                     &input, &fix_imports, &encoding, &errors))
        return NULL;

    unpickler = _Unpickler_New();
    if (unpickler == NULL)
        return NULL;

    if (_Unpickler_SetStringInput(unpickler, input) < 0)
        goto error;

    if (_Unpickler_SetInputEncoding(unpickler, encoding, errors) < 0)
        goto error;

    unpickler->fix_imports = PyObject_IsTrue(fix_imports);
    if (unpickler->fix_imports == -1)
        goto error;

    result = load(unpickler);
    Py_DECREF(unpickler);
    return result;

  error:
    Py_XDECREF(unpickler);
    return NULL;
}

Here is the call graph for this function:

static int Pickler_clear ( PicklerObject self) [static]

Definition at line 3342 of file _pickle.c.

{
    Py_CLEAR(self->output_buffer);
    Py_CLEAR(self->write);
    Py_CLEAR(self->pers_func);
    Py_CLEAR(self->arg);
    Py_CLEAR(self->fast_memo);

    if (self->memo != NULL) {
        PyMemoTable *memo = self->memo;
        self->memo = NULL;
        PyMemoTable_Del(memo);
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* Pickler_clear_memo ( PicklerObject self) [static]

Definition at line 3266 of file _pickle.c.

{
    if (self->