diff options
Diffstat (limited to 'Modules')
| -rw-r--r-- | Modules/cPickle.c | 879 | ||||
| -rw-r--r-- | Modules/cStringIO.c | 114 |
2 files changed, 648 insertions, 345 deletions
diff --git a/Modules/cPickle.c b/Modules/cPickle.c index 1f8ed9d..138a8d1 100644 --- a/Modules/cPickle.c +++ b/Modules/cPickle.c @@ -1,5 +1,5 @@ /* - $Id$ + cPickle.c,v 1.46 1997/12/04 00:08:07 jim Exp Copyright @@ -55,7 +55,7 @@ static char cPickle_module_documentation[] = "C implementation and optimization of the Python pickle module\n" "\n" -"$Id$\n" +"cPickle.c,v 1.46 1997/12/04 00:08:07 jim Exp\n" ; #include "Python.h" @@ -82,9 +82,7 @@ static char cPickle_module_documentation[] = #define POP_MARK '1' #define DUP '2' #define FLOAT 'F' -#ifdef FORMAT_1_3 #define BINFLOAT 'G' -#endif #define INT 'I' #define BININT 'J' #define BININT1 'K' @@ -134,10 +132,8 @@ static PyObject *empty_tuple; static PyObject *__class___str, *__getinitargs___str, *__dict___str, *__getstate___str, *__setstate___str, *__name___str, *__reduce___str, *write_str, *__safe_for_unpickling___str, *append_str, - *read_str, *readline_str, *__main___str; - -/* __builtins__ module */ -static PyObject *builtins; + *read_str, *readline_str, *__main___str, + *copy_reg_str, *dispatch_table_str, *safe_constructors_str; static int save(); static int put2(); @@ -155,43 +151,42 @@ typedef struct { int (*write_func)(); char *write_buf; int buf_size; + PyObject *dispatch_table; + PyObject *class_map; } Picklerobject; static PyTypeObject Picklertype; - typedef struct { - PyObject_HEAD - FILE *fp; - PyObject *file; - PyObject *readline; - PyObject *read; - PyObject *memo; - PyObject *arg; - PyObject *stack; - PyObject *mark; - PyObject *pers_func; - PyObject *last_string; - int *marks; - int num_marks; - int marks_size; - int (*read_func)(); - int (*readline_func)(); - int buf_size; - char *buf; + PyObject_HEAD + FILE *fp; + PyObject *file; + PyObject *readline; + PyObject *read; + PyObject *memo; + PyObject *arg; + PyObject *stack; + PyObject *mark; + PyObject *pers_func; + PyObject *last_string; + int *marks; + int num_marks; + int marks_size; + int (*read_func)(); + int (*readline_func)(); + int buf_size; + char *buf; + PyObject *safe_constructors; + PyObject *class_map; } Unpicklerobject; static PyTypeObject Unpicklertype; int -cPickle_PyMapping_HasKey(o, key) - PyObject *o; - PyObject *key; -{ +cPickle_PyMapping_HasKey(PyObject *o, PyObject *key) { PyObject *v; - if((v = PyObject_GetItem(o,key))) - { + if((v = PyObject_GetItem(o,key))) { Py_DECREF(v); return 1; } @@ -205,12 +200,11 @@ static PyObject * #ifdef HAVE_STDARG_PROTOTYPES /* VARARGS 2 */ -PyErr_Format(PyObject *ErrType, char *stringformat, char *format, ...) +PyErr_Format(PyObject *ErrType, char *stringformat, char *format, ...) { #else /* VARARGS */ -PyErr_Format(va_alist) va_dcl +PyErr_Format(va_alist) va_dcl { #endif -{ va_list va; PyObject *args=0, *retval=0; #ifdef HAVE_STDARG_PROTOTYPES @@ -229,10 +223,8 @@ PyErr_Format(va_alist) va_dcl if(format && ! args) return NULL; if(stringformat && !(retval=PyString_FromString(stringformat))) return NULL; - if(retval) - { - if(args) - { + if(retval) { + if(args) { PyObject *v; v=PyString_Format(retval, args); Py_DECREF(retval); @@ -243,8 +235,7 @@ PyErr_Format(va_alist) va_dcl } else if(args) retval=args; - else - { + else { PyErr_SetObject(ErrType,Py_None); return NULL; } @@ -504,8 +495,7 @@ readline_other(Unpicklerobject *self, char **s) { static char * -pystrndup(char *s, int l) -{ +pystrndup(char *s, int l) { char *r; UNLESS(r=malloc((l+1)*sizeof(char))) return (char*)PyErr_NoMemory(); memcpy(r,s,l); @@ -625,9 +615,62 @@ finally: return res; } +#define PyImport_Import cPickle_Import static PyObject * -whichmodule(PyObject *global, PyObject *global_name) { +PyImport_Import(PyObject *module_name) { + static PyObject *silly_list=0, *__builtins___str=0, *__import___str; + static PyObject *standard_builtins=0; + PyObject *globals=0, *__import__=0, *__builtins__=0, *r=0; + + UNLESS(silly_list) { + UNLESS(__import___str=PyString_FromString("__import__")) return NULL; + UNLESS(__builtins___str=PyString_FromString("__builtins__")) return NULL; + UNLESS(silly_list=Py_BuildValue("[s]","__doc__")) return NULL; + } + + if((globals=PyEval_GetGlobals())) { + Py_INCREF(globals); + UNLESS(__builtins__=PyObject_GetItem(globals,__builtins___str)) goto err; + } + else { + PyErr_Clear(); + + UNLESS(standard_builtins || + (standard_builtins=PyImport_ImportModule("__builtin__"))) + return NULL; + + __builtins__=standard_builtins; + Py_INCREF(__builtins__); + UNLESS(globals = Py_BuildValue("{sO}", "__builtins__", __builtins__)) + goto err; + } + + if(PyDict_Check(__builtins__)) { + UNLESS(__import__=PyObject_GetItem(__builtins__,__import___str)) goto err; + } + else { + UNLESS(__import__=PyObject_GetAttr(__builtins__,__import___str)) goto err; + } + + UNLESS(r=PyObject_CallFunction(__import__,"OOOO", + module_name, globals, globals, silly_list)) + goto err; + + Py_DECREF(globals); + Py_DECREF(__builtins__); + Py_DECREF(__import__); + + return r; +err: + Py_XDECREF(globals); + Py_XDECREF(__builtins__); + Py_XDECREF(__import__); + return NULL; +} + +static PyObject * +whichmodule(PyObject *class_map, PyObject *global, PyObject *global_name) { int i, j; PyObject *module = 0, *modules_dict = 0, *global_name_attr = 0, *name = 0; @@ -1052,13 +1095,11 @@ save_list(Picklerobject *self, PyObject *args) { if ((*self->write_func)(self, s, s_len) < 0) goto finally; - if (len == 0) - { + if (len == 0) { if (put(self, args) < 0) goto finally; } - else - { + else { if (put2(self, args) < 0) goto finally; } @@ -1117,13 +1158,11 @@ save_dict(Picklerobject *self, PyObject *args) { if ((len = PyDict_Size(args)) < 0) goto finally; - if (len == 0) - { + if (len == 0) { if (put(self, args) < 0) goto finally; } - else - { + else { if (put2(self, args) < 0) goto finally; } @@ -1212,7 +1251,7 @@ save_inst(Picklerobject *self, PyObject *args) { goto finally; } - UNLESS(module = whichmodule(class, name)) + UNLESS(module = whichmodule(self->class_map, class, name)) goto finally; module_str = PyString_AS_STRING((PyStringObject *)module); @@ -1290,18 +1329,16 @@ save_global(Picklerobject *self, PyObject *args, PyObject *name) { static char global = GLOBAL; - if (name) - { + if (name) { global_name = name; Py_INCREF(global_name); } - else - { + else { UNLESS(global_name = PyObject_GetAttr(args, __name___str)) goto finally; } - UNLESS(module = whichmodule(args, global_name)) + UNLESS(module = whichmodule(self->class_map, args, global_name)) goto finally; module_str = PyString_AS_STRING((PyStringObject *)module); @@ -1411,8 +1448,7 @@ save_reduce(Picklerobject *self, PyObject *callable, if ((*self->write_func)(self, &reduce, 1) < 0) return -1; - if (ob != NULL) - { + if (ob != NULL) { if (state && !PyDict_Check(state)) { if (put2(self, ob) < 0) return -1; @@ -1423,8 +1459,7 @@ save_reduce(Picklerobject *self, PyObject *callable, } } - if (state) - { + if (state) { if (save(self, state, 0) < 0) return -1; @@ -1721,11 +1756,13 @@ Pickle_clear_memo(Picklerobject *self, PyObject *args) { static struct PyMethodDef Pickler_methods[] = { {"dump", (PyCFunction)Pickler_dump, 1, - "dump(object) -- Write an object in pickle format"}, + "dump(object) --" + "Write an object in pickle format to the object's pickle stream\n" + }, {"dump_special", (PyCFunction)dump_special, 1, ""}, {"clear_memo", (PyCFunction)Pickle_clear_memo, 1, - "clear_memo() -- Clear the picklers memp"}, + "clear_memo() -- Clear the picklers memo"}, {NULL, NULL} /* sentinel */ }; @@ -1746,6 +1783,8 @@ newPicklerobject(PyObject *file, int bin) { self->write_buf = NULL; self->bin = bin; self->buf_size = 0; + self->class_map = NULL; + self->dispatch_table = NULL; Py_INCREF(file); self->file = file; @@ -1768,24 +1807,42 @@ newPicklerobject(PyObject *file, int bin) { else { self->write_func = write_other; - UNLESS(self->write = PyObject_GetAttr(file, write_str)) - { + UNLESS(self->write = PyObject_GetAttr(file, write_str)) { PyErr_Clear(); PyErr_SetString(PyExc_TypeError, "argument must have 'write' " "attribute"); - Py_XDECREF((PyObject *)self); - return NULL; + goto err; } UNLESS(self->write_buf = (char *)malloc(WRITE_BUF_SIZE * sizeof(char))) { PyErr_NoMemory(); - Py_XDECREF((PyObject *)self); - return NULL; + goto err; } } + if(PyEval_GetRestricted()) { + /* Restricted execution, get private tables */ + PyObject *m; + + UNLESS(self->class_map=PyDict_New()) goto err; + UNLESS(m=PyImport_Import(copy_reg_str)) goto err; + self->dispatch_table=PyObject_GetAttr(m, dispatch_table_str); + Py_DECREF(m); + UNLESS(self->dispatch_table) goto err; + } + else { + self->class_map=class_map; + Py_INCREF(class_map); + self->dispatch_table=dispatch_table; + Py_INCREF(dispatch_table); + } + return self; + +err: + Py_DECREF((PyObject *)self); + return NULL; } @@ -1807,6 +1864,8 @@ Pickler_dealloc(Picklerobject *self) { Py_XDECREF(self->file); Py_XDECREF(self->pers_func); Py_XDECREF(self->inst_pers_func); + Py_XDECREF(self->class_map); + Py_XDECREF(self->dispatch_table); if (self->write_buf) { free(self->write_buf); @@ -1868,7 +1927,9 @@ Pickler_setattr(Picklerobject *self, char *name, PyObject *value) { } -static char Picklertype__doc__[] = ""; +static char Picklertype__doc__[] = +"Objects that know how to pickle objects\n" +; static PyTypeObject Picklertype_value() { PyTypeObject Picklertype = { @@ -1898,100 +1959,43 @@ static PyTypeObject Picklertype_value() { return Picklertype; } - -PyObject * -PyImport_ImportModuleNi(char *module_name) -{ - char *import_str; - int size, i; - PyObject *import; - - static PyObject *eval_dict = 0; - - size = strlen(module_name); - for (i = 0; i < size; i++) { - if (((module_name[i] < 'A') || (module_name[i] > 'z')) && - (module_name[i] != '_')) { - PyErr_SetString(PyExc_ImportError, "module name contains " - "invalid characters."); - return NULL; - } - } - - UNLESS(import_str = - (char *)malloc((strlen(module_name) + 15) * sizeof(char))) { - PyErr_NoMemory(); - return NULL; - } - - sprintf(import_str, "__import__('%s')", module_name); - - UNLESS(eval_dict) - UNLESS(eval_dict = Py_BuildValue("{sO}", "__builtins__", builtins)) - return NULL; - - if (!(import = - PyRun_String(import_str, Py_eval_input, eval_dict, eval_dict))) { - free(import_str); - return NULL; - } - - free(import_str); - - return import; -} - - static PyObject * -find_class(PyObject *py_module_name, PyObject *py_class_name) { - PyObject *import = 0, *class = 0, *t = 0; - char *module_name, *class_name; - PyObject *res = NULL; +find_class(PyObject *class_map, + PyObject *py_module_name, PyObject *py_global_name) { + PyObject *global = 0, *t = 0, *module; - module_name = PyString_AS_STRING((PyStringObject *)py_module_name); - class_name = PyString_AS_STRING((PyStringObject *)py_class_name); - - UNLESS(t = PyTuple_New(2)) - goto finally; + UNLESS(t = PyTuple_New(2)) return NULL; PyTuple_SET_ITEM((PyTupleObject *)t, 0, py_module_name); Py_INCREF(py_module_name); - - PyTuple_SET_ITEM((PyTupleObject *)t, 1, py_class_name); - Py_INCREF(py_class_name); + PyTuple_SET_ITEM((PyTupleObject *)t, 1, py_global_name); + Py_INCREF(py_global_name); - if ((class = PyDict_GetItem(class_map, t))) { - res = class; - Py_INCREF(class); - goto finally; + global=PyDict_GetItem(class_map, t); + + if (global) { + Py_DECREF(t); + Py_INCREF(global); + return global; } PyErr_Clear(); - if (!(import = PyImport_ImportModuleNi(module_name)) || - !(class = PyObject_GetAttr(import, py_class_name))) { - PyErr_Format(PyExc_SystemError, "Failed to import global %s " - "from module %s", "ss", class_name, module_name); - goto finally; - } - - if (PyDict_SetItem(class_map, t, class) < 0) - goto finally; + UNLESS(module=PyImport_Import(py_module_name)) return NULL; + global=PyObject_GetAttr(module, py_global_name); + Py_DECREF(module); + UNLESS(global) return NULL; - res = class; + if (PyDict_SetItem(class_map, t, global) < 0) global=NULL; + Py_DECREF(t); -finally: - Py_XDECREF(import); - Py_XDECREF(t); - - return res; + return global; } static int marker(Unpicklerobject *self) { - if (self->num_marks < 1) - { + if (self->num_marks < 1) { PyErr_SetString(UnpicklingError, "could not find MARK"); return -1; } @@ -2177,7 +2181,6 @@ finally: return res; } -#ifdef FORMAT_1_3 static int load_binfloat(Unpicklerobject *self) { PyObject *py_float = 0; @@ -2250,7 +2253,6 @@ finally: return res; } -#endif static int load_string(Unpicklerobject *self) { @@ -2506,14 +2508,40 @@ finally: } static PyObject * -Instance_New(PyObject *cls, PyObject *args) -{ +Instance_New(PyObject *cls, PyObject *args) { int has_key; PyObject *safe=0, *r=0; - if (PyClass_Check(cls)) - if((r=PyInstance_New(cls, args, NULL))) return r; - else goto err; + if (PyClass_Check(cls)) { + int l; + + if((l=PyObject_Length(args)) < 0) goto err; + UNLESS(l) { + PyObject *__getinitargs__; + + UNLESS(__getinitargs__=PyObject_GetAttr(cls, __getinitargs___str)) { + /* We have a class with no __getinitargs__, so bypass usual + construction */ + PyInstanceObject *inst; + + PyErr_Clear(); + UNLESS(inst=PyObject_NEW(PyInstanceObject, &PyInstance_Type)) + goto err; + inst->in_class=(PyClassObject*)cls; + Py_INCREF(cls); + UNLESS(inst->in_dict=PyDict_New()) { + Py_DECREF(inst); + goto err; + } + + return (PyObject *)inst; + } + Py_DECREF(__getinitargs__); + } + + if((r=PyInstance_New(cls, args, NULL))) return r; + else goto err; + } if ((has_key = cPickle_PyMapping_HasKey(safe_constructors, cls)) < 0) @@ -2534,8 +2562,7 @@ err: PyObject *tp, *v, *tb; PyErr_Fetch(&tp, &v, &tb); - if((r=Py_BuildValue("OOO",v,cls,args))) - { + if((r=Py_BuildValue("OOO",v,cls,args))) { Py_XDECREF(v); v=r; } @@ -2553,9 +2580,6 @@ load_obj(Unpicklerobject *self) { if ((i = marker(self)) < 0) goto finally; - class = PyList_GET_ITEM((PyListObject *)self->stack, i); - Py_INCREF(class); - if ((len = PyList_Size(self->stack)) < 0) goto finally; @@ -2565,6 +2589,9 @@ load_obj(Unpicklerobject *self) { UNLESS(tup = PySequence_Tuple(slice)) goto finally; + class = PyList_GET_ITEM((PyListObject *)self->stack, i); + Py_INCREF(class); + UNLESS(obj = Instance_New(class, tup)) goto finally; @@ -2594,41 +2621,30 @@ load_inst(Unpicklerobject *self) { int i, j, len, res = -1; char *s; - if ((i = marker(self)) < 0) - goto finally; + if ((i = marker(self)) < 0) goto finally; - if ((j = PyList_Size(self->stack)) < 0) - goto finally; + if ((j = PyList_Size(self->stack)) < 0) goto finally; - UNLESS(arg_slice = PyList_GetSlice(self->stack, i, j)) - goto finally; + UNLESS(arg_slice = PyList_GetSlice(self->stack, i, j)) goto finally; - UNLESS(arg_tup = PySequence_Tuple(arg_slice)) - goto finally; + UNLESS(arg_tup = PySequence_Tuple(arg_slice)) goto finally; - if (DEL_LIST_SLICE(self->stack, i, j) < 0) - goto finally; + if (DEL_LIST_SLICE(self->stack, i, j) < 0) goto finally; - if ((len = (*self->readline_func)(self, &s)) < 0) - goto finally; + if ((len = (*self->readline_func)(self, &s)) < 0) goto finally; - UNLESS(module_name = PyString_FromStringAndSize(s, len - 1)) - goto finally; + UNLESS(module_name = PyString_FromStringAndSize(s, len - 1)) goto finally; - if ((len = (*self->readline_func)(self, &s)) < 0) - goto finally; + if ((len = (*self->readline_func)(self, &s)) < 0) goto finally; - UNLESS(class_name = PyString_FromStringAndSize(s, len - 1)) - goto finally; + UNLESS(class_name = PyString_FromStringAndSize(s, len - 1)) goto finally; - UNLESS(class = find_class(module_name, class_name)) + UNLESS(class = find_class(self->class_map, module_name, class_name)) goto finally; - UNLESS(obj = Instance_New(class, arg_tup)) - goto finally; + UNLESS(obj = Instance_New(class, arg_tup)) goto finally; - if (PyList_Append(self->stack, obj) < 0) - goto finally; + if (PyList_Append(self->stack, obj) < 0) goto finally; res = 0; @@ -2662,7 +2678,7 @@ load_global(Unpicklerobject *self) { UNLESS(class_name = PyString_FromStringAndSize(s, len - 1)) goto finally; - UNLESS(class = find_class(module_name, class_name)) + UNLESS(class = find_class(self->class_map, module_name, class_name)) goto finally; if (PyList_Append(self->stack, class) < 0) @@ -2692,20 +2708,32 @@ load_persid(Unpicklerobject *self) { UNLESS(pid = PyString_FromStringAndSize(s, len - 1)) goto finally; - UNLESS(self->arg) - UNLESS(self->arg = PyTuple_New(1)) - goto finally; + if(PyList_Check(self->pers_func)) { + if(PyList_Append(self->pers_func, pid) < 0) goto finally; + pers_load_val=pid; + Py_INCREF(pid); + } + else { + UNLESS(self->arg) + UNLESS(self->arg = PyTuple_New(1)) + goto finally; - Py_INCREF(pid); - if (PyTuple_SetItem(self->arg, 0, pid) < 0) - goto finally; + Py_INCREF(pid); + if (PyTuple_SetItem(self->arg, 0, pid) < 0) + goto finally; - UNLESS(pers_load_val = - PyObject_CallObject(self->pers_func, self->arg)) - goto finally; - - if (PyList_Append(self->stack, pers_load_val) < 0) - goto finally; + UNLESS(pers_load_val = + PyObject_CallObject(self->pers_func, self->arg)) + goto finally; + } + if (PyList_Append(self->stack, pers_load_val) < 0) + goto finally; + } + else { + PyErr_SetString(UnpicklingError, + "A load persistent id instruction was encountered,\n" + "but no persistent_load function was specified."); + goto finally; } res = 0; @@ -2733,21 +2761,33 @@ load_binpersid(Unpicklerobject *self) { if (DEL_LIST_SLICE(self->stack, len - 1, len) < 0) goto finally; - UNLESS(self->arg) + if(PyList_Check(self->pers_func)) { + if(PyList_Append(self->pers_func, pid) < 0) goto finally; + pers_load_val=pid; + Py_INCREF(pid); + } + else { + UNLESS(self->arg) UNLESS(self->arg = PyTuple_New(1)) - goto finally; + goto finally; - Py_INCREF(pid); - if (PyTuple_SetItem(self->arg, 0, pid) < 0) + Py_INCREF(pid); + if (PyTuple_SetItem(self->arg, 0, pid) < 0) goto finally; - UNLESS(pers_load_val = - PyObject_CallObject(self->pers_func, self->arg)) + UNLESS(pers_load_val = + PyObject_CallObject(self->pers_func, self->arg)) goto finally; - + } if (PyList_Append(self->stack, pers_load_val) < 0) goto finally; } + else { + PyErr_SetString(UnpicklingError, + "A load persistent id instruction was encountered,\n" + "but no persistent_load function was specified."); + goto finally; + } res = 0; @@ -3148,8 +3188,7 @@ load_build(Unpicklerobject *self) { UNLESS(inst = PyList_GetItem(self->stack, len - 2)) goto finally; - UNLESS(__setstate__ = PyObject_GetAttr(inst, __setstate___str)) - { + UNLESS(__setstate__ = PyObject_GetAttr(inst, __setstate___str)) { PyErr_Clear(); UNLESS(instdict = PyObject_GetAttr(inst, __dict___str)) @@ -3247,8 +3286,7 @@ finally: } static PyObject * -load(Unpicklerobject *self) -{ +load(Unpicklerobject *self) { PyObject *stack = 0, *err = 0, *val = 0; int len; char *s; @@ -3493,6 +3531,303 @@ err: } +/* No-load functions to support noload, which is used to + find persistent references. */ + +static int +noload_obj(Unpicklerobject *self) { + int i, len; + + if ((i = marker(self)) < 0) return -1; + if ((len = PyList_Size(self->stack)) < 0) return -1; + return DEL_LIST_SLICE(self->stack, i+1, len); +} + + +static int +noload_inst(Unpicklerobject *self) { + int i, j; + char *s; + + if ((i = marker(self)) < 0) return -1; + if ((j = PyList_Size(self->stack)) < 0) return -1; + if (DEL_LIST_SLICE(self->stack, i, j) < 0) return -1; + if ((*self->readline_func)(self, &s) < 0) return -1; + if ((*self->readline_func)(self, &s) < 0) return -1; + return PyList_Append(self->stack, Py_None); +} + +static int +noload_global(Unpicklerobject *self) { + char *s; + + if ((*self->readline_func)(self, &s) < 0) return -1; + if ((*self->readline_func)(self, &s) < 0) return -1; + return PyList_Append(self->stack, Py_None); +} + +static int +noload_reduce(Unpicklerobject *self) { + int len; + + if ((len = PyList_Size(self->stack)) < 0) return -1; + if (DEL_LIST_SLICE(self->stack, len - 2, len) < 0) return -1; + return PyList_Append(self->stack, Py_None); +} + +static int +noload_build(Unpicklerobject *self) { + int len; + + if ((len = PyList_Size(self->stack)) < 0) return -1; + return DEL_LIST_SLICE(self->stack, len - 1, len); +} + + +static PyObject * +noload(Unpicklerobject *self) { + PyObject *stack = 0, *err = 0, *val = 0; + int len; + char *s; + + UNLESS(stack = PyList_New(0)) + goto err; + + self->stack = stack; + self->num_marks = 0; + + while (1) { + if ((*self->read_func)(self, &s, 1) < 0) + break; + + switch (s[0]) { + case NONE: + if (load_none(self) < 0) + break; + continue; + + case BININT: + if (load_binint(self) < 0) + break; + continue; + + case BININT1: + if (load_binint1(self) < 0) + break; + continue; + + case BININT2: + if (load_binint2(self) < 0) + break; + continue; + + case INT: + if (load_int(self) < 0) + break; + continue; + + case LONG: + if (load_long(self) < 0) + break; + continue; + + case FLOAT: + if (load_float(self) < 0) + break; + continue; + + case BINFLOAT: + if (load_binfloat(self) < 0) + break; + continue; + + case BINSTRING: + if (load_binstring(self) < 0) + break; + continue; + + case SHORT_BINSTRING: + if (load_short_binstring(self) < 0) + break; + continue; + + case STRING: + if (load_string(self) < 0) + break; + continue; + + case EMPTY_TUPLE: + if (load_empty_tuple(self) < 0) + break; + continue; + + case TUPLE: + if (load_tuple(self) < 0) + break; + continue; + + case EMPTY_LIST: + if (load_empty_list(self) < 0) + break; + continue; + + case LIST: + if (load_list(self) < 0) + break; + continue; + + case EMPTY_DICT: + if (load_empty_dict(self) < 0) + break; + continue; + + case DICT: + if (load_dict(self) < 0) + break; + continue; + + case OBJ: + if (noload_obj(self) < 0) + break; + continue; + + case INST: + if (noload_inst(self) < 0) + break; + continue; + + case GLOBAL: + if (noload_global(self) < 0) + break; + continue; + + case APPEND: + if (load_append(self) < 0) + break; + continue; + + case APPENDS: + if (load_appends(self) < 0) + break; + continue; + + case BUILD: + if (noload_build(self) < 0) + break; + continue; + + case DUP: + if (load_dup(self) < 0) + break; + continue; + + case BINGET: + if (load_binget(self) < 0) + break; + continue; + + case LONG_BINGET: + if (load_long_binget(self) < 0) + break; + continue; + + case GET: + if (load_get(self) < 0) + break; + continue; + + case MARK: + if (load_mark(self) < 0) + break; + continue; + + case BINPUT: + if (load_binput(self) < 0) + break; + continue; + + case LONG_BINPUT: + if (load_long_binput(self) < 0) + break; + continue; + + case PUT: + if (load_put(self) < 0) + break; + continue; + + case POP: + if (load_pop(self) < 0) + break; + continue; + + case POP_MARK: + if (load_pop_mark(self) < 0) + break; + continue; + + case SETITEM: + if (load_setitem(self) < 0) + break; + continue; + + case SETITEMS: + if (load_setitems(self) < 0) + break; + continue; + + case STOP: + break; + + case PERSID: + if (load_persid(self) < 0) + break; + continue; + + case BINPERSID: + if (load_binpersid(self) < 0) + break; + continue; + + case REDUCE: + if (noload_reduce(self) < 0) + break; + continue; + + default: + PyErr_Format(UnpicklingError, "invalid load key, '%s'.", + "c", s[0]); + goto err; + } + + break; + } + + if ((err = PyErr_Occurred()) == PyExc_EOFError) { + PyErr_SetNone(PyExc_EOFError); + goto err; + } + + if (err) goto err; + + if ((len = PyList_Size(stack)) < 0) goto err; + + UNLESS(val = PyList_GetItem(stack, len - 1)) goto err; + Py_INCREF(val); + + Py_DECREF(stack); + + self->stack=NULL; + return val; + +err: + self->stack=NULL; + Py_XDECREF(stack); + + return NULL; +} + + static PyObject * Unpickler_load(Unpicklerobject *self, PyObject *args) { UNLESS(PyArg_ParseTuple(args, "")) @@ -3501,9 +3836,27 @@ Unpickler_load(Unpicklerobject *self, PyObject *args) { return load(self); } +static PyObject * +Unpickler_noload(Unpicklerobject *self, PyObject *args) { + UNLESS(PyArg_ParseTuple(args, "")) + return NULL; + + return noload(self); +} + static struct PyMethodDef Unpickler_methods[] = { - {"load", (PyCFunction)Unpickler_load, 1, ""}, + {"load", (PyCFunction)Unpickler_load, 1, + "load() -- Load a pickle" + }, + {"noload", (PyCFunction)Unpickler_noload, 1, + "noload() -- not load a pickle, but go through most of the motions\n" + "\n" + "This function can be used to read past a pickle without instantiating\n" + "any objects or importing any modules. It can also be used to find all\n" + "persistent references without instantiating any objects or importing\n" + "any modules.\n" + }, {NULL, NULL} /* sentinel */ }; @@ -3553,17 +3906,36 @@ newUnpicklerobject(PyObject *f) { self->readline_func = readline_other; UNLESS((self->readline = PyObject_GetAttr(f, readline_str)) && - (self->read = PyObject_GetAttr(f, read_str))) - { + (self->read = PyObject_GetAttr(f, read_str))) { PyErr_Clear(); PyErr_SetString( PyExc_TypeError, "argument must have 'read' and " "'readline' attributes" ); - Py_XDECREF((PyObject *)self); - return NULL; + goto err; } } + if(PyEval_GetRestricted()) { + /* Restricted execution, get private tables */ + PyObject *m; + + UNLESS(self->class_map=PyDict_New()) goto err; + UNLESS(m=PyImport_Import(copy_reg_str)) goto err; + self->safe_constructors=PyObject_GetAttr(m, safe_constructors_str); + Py_DECREF(m); + UNLESS(self->safe_constructors) goto err; + } + else { + self->class_map=class_map; + Py_INCREF(class_map); + self->safe_constructors=safe_constructors; + Py_INCREF(safe_constructors); + } + return self; + +err: + Py_DECREF((PyObject *)self); + return NULL; } @@ -3587,6 +3959,8 @@ Unpickler_dealloc(Unpicklerobject *self) { Py_XDECREF(self->pers_func); Py_XDECREF(self->arg); Py_XDECREF(self->last_string); + Py_XDECREF(self->class_map); + Py_XDECREF(self->safe_constructors); if (self->marks) { free(self->marks); @@ -3752,7 +4126,8 @@ finally: } -static char Unpicklertype__doc__[] = ""; +static char Unpicklertype__doc__[] = +"Objects that know how to unpickle"; static PyTypeObject Unpicklertype_value() { PyTypeObject Unpicklertype = { @@ -3783,12 +4158,35 @@ static PyTypeObject Unpicklertype_value() { } static struct PyMethodDef cPickle_methods[] = { - {"dump", (PyCFunction)cpm_dump, 1, ""}, - {"dumps", (PyCFunction)cpm_dumps, 1, ""}, - {"load", (PyCFunction)cpm_load, 1, ""}, - {"loads", (PyCFunction)cpm_loads, 1, ""}, - {"Pickler", (PyCFunction)get_Pickler, 1, ""}, - {"Unpickler", (PyCFunction)get_Unpickler, 1, ""}, + {"dump", (PyCFunction)cpm_dump, 1, + "dump(object, file, [binary]) --" + "Write an object in pickle format to the given file\n" + "\n" + "If the optional argument, binary, is provided and is true, then the\n" + "pickle will be written in binary format, which is more space and\n" + "computationally efficient. \n" + }, + {"dumps", (PyCFunction)cpm_dumps, 1, + "dumps(object, [binary]) --" + "Return a string containing an object in pickle format\n" + "\n" + "If the optional argument, binary, is provided and is true, then the\n" + "pickle will be written in binary format, which is more space and\n" + "computationally efficient. \n" + }, + {"load", (PyCFunction)cpm_load, 1, + "load(file) -- Load a pickle from the given file"}, + {"loads", (PyCFunction)cpm_loads, 1, + "loads(string) -- Load a pickle from the given string"}, + {"Pickler", (PyCFunction)get_Pickler, 1, + "Pickler(file, [binary]) -- Create a pickler\n" + "\n" + "If the optional argument, binary, is provided and is true, then\n" + "pickles will be written in binary format, which is more space and\n" + "computationally efficient. \n" + }, + {"Unpickler", (PyCFunction)get_Unpickler, 1, + "Unpickler(file) -- Create an unpickler"}, { NULL, NULL } }; @@ -3826,23 +4224,29 @@ init_stuff(PyObject *module, PyObject *module_dict) { INIT_STR(append); INIT_STR(read); INIT_STR(readline); - - UNLESS(builtins = PyImport_ImportModule("__builtin__")) - return -1; + INIT_STR(copy_reg); + INIT_STR(dispatch_table); + INIT_STR(safe_constructors); UNLESS(copy_reg = PyImport_ImportModule("copy_reg")) return -1; - UNLESS(dispatch_table = PyObject_GetAttrString(copy_reg, - "dispatch_table")) + /* These next few are special because we want to use different + ones in restricted mode. */ + + UNLESS(dispatch_table = PyObject_GetAttr(copy_reg, dispatch_table_str)) return -1; - UNLESS(safe_constructors = PyObject_GetAttrString(copy_reg, - "safe_constructors")) + UNLESS(safe_constructors = PyObject_GetAttr(copy_reg, + safe_constructors_str)) return -1; Py_DECREF(copy_reg); + UNLESS(class_map = PyDict_New()) return -1; + + /* Down to here ********************************** */ + UNLESS(string = PyImport_ImportModule("string")) return -1; @@ -3854,9 +4258,6 @@ init_stuff(PyObject *module, PyObject *module_dict) { UNLESS(empty_tuple = PyTuple_New(0)) return -1; - UNLESS(class_map = PyDict_New()) - return -1; - UNLESS(PicklingError = PyString_FromString("cPickle.PicklingError")) return -1; @@ -3876,26 +4277,13 @@ init_stuff(PyObject *module, PyObject *module_dict) { return 0; } - -/* Initialization function for the module (*must* be called initcPickle) */ void initcPickle() { PyObject *m, *d, *v; - static char revbuf[] = "$Revision$"; - char *rev = revbuf; + char *rev="1.46"; PyObject *format_version; PyObject *compatible_formats; - /* Fix up the revision number */ - if (rev[0] == '$') { - char *p = strchr(rev, ' '); - if (p) { - rev = p+1; - p = strrchr(rev, ' '); - if (p) - *p = '\0'; - } - } /* Create the module and add the functions */ m = Py_InitModule4("cPickle", cPickle_methods, @@ -3907,8 +4295,7 @@ initcPickle() { /* Add some symbolic constants to the module */ d = PyModule_GetDict(m); - v = PyString_FromString(rev); - PyDict_SetItemString(d,"__version__", v); + PyDict_SetItemString(d,"__version__", v = PyString_FromString(rev)); Py_XDECREF(v); #ifdef FORMAT_1_3 diff --git a/Modules/cStringIO.c b/Modules/cStringIO.c index ff47b70..5d9597f 100644 --- a/Modules/cStringIO.c +++ b/Modules/cStringIO.c @@ -1,6 +1,6 @@ /* - $Id$ + cStringIO.c,v 1.23 1997/12/04 00:12:05 jim Exp A simple fast partial StringIO replacement. @@ -85,7 +85,7 @@ static char cStringIO_module_documentation[] = "If someone else wants to provide a more complete implementation,\n" "go for it. :-) \n" "\n" -"$Id$\n" +"cStringIO.c,v 1.23 1997/12/04 00:12:05 jim Exp\n" ; #include "Python.h" @@ -141,17 +141,14 @@ static PyObject * O_seek(Oobject *self, PyObject *args) { int position, mode = 0; - UNLESS(PyArg_ParseTuple(args, "i|i", &position, &mode)) - { + UNLESS(PyArg_ParseTuple(args, "i|i", &position, &mode)) { return NULL; } - if (mode == 2) - { + if (mode == 2) { position += self->string_size; } - else if (mode == 1) - { + else if (mode == 1) { position += self->pos; } @@ -171,8 +168,7 @@ O_cread(PyObject *self, char **output, int n) { int l; l = ((Oobject*)self)->string_size - ((Oobject*)self)->pos; - if (n < 0 || n > l) - { + if (n < 0 || n > l) { n = l; } @@ -234,14 +230,12 @@ O_cwrite(PyObject *self, char *c, int l) { int newl; newl=((Oobject*)self)->pos+l; - if(newl >= ((Oobject*)self)->buf_size) - { + if(newl >= ((Oobject*)self)->buf_size) { ((Oobject*)self)->buf_size*=2; if(((Oobject*)self)->buf_size <= newl) ((Oobject*)self)->buf_size=newl+1; UNLESS(((Oobject*)self)->buf= (char*)realloc(((Oobject*)self)->buf, - (((Oobject*)self)->buf_size) *sizeof(char))) - { + (((Oobject*)self)->buf_size) *sizeof(char))) { PyErr_SetString(PyExc_MemoryError,"out of memory"); ((Oobject*)self)->buf_size=((Oobject*)self)->pos=0; return -1; @@ -252,8 +246,7 @@ O_cwrite(PyObject *self, char *c, int l) { ((Oobject*)self)->pos += l; - if (((Oobject*)self)->string_size < ((Oobject*)self)->pos) - { + if (((Oobject*)self)->string_size < ((Oobject*)self)->pos) { ((Oobject*)self)->string_size = ((Oobject*)self)->pos; } @@ -340,29 +333,24 @@ O_writelines(Oobject *self, PyObject *args) { PyObject *string_module = 0; static PyObject *string_joinfields = 0; - UNLESS(PyArg_Parse(args, "O", args)) - { + UNLESS(PyArg_Parse(args, "O", args)) { return NULL; } - if (!string_joinfields) - { - UNLESS(string_module = PyImport_ImportModule("string")) - { + if (!string_joinfields) { + UNLESS(string_module = PyImport_ImportModule("string")) { return NULL; } UNLESS(string_joinfields= - PyObject_GetAttrString(string_module, "joinfields")) - { + PyObject_GetAttrString(string_module, "joinfields")) { return NULL; } Py_DECREF(string_module); } - if (PyObject_Length(args) == -1) - { + if (PyObject_Length(args) == -1) { return NULL; } @@ -462,8 +450,7 @@ newOobject(int size) { self->string_size = 0; self->softspace = 0; - UNLESS(self->buf=malloc(size*sizeof(char))) - { + UNLESS(self->buf=malloc(size*sizeof(char))) { PyErr_SetString(PyExc_MemoryError,"out of memory"); self->buf_size = 0; return NULL; @@ -628,74 +615,3 @@ initcStringIO() { /* Check for errors */ if (PyErr_Occurred()) Py_FatalError("can't initialize module cStringIO"); } - - -/****************************************************************************** - - $Log$ - Revision 2.8 1997/09/03 18:19:38 guido - #Plug small memory leaks in constructors. - - Revision 2.7 1997/09/03 00:09:26 guido - Fix the bug Jeremy was experiencing: both the close() and the - dealloc() functions contained code to free/DECREF the buffer - (there were differences between I and O objects but the logic bug was - the same). Fixed this be setting the buffer pointer to NULL and - testing for that. (This also makes it safe to call close() more than - once.) - - XXX Worry: what if you try to read() or write() once the thing is - closed? - - Revision 2.6 1997/08/13 03:14:41 guido - cPickle release 0.3 from Jim Fulton - - Revision 1.21 1997/06/19 18:51:42 jim - Added ident string. - - Revision 1.20 1997/06/13 20:50:50 jim - - Various changes to make gcc -Wall -pedantic happy, including - getting rid of staticforward declarations and adding pretend use - of two statics defined in .h file. - - Revision 1.19 1997/06/02 18:15:17 jim - Merged in guido's changes. - - Revision 1.18 1997/05/07 16:26:47 jim - getvalue() can nor be given an argument. If this argument is true, - then getvalue returns the text upto the current position. Otherwise - it returns all of the text. The default value of the argument is - false. - - Revision 1.17 1997/04/17 18:02:46 chris - getvalue() now returns entire string, not just the string up to - current position - - Revision 2.5 1997/04/11 19:56:06 guido - My own patch: support writable 'softspace' attribute. - - > Jim asked: What is softspace for? - - It's an old feature. The print statement uses this to remember - whether it should insert a space before the next item or not. - Implementation is in fileobject.c. - - Revision 1.11 1997/01/23 20:45:01 jim - ANSIfied it. - Changed way C API was exported. - - Revision 1.10 1997/01/02 15:19:55 chris - checked in to be sure repository is up to date. - - Revision 1.9 1996/12/27 21:40:29 jim - Took out some lamosities in interface, like returning self from - write. - - Revision 1.8 1996/12/23 15:52:49 jim - Added ifdef to check for CObject before using it. - - Revision 1.7 1996/12/23 15:22:35 jim - Finished implementation, adding full compatibility with StringIO, and - then some. - - *****************************************************************************/ |