+++ /dev/null
-/** @file\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
- Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
- This program and the accompanying materials are licensed and made available under\r
- the terms and conditions of the BSD License that accompanies this distribution.\r
- The full text of the license may be found at\r
- http://opensource.org/licenses/bsd-license.\r
-\r
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-**/\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