--- /dev/null
+\r
+/* Write Python objects to files and read them back.\r
+ This is intended for writing and reading compiled Python code only;\r
+ a true persistent storage facility would be much harder, since\r
+ it would have to take circular links and sharing into account. */\r
+\r
+#define PY_SSIZE_T_CLEAN\r
+\r
+#include "Python.h"\r
+#include "longintrepr.h"\r
+#include "code.h"\r
+#include "marshal.h"\r
+\r
+#ifndef ABS\r
+ #define ABS(x) ((x) < 0 ? -(x) : (x))\r
+#endif\r
+\r
+/* High water mark to determine when the marshalled object is dangerously deep\r
+ * and risks coring the interpreter. When the object stack gets this deep,\r
+ * raise an exception instead of continuing.\r
+ */\r
+#define MAX_MARSHAL_STACK_DEPTH 2000\r
+\r
+#define TYPE_NULL '0'\r
+#define TYPE_NONE 'N'\r
+#define TYPE_FALSE 'F'\r
+#define TYPE_TRUE 'T'\r
+#define TYPE_STOPITER 'S'\r
+#define TYPE_ELLIPSIS '.'\r
+#define TYPE_INT 'i'\r
+#define TYPE_INT64 'I'\r
+#define TYPE_FLOAT 'f'\r
+#define TYPE_BINARY_FLOAT 'g'\r
+#define TYPE_COMPLEX 'x'\r
+#define TYPE_BINARY_COMPLEX 'y'\r
+#define TYPE_LONG 'l'\r
+#define TYPE_STRING 's'\r
+#define TYPE_INTERNED 't'\r
+#define TYPE_STRINGREF 'R'\r
+#define TYPE_TUPLE '('\r
+#define TYPE_LIST '['\r
+#define TYPE_DICT '{'\r
+#define TYPE_CODE 'c'\r
+#define TYPE_UNICODE 'u'\r
+#define TYPE_UNKNOWN '?'\r
+#define TYPE_SET '<'\r
+#define TYPE_FROZENSET '>'\r
+\r
+#define WFERR_OK 0\r
+#define WFERR_UNMARSHALLABLE 1\r
+#define WFERR_NESTEDTOODEEP 2\r
+#define WFERR_NOMEMORY 3\r
+\r
+typedef struct {\r
+ FILE *fp;\r
+ int error; /* see WFERR_* values */\r
+ int depth;\r
+ /* If fp == NULL, the following are valid: */\r
+ PyObject *str;\r
+ char *ptr;\r
+ char *end;\r
+ PyObject *strings; /* dict on marshal, list on unmarshal */\r
+ int version;\r
+} WFILE;\r
+\r
+#define w_byte(c, p) if (((p)->fp)) putc((c), (p)->fp); \\r
+ else if ((p)->ptr != (p)->end) *(p)->ptr++ = (c); \\r
+ else w_more(c, p)\r
+\r
+static void\r
+w_more(int c, WFILE *p)\r
+{\r
+ Py_ssize_t size, newsize;\r
+ if (p->str == NULL)\r
+ return; /* An error already occurred */\r
+ size = PyString_Size(p->str);\r
+ newsize = size + size + 1024;\r
+ if (newsize > 32*1024*1024) {\r
+ newsize = size + (size >> 3); /* 12.5% overallocation */\r
+ }\r
+ if (_PyString_Resize(&p->str, newsize) != 0) {\r
+ p->ptr = p->end = NULL;\r
+ }\r
+ else {\r
+ p->ptr = PyString_AS_STRING((PyStringObject *)p->str) + size;\r
+ p->end =\r
+ PyString_AS_STRING((PyStringObject *)p->str) + newsize;\r
+ *p->ptr++ = Py_SAFE_DOWNCAST(c, int, char);\r
+ }\r
+}\r
+\r
+static void\r
+w_string(char *s, int n, WFILE *p)\r
+{\r
+ if (p->fp != NULL) {\r
+ fwrite(s, 1, n, p->fp);\r
+ }\r
+ else {\r
+ while (--n >= 0) {\r
+ w_byte(*s, p);\r
+ s++;\r
+ }\r
+ }\r
+}\r
+\r
+static void\r
+w_short(int x, WFILE *p)\r
+{\r
+ w_byte((char)( x & 0xff), p);\r
+ w_byte((char)((x>> 8) & 0xff), p);\r
+}\r
+\r
+static void\r
+w_long(long x, WFILE *p)\r
+{\r
+ w_byte((char)( x & 0xff), p);\r
+ w_byte((char)((x>> 8) & 0xff), p);\r
+ w_byte((char)((x>>16) & 0xff), p);\r
+ w_byte((char)((x>>24) & 0xff), p);\r
+}\r
+\r
+#if SIZEOF_LONG > 4\r
+static void\r
+w_long64(long x, WFILE *p)\r
+{\r
+ w_long(x, p);\r
+ w_long(x>>32, p);\r
+}\r
+#endif\r
+\r
+/* We assume that Python longs are stored internally in base some power of\r
+ 2**15; for the sake of portability we'll always read and write them in base\r
+ exactly 2**15. */\r
+\r
+#define PyLong_MARSHAL_SHIFT 15\r
+#define PyLong_MARSHAL_BASE ((short)1 << PyLong_MARSHAL_SHIFT)\r
+#define PyLong_MARSHAL_MASK (PyLong_MARSHAL_BASE - 1)\r
+#if PyLong_SHIFT % PyLong_MARSHAL_SHIFT != 0\r
+#error "PyLong_SHIFT must be a multiple of PyLong_MARSHAL_SHIFT"\r
+#endif\r
+#define PyLong_MARSHAL_RATIO (PyLong_SHIFT / PyLong_MARSHAL_SHIFT)\r
+\r
+static void\r
+w_PyLong(const PyLongObject *ob, WFILE *p)\r
+{\r
+ Py_ssize_t i, j, n, l;\r
+ digit d;\r
+\r
+ w_byte(TYPE_LONG, p);\r
+ if (Py_SIZE(ob) == 0) {\r
+ w_long((long)0, p);\r
+ return;\r
+ }\r
+\r
+ /* set l to number of base PyLong_MARSHAL_BASE digits */\r
+ n = ABS(Py_SIZE(ob));\r
+ l = (n-1) * PyLong_MARSHAL_RATIO;\r
+ d = ob->ob_digit[n-1];\r
+ assert(d != 0); /* a PyLong is always normalized */\r
+ do {\r
+ d >>= PyLong_MARSHAL_SHIFT;\r
+ l++;\r
+ } while (d != 0);\r
+ w_long((long)(Py_SIZE(ob) > 0 ? l : -l), p);\r
+\r
+ for (i=0; i < n-1; i++) {\r
+ d = ob->ob_digit[i];\r
+ for (j=0; j < PyLong_MARSHAL_RATIO; j++) {\r
+ w_short(d & PyLong_MARSHAL_MASK, p);\r
+ d >>= PyLong_MARSHAL_SHIFT;\r
+ }\r
+ assert (d == 0);\r
+ }\r
+ d = ob->ob_digit[n-1];\r
+ do {\r
+ w_short(d & PyLong_MARSHAL_MASK, p);\r
+ d >>= PyLong_MARSHAL_SHIFT;\r
+ } while (d != 0);\r
+}\r
+\r
+static void\r
+w_object(PyObject *v, WFILE *p)\r
+{\r
+ Py_ssize_t i, n;\r
+\r
+ p->depth++;\r
+\r
+ if (p->depth > MAX_MARSHAL_STACK_DEPTH) {\r
+ p->error = WFERR_NESTEDTOODEEP;\r
+ }\r
+ else if (v == NULL) {\r
+ w_byte(TYPE_NULL, p);\r
+ }\r
+ else if (v == Py_None) {\r
+ w_byte(TYPE_NONE, p);\r
+ }\r
+ else if (v == PyExc_StopIteration) {\r
+ w_byte(TYPE_STOPITER, p);\r
+ }\r
+ else if (v == Py_Ellipsis) {\r
+ w_byte(TYPE_ELLIPSIS, p);\r
+ }\r
+ else if (v == Py_False) {\r
+ w_byte(TYPE_FALSE, p);\r
+ }\r
+ else if (v == Py_True) {\r
+ w_byte(TYPE_TRUE, p);\r
+ }\r
+ else if (PyInt_CheckExact(v)) {\r
+ long x = PyInt_AS_LONG((PyIntObject *)v);\r
+#if SIZEOF_LONG > 4\r
+ long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);\r
+ if (y && y != -1) {\r
+ w_byte(TYPE_INT64, p);\r
+ w_long64(x, p);\r
+ }\r
+ else\r
+#endif\r
+ {\r
+ w_byte(TYPE_INT, p);\r
+ w_long(x, p);\r
+ }\r
+ }\r
+ else if (PyLong_CheckExact(v)) {\r
+ PyLongObject *ob = (PyLongObject *)v;\r
+ w_PyLong(ob, p);\r
+ }\r
+ else if (PyFloat_CheckExact(v)) {\r
+ if (p->version > 1) {\r
+ unsigned char buf[8];\r
+ if (_PyFloat_Pack8(PyFloat_AsDouble(v),\r
+ buf, 1) < 0) {\r
+ p->error = WFERR_UNMARSHALLABLE;\r
+ return;\r
+ }\r
+ w_byte(TYPE_BINARY_FLOAT, p);\r
+ w_string((char*)buf, 8, p);\r
+ }\r
+ else {\r
+ char *buf = PyOS_double_to_string(PyFloat_AS_DOUBLE(v),\r
+ 'g', 17, 0, NULL);\r
+ if (!buf) {\r
+ p->error = WFERR_NOMEMORY;\r
+ return;\r
+ }\r
+ n = strlen(buf);\r
+ w_byte(TYPE_FLOAT, p);\r
+ w_byte((int)n, p);\r
+ w_string(buf, (int)n, p);\r
+ PyMem_Free(buf);\r
+ }\r
+ }\r
+#ifndef WITHOUT_COMPLEX\r
+ else if (PyComplex_CheckExact(v)) {\r
+ if (p->version > 1) {\r
+ unsigned char buf[8];\r
+ if (_PyFloat_Pack8(PyComplex_RealAsDouble(v),\r
+ buf, 1) < 0) {\r
+ p->error = WFERR_UNMARSHALLABLE;\r
+ return;\r
+ }\r
+ w_byte(TYPE_BINARY_COMPLEX, p);\r
+ w_string((char*)buf, 8, p);\r
+ if (_PyFloat_Pack8(PyComplex_ImagAsDouble(v),\r
+ buf, 1) < 0) {\r
+ p->error = WFERR_UNMARSHALLABLE;\r
+ return;\r
+ }\r
+ w_string((char*)buf, 8, p);\r
+ }\r
+ else {\r
+ char *buf;\r
+ w_byte(TYPE_COMPLEX, p);\r
+ buf = PyOS_double_to_string(PyComplex_RealAsDouble(v),\r
+ 'g', 17, 0, NULL);\r
+ if (!buf) {\r
+ p->error = WFERR_NOMEMORY;\r
+ return;\r
+ }\r
+ n = strlen(buf);\r
+ w_byte((int)n, p);\r
+ w_string(buf, (int)n, p);\r
+ PyMem_Free(buf);\r
+ buf = PyOS_double_to_string(PyComplex_ImagAsDouble(v),\r
+ 'g', 17, 0, NULL);\r
+ if (!buf) {\r
+ p->error = WFERR_NOMEMORY;\r
+ return;\r
+ }\r
+ n = strlen(buf);\r
+ w_byte((int)n, p);\r
+ w_string(buf, (int)n, p);\r
+ PyMem_Free(buf);\r
+ }\r
+ }\r
+#endif\r
+ else if (PyString_CheckExact(v)) {\r
+ if (p->strings && PyString_CHECK_INTERNED(v)) {\r
+ PyObject *o = PyDict_GetItem(p->strings, v);\r
+ if (o) {\r
+ long w = PyInt_AsLong(o);\r
+ w_byte(TYPE_STRINGREF, p);\r
+ w_long(w, p);\r
+ goto exit;\r
+ }\r
+ else {\r
+ int ok;\r
+ o = PyInt_FromSsize_t(PyDict_Size(p->strings));\r
+ ok = o &&\r
+ PyDict_SetItem(p->strings, v, o) >= 0;\r
+ Py_XDECREF(o);\r
+ if (!ok) {\r
+ p->depth--;\r
+ p->error = WFERR_UNMARSHALLABLE;\r
+ return;\r
+ }\r
+ w_byte(TYPE_INTERNED, p);\r
+ }\r
+ }\r
+ else {\r
+ w_byte(TYPE_STRING, p);\r
+ }\r
+ n = PyString_GET_SIZE(v);\r
+ if (n > INT_MAX) {\r
+ /* huge strings are not supported */\r
+ p->depth--;\r
+ p->error = WFERR_UNMARSHALLABLE;\r
+ return;\r
+ }\r
+ w_long((long)n, p);\r
+ w_string(PyString_AS_STRING(v), (int)n, p);\r
+ }\r
+#ifdef Py_USING_UNICODE\r
+ else if (PyUnicode_CheckExact(v)) {\r
+ PyObject *utf8;\r
+ utf8 = PyUnicode_AsUTF8String(v);\r
+ if (utf8 == NULL) {\r
+ p->depth--;\r
+ p->error = WFERR_UNMARSHALLABLE;\r
+ return;\r
+ }\r
+ w_byte(TYPE_UNICODE, p);\r
+ n = PyString_GET_SIZE(utf8);\r
+ if (n > INT_MAX) {\r
+ p->depth--;\r
+ p->error = WFERR_UNMARSHALLABLE;\r
+ return;\r
+ }\r
+ w_long((long)n, p);\r
+ w_string(PyString_AS_STRING(utf8), (int)n, p);\r
+ Py_DECREF(utf8);\r
+ }\r
+#endif\r
+ else if (PyTuple_CheckExact(v)) {\r
+ w_byte(TYPE_TUPLE, p);\r
+ n = PyTuple_Size(v);\r
+ w_long((long)n, p);\r
+ for (i = 0; i < n; i++) {\r
+ w_object(PyTuple_GET_ITEM(v, i), p);\r
+ }\r
+ }\r
+ else if (PyList_CheckExact(v)) {\r
+ w_byte(TYPE_LIST, p);\r
+ n = PyList_GET_SIZE(v);\r
+ w_long((long)n, p);\r
+ for (i = 0; i < n; i++) {\r
+ w_object(PyList_GET_ITEM(v, i), p);\r
+ }\r
+ }\r
+ else if (PyDict_CheckExact(v)) {\r
+ Py_ssize_t pos;\r
+ PyObject *key, *value;\r
+ w_byte(TYPE_DICT, p);\r
+ /* This one is NULL object terminated! */\r
+ pos = 0;\r
+ while (PyDict_Next(v, &pos, &key, &value)) {\r
+ w_object(key, p);\r
+ w_object(value, p);\r
+ }\r
+ w_object((PyObject *)NULL, p);\r
+ }\r
+ else if (PyAnySet_CheckExact(v)) {\r
+ PyObject *value, *it;\r
+\r
+ if (PyObject_TypeCheck(v, &PySet_Type))\r
+ w_byte(TYPE_SET, p);\r
+ else\r
+ w_byte(TYPE_FROZENSET, p);\r
+ n = PyObject_Size(v);\r
+ if (n == -1) {\r
+ p->depth--;\r
+ p->error = WFERR_UNMARSHALLABLE;\r
+ return;\r
+ }\r
+ w_long((long)n, p);\r
+ it = PyObject_GetIter(v);\r
+ if (it == NULL) {\r
+ p->depth--;\r
+ p->error = WFERR_UNMARSHALLABLE;\r
+ return;\r
+ }\r
+ while ((value = PyIter_Next(it)) != NULL) {\r
+ w_object(value, p);\r
+ Py_DECREF(value);\r
+ }\r
+ Py_DECREF(it);\r
+ if (PyErr_Occurred()) {\r
+ p->depth--;\r
+ p->error = WFERR_UNMARSHALLABLE;\r
+ return;\r
+ }\r
+ }\r
+ else if (PyCode_Check(v)) {\r
+ PyCodeObject *co = (PyCodeObject *)v;\r
+ w_byte(TYPE_CODE, p);\r
+ w_long(co->co_argcount, p);\r
+ w_long(co->co_nlocals, p);\r
+ w_long(co->co_stacksize, p);\r
+ w_long(co->co_flags, p);\r
+ w_object(co->co_code, p);\r
+ w_object(co->co_consts, p);\r
+ w_object(co->co_names, p);\r
+ w_object(co->co_varnames, p);\r
+ w_object(co->co_freevars, p);\r
+ w_object(co->co_cellvars, p);\r
+ w_object(co->co_filename, p);\r
+ w_object(co->co_name, p);\r
+ w_long(co->co_firstlineno, p);\r
+ w_object(co->co_lnotab, p);\r
+ }\r
+ else if (PyObject_CheckReadBuffer(v)) {\r
+ /* Write unknown buffer-style objects as a string */\r
+ char *s;\r
+ PyBufferProcs *pb = v->ob_type->tp_as_buffer;\r
+ w_byte(TYPE_STRING, p);\r
+ n = (*pb->bf_getreadbuffer)(v, 0, (void **)&s);\r
+ if (n > INT_MAX) {\r
+ p->depth--;\r
+ p->error = WFERR_UNMARSHALLABLE;\r
+ return;\r
+ }\r
+ w_long((long)n, p);\r
+ w_string(s, (int)n, p);\r
+ }\r
+ else {\r
+ w_byte(TYPE_UNKNOWN, p);\r
+ p->error = WFERR_UNMARSHALLABLE;\r
+ }\r
+ exit:\r
+ p->depth--;\r
+}\r
+\r
+/* version currently has no effect for writing longs. */\r
+void\r
+PyMarshal_WriteLongToFile(long x, FILE *fp, int version)\r
+{\r
+ WFILE wf;\r
+ wf.fp = fp;\r
+ wf.error = WFERR_OK;\r
+ wf.depth = 0;\r
+ wf.strings = NULL;\r
+ wf.version = version;\r
+ w_long(x, &wf);\r
+}\r
+\r
+void\r
+PyMarshal_WriteObjectToFile(PyObject *x, FILE *fp, int version)\r
+{\r
+ WFILE wf;\r
+ wf.fp = fp;\r
+ wf.error = WFERR_OK;\r
+ wf.depth = 0;\r
+ wf.strings = (version > 0) ? PyDict_New() : NULL;\r
+ wf.version = version;\r
+ w_object(x, &wf);\r
+ Py_XDECREF(wf.strings);\r
+}\r
+\r
+typedef WFILE RFILE; /* Same struct with different invariants */\r
+\r
+#define rs_byte(p) (((p)->ptr < (p)->end) ? (unsigned char)*(p)->ptr++ : EOF)\r
+\r
+#define r_byte(p) ((p)->fp ? getc((p)->fp) : rs_byte(p))\r
+\r
+static int\r
+r_string(char *s, int n, RFILE *p)\r
+{\r
+ if (p->fp != NULL)\r
+ /* The result fits into int because it must be <=n. */\r
+ return (int)fread(s, 1, n, p->fp);\r
+ if (p->end - p->ptr < n)\r
+ n = (int)(p->end - p->ptr);\r
+ memcpy(s, p->ptr, n);\r
+ p->ptr += n;\r
+ return n;\r
+}\r
+\r
+static int\r
+r_short(RFILE *p)\r
+{\r
+ register short x;\r
+ x = r_byte(p);\r
+ x |= r_byte(p) << 8;\r
+ /* Sign-extension, in case short greater than 16 bits */\r
+ x |= -(x & 0x8000);\r
+ return x;\r
+}\r
+\r
+static long\r
+r_long(RFILE *p)\r
+{\r
+ register long x;\r
+ register FILE *fp = p->fp;\r
+ if (fp) {\r
+ x = getc(fp);\r
+ x |= (long)getc(fp) << 8;\r
+ x |= (long)getc(fp) << 16;\r
+ x |= (long)getc(fp) << 24;\r
+ }\r
+ else {\r
+ x = rs_byte(p);\r
+ x |= (long)rs_byte(p) << 8;\r
+ x |= (long)rs_byte(p) << 16;\r
+ x |= (long)rs_byte(p) << 24;\r
+ }\r
+#if SIZEOF_LONG > 4\r
+ /* Sign extension for 64-bit machines */\r
+ x |= -(x & 0x80000000L);\r
+#endif\r
+ return x;\r
+}\r
+\r
+/* r_long64 deals with the TYPE_INT64 code. On a machine with\r
+ sizeof(long) > 4, it returns a Python int object, else a Python long\r
+ object. Note that w_long64 writes out TYPE_INT if 32 bits is enough,\r
+ so there's no inefficiency here in returning a PyLong on 32-bit boxes\r
+ for everything written via TYPE_INT64 (i.e., if an int is written via\r
+ TYPE_INT64, it *needs* more than 32 bits).\r
+*/\r
+static PyObject *\r
+r_long64(RFILE *p)\r
+{\r
+ long lo4 = r_long(p);\r
+ long hi4 = r_long(p);\r
+#if SIZEOF_LONG > 4\r
+ long x = (hi4 << 32) | (lo4 & 0xFFFFFFFFL);\r
+ return PyInt_FromLong(x);\r
+#else\r
+ unsigned char buf[8];\r
+ int one = 1;\r
+ int is_little_endian = (int)*(char*)&one;\r
+ if (is_little_endian) {\r
+ memcpy(buf, &lo4, 4);\r
+ memcpy(buf+4, &hi4, 4);\r
+ }\r
+ else {\r
+ memcpy(buf, &hi4, 4);\r
+ memcpy(buf+4, &lo4, 4);\r
+ }\r
+ return _PyLong_FromByteArray(buf, 8, is_little_endian, 1);\r
+#endif\r
+}\r
+\r
+static PyObject *\r
+r_PyLong(RFILE *p)\r
+{\r
+ PyLongObject *ob;\r
+ int size, i, j, md, shorts_in_top_digit;\r
+ long n;\r
+ digit d;\r
+\r
+ n = r_long(p);\r
+ if (n == 0)\r
+ return (PyObject *)_PyLong_New(0);\r
+ if (n < -INT_MAX || n > INT_MAX) {\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "bad marshal data (long size out of range)");\r
+ return NULL;\r
+ }\r
+\r
+ size = 1 + (ABS(n) - 1) / PyLong_MARSHAL_RATIO;\r
+ shorts_in_top_digit = 1 + (ABS(n) - 1) % PyLong_MARSHAL_RATIO;\r
+ ob = _PyLong_New(size);\r
+ if (ob == NULL)\r
+ return NULL;\r
+ Py_SIZE(ob) = n > 0 ? size : -size;\r
+\r
+ for (i = 0; i < size-1; i++) {\r
+ d = 0;\r
+ for (j=0; j < PyLong_MARSHAL_RATIO; j++) {\r
+ md = r_short(p);\r
+ if (md < 0 || md > PyLong_MARSHAL_BASE)\r
+ goto bad_digit;\r
+ d += (digit)md << j*PyLong_MARSHAL_SHIFT;\r
+ }\r
+ ob->ob_digit[i] = d;\r
+ }\r
+ d = 0;\r
+ for (j=0; j < shorts_in_top_digit; j++) {\r
+ md = r_short(p);\r
+ if (md < 0 || md > PyLong_MARSHAL_BASE)\r
+ goto bad_digit;\r
+ /* topmost marshal digit should be nonzero */\r
+ if (md == 0 && j == shorts_in_top_digit - 1) {\r
+ Py_DECREF(ob);\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "bad marshal data (unnormalized long data)");\r
+ return NULL;\r
+ }\r
+ d += (digit)md << j*PyLong_MARSHAL_SHIFT;\r
+ }\r
+ /* top digit should be nonzero, else the resulting PyLong won't be\r
+ normalized */\r
+ ob->ob_digit[size-1] = d;\r
+ return (PyObject *)ob;\r
+ bad_digit:\r
+ Py_DECREF(ob);\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "bad marshal data (digit out of range in long)");\r
+ return NULL;\r
+}\r
+\r
+\r
+static PyObject *\r
+r_object(RFILE *p)\r
+{\r
+ /* NULL is a valid return value, it does not necessarily means that\r
+ an exception is set. */\r
+ PyObject *v, *v2;\r
+ long i, n;\r
+ int type = r_byte(p);\r
+ PyObject *retval;\r
+\r
+ p->depth++;\r
+\r
+ if (p->depth > MAX_MARSHAL_STACK_DEPTH) {\r
+ p->depth--;\r
+ PyErr_SetString(PyExc_ValueError, "recursion limit exceeded");\r
+ return NULL;\r
+ }\r
+\r
+ switch (type) {\r
+\r
+ case EOF:\r
+ PyErr_SetString(PyExc_EOFError,\r
+ "EOF read where object expected");\r
+ retval = NULL;\r
+ break;\r
+\r
+ case TYPE_NULL:\r
+ retval = NULL;\r
+ break;\r
+\r
+ case TYPE_NONE:\r
+ Py_INCREF(Py_None);\r
+ retval = Py_None;\r
+ break;\r
+\r
+ case TYPE_STOPITER:\r
+ Py_INCREF(PyExc_StopIteration);\r
+ retval = PyExc_StopIteration;\r
+ break;\r
+\r
+ case TYPE_ELLIPSIS:\r
+ Py_INCREF(Py_Ellipsis);\r
+ retval = Py_Ellipsis;\r
+ break;\r
+\r
+ case TYPE_FALSE:\r
+ Py_INCREF(Py_False);\r
+ retval = Py_False;\r
+ break;\r
+\r
+ case TYPE_TRUE:\r
+ Py_INCREF(Py_True);\r
+ retval = Py_True;\r
+ break;\r
+\r
+ case TYPE_INT:\r
+ retval = PyInt_FromLong(r_long(p));\r
+ break;\r
+\r
+ case TYPE_INT64:\r
+ retval = r_long64(p);\r
+ break;\r
+\r
+ case TYPE_LONG:\r
+ retval = r_PyLong(p);\r
+ break;\r
+\r
+ case TYPE_FLOAT:\r
+ {\r
+ char buf[256];\r
+ double dx;\r
+ n = r_byte(p);\r
+ if (n == EOF || r_string(buf, (int)n, p) != n) {\r
+ PyErr_SetString(PyExc_EOFError,\r
+ "EOF read where object expected");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ buf[n] = '\0';\r
+ dx = PyOS_string_to_double(buf, NULL, NULL);\r
+ if (dx == -1.0 && PyErr_Occurred()) {\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ retval = PyFloat_FromDouble(dx);\r
+ break;\r
+ }\r
+\r
+ case TYPE_BINARY_FLOAT:\r
+ {\r
+ unsigned char buf[8];\r
+ double x;\r
+ if (r_string((char*)buf, 8, p) != 8) {\r
+ PyErr_SetString(PyExc_EOFError,\r
+ "EOF read where object expected");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ x = _PyFloat_Unpack8(buf, 1);\r
+ if (x == -1.0 && PyErr_Occurred()) {\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ retval = PyFloat_FromDouble(x);\r
+ break;\r
+ }\r
+\r
+#ifndef WITHOUT_COMPLEX\r
+ case TYPE_COMPLEX:\r
+ {\r
+ char buf[256];\r
+ Py_complex c;\r
+ n = r_byte(p);\r
+ if (n == EOF || r_string(buf, (int)n, p) != n) {\r
+ PyErr_SetString(PyExc_EOFError,\r
+ "EOF read where object expected");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ buf[n] = '\0';\r
+ c.real = PyOS_string_to_double(buf, NULL, NULL);\r
+ if (c.real == -1.0 && PyErr_Occurred()) {\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ n = r_byte(p);\r
+ if (n == EOF || r_string(buf, (int)n, p) != n) {\r
+ PyErr_SetString(PyExc_EOFError,\r
+ "EOF read where object expected");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ buf[n] = '\0';\r
+ c.imag = PyOS_string_to_double(buf, NULL, NULL);\r
+ if (c.imag == -1.0 && PyErr_Occurred()) {\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ retval = PyComplex_FromCComplex(c);\r
+ break;\r
+ }\r
+\r
+ case TYPE_BINARY_COMPLEX:\r
+ {\r
+ unsigned char buf[8];\r
+ Py_complex c;\r
+ if (r_string((char*)buf, 8, p) != 8) {\r
+ PyErr_SetString(PyExc_EOFError,\r
+ "EOF read where object expected");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ c.real = _PyFloat_Unpack8(buf, 1);\r
+ if (c.real == -1.0 && PyErr_Occurred()) {\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ if (r_string((char*)buf, 8, p) != 8) {\r
+ PyErr_SetString(PyExc_EOFError,\r
+ "EOF read where object expected");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ c.imag = _PyFloat_Unpack8(buf, 1);\r
+ if (c.imag == -1.0 && PyErr_Occurred()) {\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ retval = PyComplex_FromCComplex(c);\r
+ break;\r
+ }\r
+#endif\r
+\r
+ case TYPE_INTERNED:\r
+ case TYPE_STRING:\r
+ n = r_long(p);\r
+ if (n < 0 || n > INT_MAX) {\r
+ PyErr_SetString(PyExc_ValueError, "bad marshal data (string size out of range)");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ v = PyString_FromStringAndSize((char *)NULL, n);\r
+ if (v == NULL) {\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ if (r_string(PyString_AS_STRING(v), (int)n, p) != n) {\r
+ Py_DECREF(v);\r
+ PyErr_SetString(PyExc_EOFError,\r
+ "EOF read where object expected");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ if (type == TYPE_INTERNED) {\r
+ PyString_InternInPlace(&v);\r
+ if (PyList_Append(p->strings, v) < 0) {\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ }\r
+ retval = v;\r
+ break;\r
+\r
+ case TYPE_STRINGREF:\r
+ n = r_long(p);\r
+ if (n < 0 || n >= PyList_GET_SIZE(p->strings)) {\r
+ PyErr_SetString(PyExc_ValueError, "bad marshal data (string ref out of range)");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ v = PyList_GET_ITEM(p->strings, n);\r
+ Py_INCREF(v);\r
+ retval = v;\r
+ break;\r
+\r
+#ifdef Py_USING_UNICODE\r
+ case TYPE_UNICODE:\r
+ {\r
+ char *buffer;\r
+\r
+ n = r_long(p);\r
+ if (n < 0 || n > INT_MAX) {\r
+ PyErr_SetString(PyExc_ValueError, "bad marshal data (unicode size out of range)");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ buffer = PyMem_NEW(char, n);\r
+ if (buffer == NULL) {\r
+ retval = PyErr_NoMemory();\r
+ break;\r
+ }\r
+ if (r_string(buffer, (int)n, p) != n) {\r
+ PyMem_DEL(buffer);\r
+ PyErr_SetString(PyExc_EOFError,\r
+ "EOF read where object expected");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ v = PyUnicode_DecodeUTF8(buffer, n, NULL);\r
+ PyMem_DEL(buffer);\r
+ retval = v;\r
+ break;\r
+ }\r
+#endif\r
+\r
+ case TYPE_TUPLE:\r
+ n = r_long(p);\r
+ if (n < 0 || n > INT_MAX) {\r
+ PyErr_SetString(PyExc_ValueError, "bad marshal data (tuple size out of range)");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ v = PyTuple_New((int)n);\r
+ if (v == NULL) {\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ for (i = 0; i < n; i++) {\r
+ v2 = r_object(p);\r
+ if ( v2 == NULL ) {\r
+ if (!PyErr_Occurred())\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "NULL object in marshal data for tuple");\r
+ Py_DECREF(v);\r
+ v = NULL;\r
+ break;\r
+ }\r
+ PyTuple_SET_ITEM(v, (int)i, v2);\r
+ }\r
+ retval = v;\r
+ break;\r
+\r
+ case TYPE_LIST:\r
+ n = r_long(p);\r
+ if (n < 0 || n > INT_MAX) {\r
+ PyErr_SetString(PyExc_ValueError, "bad marshal data (list size out of range)");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ v = PyList_New((int)n);\r
+ if (v == NULL) {\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ for (i = 0; i < n; i++) {\r
+ v2 = r_object(p);\r
+ if ( v2 == NULL ) {\r
+ if (!PyErr_Occurred())\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "NULL object in marshal data for list");\r
+ Py_DECREF(v);\r
+ v = NULL;\r
+ break;\r
+ }\r
+ PyList_SET_ITEM(v, (int)i, v2);\r
+ }\r
+ retval = v;\r
+ break;\r
+\r
+ case TYPE_DICT:\r
+ v = PyDict_New();\r
+ if (v == NULL) {\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ for (;;) {\r
+ PyObject *key, *val;\r
+ key = r_object(p);\r
+ if (key == NULL)\r
+ break;\r
+ val = r_object(p);\r
+ if (val != NULL)\r
+ PyDict_SetItem(v, key, val);\r
+ Py_DECREF(key);\r
+ Py_XDECREF(val);\r
+ }\r
+ if (PyErr_Occurred()) {\r
+ Py_DECREF(v);\r
+ v = NULL;\r
+ }\r
+ retval = v;\r
+ break;\r
+\r
+ case TYPE_SET:\r
+ case TYPE_FROZENSET:\r
+ n = r_long(p);\r
+ if (n < 0 || n > INT_MAX) {\r
+ PyErr_SetString(PyExc_ValueError, "bad marshal data (set size out of range)");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ v = (type == TYPE_SET) ? PySet_New(NULL) : PyFrozenSet_New(NULL);\r
+ if (v == NULL) {\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ for (i = 0; i < n; i++) {\r
+ v2 = r_object(p);\r
+ if ( v2 == NULL ) {\r
+ if (!PyErr_Occurred())\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "NULL object in marshal data for set");\r
+ Py_DECREF(v);\r
+ v = NULL;\r
+ break;\r
+ }\r
+ if (PySet_Add(v, v2) == -1) {\r
+ Py_DECREF(v);\r
+ Py_DECREF(v2);\r
+ v = NULL;\r
+ break;\r
+ }\r
+ Py_DECREF(v2);\r
+ }\r
+ retval = v;\r
+ break;\r
+\r
+ case TYPE_CODE:\r
+ if (PyEval_GetRestricted()) {\r
+ PyErr_SetString(PyExc_RuntimeError,\r
+ "cannot unmarshal code objects in "\r
+ "restricted execution mode");\r
+ retval = NULL;\r
+ break;\r
+ }\r
+ else {\r
+ int argcount;\r
+ int nlocals;\r
+ int stacksize;\r
+ int flags;\r
+ PyObject *code = NULL;\r
+ PyObject *consts = NULL;\r
+ PyObject *names = NULL;\r
+ PyObject *varnames = NULL;\r
+ PyObject *freevars = NULL;\r
+ PyObject *cellvars = NULL;\r
+ PyObject *filename = NULL;\r
+ PyObject *name = NULL;\r
+ int firstlineno;\r
+ PyObject *lnotab = NULL;\r
+\r
+ v = NULL;\r
+\r
+ /* XXX ignore long->int overflows for now */\r
+ argcount = (int)r_long(p);\r
+ nlocals = (int)r_long(p);\r
+ stacksize = (int)r_long(p);\r
+ flags = (int)r_long(p);\r
+ code = r_object(p);\r
+ if (code == NULL)\r
+ goto code_error;\r
+ consts = r_object(p);\r
+ if (consts == NULL)\r
+ goto code_error;\r
+ names = r_object(p);\r
+ if (names == NULL)\r
+ goto code_error;\r
+ varnames = r_object(p);\r
+ if (varnames == NULL)\r
+ goto code_error;\r
+ freevars = r_object(p);\r
+ if (freevars == NULL)\r
+ goto code_error;\r
+ cellvars = r_object(p);\r
+ if (cellvars == NULL)\r
+ goto code_error;\r
+ filename = r_object(p);\r
+ if (filename == NULL)\r
+ goto code_error;\r
+ name = r_object(p);\r
+ if (name == NULL)\r
+ goto code_error;\r
+ firstlineno = (int)r_long(p);\r
+ lnotab = r_object(p);\r
+ if (lnotab == NULL)\r
+ goto code_error;\r
+\r
+ v = (PyObject *) PyCode_New(\r
+ argcount, nlocals, stacksize, flags,\r
+ code, consts, names, varnames,\r
+ freevars, cellvars, filename, name,\r
+ firstlineno, lnotab);\r
+\r
+ code_error:\r
+ Py_XDECREF(code);\r
+ Py_XDECREF(consts);\r
+ Py_XDECREF(names);\r
+ Py_XDECREF(varnames);\r
+ Py_XDECREF(freevars);\r
+ Py_XDECREF(cellvars);\r
+ Py_XDECREF(filename);\r
+ Py_XDECREF(name);\r
+ Py_XDECREF(lnotab);\r
+\r
+ }\r
+ retval = v;\r
+ break;\r
+\r
+ default:\r
+ /* Bogus data got written, which isn't ideal.\r
+ This will let you keep working and recover. */\r
+ PyErr_SetString(PyExc_ValueError, "bad marshal data (unknown type code)");\r
+ retval = NULL;\r
+ break;\r
+\r
+ }\r
+ p->depth--;\r
+ return retval;\r
+}\r
+\r
+static PyObject *\r
+read_object(RFILE *p)\r
+{\r
+ PyObject *v;\r
+ if (PyErr_Occurred()) {\r
+ fprintf(stderr, "XXX readobject called with exception set\n");\r
+ return NULL;\r
+ }\r
+ v = r_object(p);\r
+ if (v == NULL && !PyErr_Occurred())\r
+ PyErr_SetString(PyExc_TypeError, "NULL object in marshal data for object");\r
+ return v;\r
+}\r
+\r
+int\r
+PyMarshal_ReadShortFromFile(FILE *fp)\r
+{\r
+ RFILE rf;\r
+ assert(fp);\r
+ rf.fp = fp;\r
+ rf.strings = NULL;\r
+ rf.end = rf.ptr = NULL;\r
+ return r_short(&rf);\r
+}\r
+\r
+long\r
+PyMarshal_ReadLongFromFile(FILE *fp)\r
+{\r
+ RFILE rf;\r
+ rf.fp = fp;\r
+ rf.strings = NULL;\r
+ rf.ptr = rf.end = NULL;\r
+ return r_long(&rf);\r
+}\r
+\r
+#ifdef HAVE_FSTAT\r
+/* Return size of file in bytes; < 0 if unknown. */\r
+static off_t\r
+getfilesize(FILE *fp)\r
+{\r
+ struct stat st;\r
+ if (fstat(fileno(fp), &st) != 0)\r
+ return -1;\r
+ else\r
+ return st.st_size;\r
+}\r
+#endif\r
+\r
+/* If we can get the size of the file up-front, and it's reasonably small,\r
+ * read it in one gulp and delegate to ...FromString() instead. Much quicker\r
+ * than reading a byte at a time from file; speeds .pyc imports.\r
+ * CAUTION: since this may read the entire remainder of the file, don't\r
+ * call it unless you know you're done with the file.\r
+ */\r
+PyObject *\r
+PyMarshal_ReadLastObjectFromFile(FILE *fp)\r
+{\r
+/* REASONABLE_FILE_LIMIT is by defn something big enough for Tkinter.pyc. */\r
+#define REASONABLE_FILE_LIMIT (1L << 18)\r
+#ifdef HAVE_FSTAT\r
+ off_t filesize;\r
+ filesize = getfilesize(fp);\r
+ if (filesize > 0 && filesize <= REASONABLE_FILE_LIMIT) {\r
+ char* pBuf = (char *)PyMem_MALLOC(filesize);\r
+ if (pBuf != NULL) {\r
+ PyObject* v;\r
+ size_t n;\r
+ /* filesize must fit into an int, because it\r
+ is smaller than REASONABLE_FILE_LIMIT */\r
+ n = fread(pBuf, 1, (int)filesize, fp);\r
+ v = PyMarshal_ReadObjectFromString(pBuf, n);\r
+ PyMem_FREE(pBuf);\r
+ return v;\r
+ }\r
+\r
+ }\r
+#endif\r
+ /* We don't have fstat, or we do but the file is larger than\r
+ * REASONABLE_FILE_LIMIT or malloc failed -- read a byte at a time.\r
+ */\r
+ return PyMarshal_ReadObjectFromFile(fp);\r
+\r
+#undef REASONABLE_FILE_LIMIT\r
+}\r
+\r
+PyObject *\r
+PyMarshal_ReadObjectFromFile(FILE *fp)\r
+{\r
+ RFILE rf;\r
+ PyObject *result;\r
+ rf.fp = fp;\r
+ rf.strings = PyList_New(0);\r
+ rf.depth = 0;\r
+ rf.ptr = rf.end = NULL;\r
+ result = r_object(&rf);\r
+ Py_DECREF(rf.strings);\r
+ return result;\r
+}\r
+\r
+PyObject *\r
+PyMarshal_ReadObjectFromString(char *str, Py_ssize_t len)\r
+{\r
+ RFILE rf;\r
+ PyObject *result;\r
+ rf.fp = NULL;\r
+ rf.ptr = str;\r
+ rf.end = str + len;\r
+ rf.strings = PyList_New(0);\r
+ rf.depth = 0;\r
+ result = r_object(&rf);\r
+ Py_DECREF(rf.strings);\r
+ return result;\r
+}\r
+\r
+static void\r
+set_error(int error)\r
+{\r
+ switch (error) {\r
+ case WFERR_NOMEMORY:\r
+ PyErr_NoMemory();\r
+ break;\r
+ case WFERR_UNMARSHALLABLE:\r
+ PyErr_SetString(PyExc_ValueError, "unmarshallable object");\r
+ break;\r
+ case WFERR_NESTEDTOODEEP:\r
+ default:\r
+ PyErr_SetString(PyExc_ValueError,\r
+ "object too deeply nested to marshal");\r
+ break;\r
+ }\r
+}\r
+\r
+PyObject *\r
+PyMarshal_WriteObjectToString(PyObject *x, int version)\r
+{\r
+ WFILE wf;\r
+ wf.fp = NULL;\r
+ wf.str = PyString_FromStringAndSize((char *)NULL, 50);\r
+ if (wf.str == NULL)\r
+ return NULL;\r
+ wf.ptr = PyString_AS_STRING((PyStringObject *)wf.str);\r
+ wf.end = wf.ptr + PyString_Size(wf.str);\r
+ wf.error = WFERR_OK;\r
+ wf.depth = 0;\r
+ wf.version = version;\r
+ wf.strings = (version > 0) ? PyDict_New() : NULL;\r
+ w_object(x, &wf);\r
+ Py_XDECREF(wf.strings);\r
+ if (wf.str != NULL) {\r
+ char *base = PyString_AS_STRING((PyStringObject *)wf.str);\r
+ if (wf.ptr - base > PY_SSIZE_T_MAX) {\r
+ Py_DECREF(wf.str);\r
+ PyErr_SetString(PyExc_OverflowError,\r
+ "too much marshall data for a string");\r
+ return NULL;\r
+ }\r
+ if (_PyString_Resize(&wf.str, (Py_ssize_t)(wf.ptr - base)))\r
+ return NULL;\r
+ }\r
+ if (wf.error != WFERR_OK) {\r
+ Py_XDECREF(wf.str);\r
+ set_error(wf.error);\r
+ return NULL;\r
+ }\r
+ return wf.str;\r
+}\r
+\r
+/* And an interface for Python programs... */\r
+\r
+static PyObject *\r
+marshal_dump(PyObject *self, PyObject *args)\r
+{\r
+ WFILE wf;\r
+ PyObject *x;\r
+ PyObject *f;\r
+ int version = Py_MARSHAL_VERSION;\r
+ if (!PyArg_ParseTuple(args, "OO|i:dump", &x, &f, &version))\r
+ return NULL;\r
+ if (!PyFile_Check(f)) {\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "marshal.dump() 2nd arg must be file");\r
+ return NULL;\r
+ }\r
+ wf.fp = PyFile_AsFile(f);\r
+ wf.str = NULL;\r
+ wf.ptr = wf.end = NULL;\r
+ wf.error = WFERR_OK;\r
+ wf.depth = 0;\r
+ wf.strings = (version > 0) ? PyDict_New() : 0;\r
+ wf.version = version;\r
+ w_object(x, &wf);\r
+ Py_XDECREF(wf.strings);\r
+ if (wf.error != WFERR_OK) {\r
+ set_error(wf.error);\r
+ return NULL;\r
+ }\r
+ Py_INCREF(Py_None);\r
+ return Py_None;\r
+}\r
+\r
+PyDoc_STRVAR(dump_doc,\r
+"dump(value, file[, version])\n\\r
+\n\\r
+Write the value on the open file. The value must be a supported type.\n\\r
+The file must be an open file object such as sys.stdout or returned by\n\\r
+open() or os.popen(). It must be opened in binary mode ('wb' or 'w+b').\n\\r
+\n\\r
+If the value has (or contains an object that has) an unsupported type, a\n\\r
+ValueError exception is raised — but garbage data will also be written\n\\r
+to the file. The object will not be properly read back by load()\n\\r
+\n\\r
+New in version 2.4: The version argument indicates the data format that\n\\r
+dump should use.");\r
+\r
+static PyObject *\r
+marshal_load(PyObject *self, PyObject *f)\r
+{\r
+ RFILE rf;\r
+ PyObject *result;\r
+ if (!PyFile_Check(f)) {\r
+ PyErr_SetString(PyExc_TypeError,\r
+ "marshal.load() arg must be file");\r
+ return NULL;\r
+ }\r
+ rf.fp = PyFile_AsFile(f);\r
+ rf.strings = PyList_New(0);\r
+ rf.depth = 0;\r
+ result = read_object(&rf);\r
+ Py_DECREF(rf.strings);\r
+ return result;\r
+}\r
+\r
+PyDoc_STRVAR(load_doc,\r
+"load(file)\n\\r
+\n\\r
+Read one value from the open file and return it. If no valid value is\n\\r
+read (e.g. because the data has a different Python version’s\n\\r
+incompatible marshal format), raise EOFError, ValueError or TypeError.\n\\r
+The file must be an open file object opened in binary mode ('rb' or\n\\r
+'r+b').\n\\r
+\n\\r
+Note: If an object containing an unsupported type was marshalled with\n\\r
+dump(), load() will substitute None for the unmarshallable type.");\r
+\r
+\r
+static PyObject *\r
+marshal_dumps(PyObject *self, PyObject *args)\r
+{\r
+ PyObject *x;\r
+ int version = Py_MARSHAL_VERSION;\r
+ if (!PyArg_ParseTuple(args, "O|i:dumps", &x, &version))\r
+ return NULL;\r
+ return PyMarshal_WriteObjectToString(x, version);\r
+}\r
+\r
+PyDoc_STRVAR(dumps_doc,\r
+"dumps(value[, version])\n\\r
+\n\\r
+Return the string that would be written to a file by dump(value, file).\n\\r
+The value must be a supported type. Raise a ValueError exception if\n\\r
+value has (or contains an object that has) an unsupported type.\n\\r
+\n\\r
+New in version 2.4: The version argument indicates the data format that\n\\r
+dumps should use.");\r
+\r
+\r
+static PyObject *\r
+marshal_loads(PyObject *self, PyObject *args)\r
+{\r
+ RFILE rf;\r
+ char *s;\r
+ Py_ssize_t n;\r
+ PyObject* result;\r
+ if (!PyArg_ParseTuple(args, "s#:loads", &s, &n))\r
+ return NULL;\r
+ rf.fp = NULL;\r
+ rf.ptr = s;\r
+ rf.end = s + n;\r
+ rf.strings = PyList_New(0);\r
+ rf.depth = 0;\r
+ result = read_object(&rf);\r
+ Py_DECREF(rf.strings);\r
+ return result;\r
+}\r
+\r
+PyDoc_STRVAR(loads_doc,\r
+"loads(string)\n\\r
+\n\\r
+Convert the string to a value. If no valid value is found, raise\n\\r
+EOFError, ValueError or TypeError. Extra characters in the string are\n\\r
+ignored.");\r
+\r
+static PyMethodDef marshal_methods[] = {\r
+ {"dump", marshal_dump, METH_VARARGS, dump_doc},\r
+ {"load", marshal_load, METH_O, load_doc},\r
+ {"dumps", marshal_dumps, METH_VARARGS, dumps_doc},\r
+ {"loads", marshal_loads, METH_VARARGS, loads_doc},\r
+ {NULL, NULL} /* sentinel */\r
+};\r
+\r
+PyDoc_STRVAR(marshal_doc,\r
+"This module contains functions that can read and write Python values in\n\\r
+a binary format. The format is specific to Python, but independent of\n\\r
+machine architecture issues.\n\\r
+\n\\r
+Not all Python object types are supported; in general, only objects\n\\r
+whose value is independent from a particular invocation of Python can be\n\\r
+written and read by this module. The following types are supported:\n\\r
+None, integers, long integers, floating point numbers, strings, Unicode\n\\r
+objects, tuples, lists, sets, dictionaries, and code objects, where it\n\\r
+should be understood that tuples, lists and dictionaries are only\n\\r
+supported as long as the values contained therein are themselves\n\\r
+supported; and recursive lists and dictionaries should not be written\n\\r
+(they will cause infinite loops).\n\\r
+\n\\r
+Variables:\n\\r
+\n\\r
+version -- indicates the format that the module uses. Version 0 is the\n\\r
+ historical format, version 1 (added in Python 2.4) shares interned\n\\r
+ strings and version 2 (added in Python 2.5) uses a binary format for\n\\r
+ floating point numbers. (New in version 2.4)\n\\r
+\n\\r
+Functions:\n\\r
+\n\\r
+dump() -- write value to a file\n\\r
+load() -- read value from a file\n\\r
+dumps() -- write value to a string\n\\r
+loads() -- read value from a string");\r
+\r
+\r
+PyMODINIT_FUNC\r
+PyMarshal_Init(void)\r
+{\r
+ PyObject *mod = Py_InitModule3("marshal", marshal_methods,\r
+ marshal_doc);\r
+ if (mod == NULL)\r
+ return;\r
+ PyModule_AddIntConstant(mod, "version", Py_MARSHAL_VERSION);\r
+}\r
projects / mirror_edk2.git / blobdiff