1991-06-04 19:42:30 +00:00
|
|
|
|
|
|
|
/* Write Python objects to files and read them back.
|
2013-03-20 01:02:10 +00:00
|
|
|
This is primarily intended for writing and reading compiled Python code,
|
|
|
|
even though dicts, lists, sets and frozensets, not commonly seen in
|
|
|
|
code objects, are supported.
|
|
|
|
Version 3 of this protocol properly supports circular links
|
|
|
|
and sharing. */
|
1991-06-04 19:42:30 +00:00
|
|
|
|
1997-04-29 20:08:16 +00:00
|
|
|
#include "Python.h"
|
2024-04-18 15:18:22 +00:00
|
|
|
#include "pycore_call.h" // _PyObject_CallNoArgs()
|
|
|
|
#include "pycore_code.h" // _PyCode_New()
|
|
|
|
#include "pycore_critical_section.h" // Py_BEGIN_CRITICAL_SECTION()
|
|
|
|
#include "pycore_hashtable.h" // _Py_hashtable_t
|
|
|
|
#include "pycore_long.h" // _PyLong_DigitCount
|
|
|
|
#include "pycore_setobject.h" // _PySet_NextEntry()
|
|
|
|
#include "marshal.h" // Py_MARSHAL_VERSION
|
2024-06-21 15:19:31 +00:00
|
|
|
#include "pycore_pystate.h" // _PyInterpreterState_GET()
|
1991-06-04 19:42:30 +00:00
|
|
|
|
2024-03-28 07:59:33 +00:00
|
|
|
#ifdef __APPLE__
|
|
|
|
# include "TargetConditionals.h"
|
|
|
|
#endif /* __APPLE__ */
|
|
|
|
|
2017-03-12 07:20:15 +00:00
|
|
|
/*[clinic input]
|
|
|
|
module marshal
|
|
|
|
[clinic start generated code]*/
|
|
|
|
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=c982b7930dee17db]*/
|
|
|
|
|
|
|
|
#include "clinic/marshal.c.h"
|
|
|
|
|
2000-06-28 18:47:56 +00:00
|
|
|
/* High water mark to determine when the marshalled object is dangerously deep
|
|
|
|
* and risks coring the interpreter. When the object stack gets this deep,
|
|
|
|
* raise an exception instead of continuing.
|
2007-08-29 20:39:13 +00:00
|
|
|
* On Windows debug builds, reduce this value.
|
2018-06-04 20:25:00 +00:00
|
|
|
*
|
|
|
|
* BUG: https://bugs.python.org/issue33720
|
|
|
|
* On Windows PGO builds, the r_object function overallocates its stack and
|
|
|
|
* can cause a stack overflow. We reduce the maximum depth for all Windows
|
|
|
|
* releases to protect against this.
|
|
|
|
* #if defined(MS_WINDOWS) && defined(_DEBUG)
|
2000-06-28 18:47:56 +00:00
|
|
|
*/
|
2018-06-04 20:25:00 +00:00
|
|
|
#if defined(MS_WINDOWS)
|
2024-03-28 07:59:33 +00:00
|
|
|
# define MAX_MARSHAL_STACK_DEPTH 1000
|
2022-11-01 22:51:05 +00:00
|
|
|
#elif defined(__wasi__)
|
2024-03-28 07:59:33 +00:00
|
|
|
# define MAX_MARSHAL_STACK_DEPTH 1500
|
|
|
|
// TARGET_OS_IPHONE covers any non-macOS Apple platform.
|
2024-04-19 18:56:33 +00:00
|
|
|
// It won't be defined on older macOS SDKs
|
|
|
|
#elif defined(__APPLE__) && defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
|
2024-03-28 07:59:33 +00:00
|
|
|
# define MAX_MARSHAL_STACK_DEPTH 1500
|
2007-08-29 20:39:13 +00:00
|
|
|
#else
|
2024-03-28 07:59:33 +00:00
|
|
|
# define MAX_MARSHAL_STACK_DEPTH 2000
|
2007-08-29 20:39:13 +00:00
|
|
|
#endif
|
2000-06-28 18:47:56 +00:00
|
|
|
|
2010-05-09 15:52:27 +00:00
|
|
|
#define TYPE_NULL '0'
|
|
|
|
#define TYPE_NONE 'N'
|
|
|
|
#define TYPE_FALSE 'F'
|
|
|
|
#define TYPE_TRUE 'T'
|
|
|
|
#define TYPE_STOPITER 'S'
|
|
|
|
#define TYPE_ELLIPSIS '.'
|
|
|
|
#define TYPE_INT 'i'
|
2017-11-15 15:41:05 +00:00
|
|
|
/* TYPE_INT64 is not generated anymore.
|
|
|
|
Supported for backward compatibility only. */
|
|
|
|
#define TYPE_INT64 'I'
|
2010-05-09 15:52:27 +00:00
|
|
|
#define TYPE_FLOAT 'f'
|
|
|
|
#define TYPE_BINARY_FLOAT 'g'
|
|
|
|
#define TYPE_COMPLEX 'x'
|
|
|
|
#define TYPE_BINARY_COMPLEX 'y'
|
|
|
|
#define TYPE_LONG 'l'
|
|
|
|
#define TYPE_STRING 's'
|
2013-03-20 01:02:10 +00:00
|
|
|
#define TYPE_INTERNED 't'
|
|
|
|
#define TYPE_REF 'r'
|
2010-05-09 15:52:27 +00:00
|
|
|
#define TYPE_TUPLE '('
|
|
|
|
#define TYPE_LIST '['
|
|
|
|
#define TYPE_DICT '{'
|
|
|
|
#define TYPE_CODE 'c'
|
|
|
|
#define TYPE_UNICODE 'u'
|
|
|
|
#define TYPE_UNKNOWN '?'
|
|
|
|
#define TYPE_SET '<'
|
|
|
|
#define TYPE_FROZENSET '>'
|
2013-03-20 01:02:10 +00:00
|
|
|
#define FLAG_REF '\x80' /* with a type, add obj to index */
|
1991-06-04 19:42:30 +00:00
|
|
|
|
2013-10-12 20:25:39 +00:00
|
|
|
#define TYPE_ASCII 'a'
|
|
|
|
#define TYPE_ASCII_INTERNED 'A'
|
|
|
|
#define TYPE_SMALL_TUPLE ')'
|
|
|
|
#define TYPE_SHORT_ASCII 'z'
|
|
|
|
#define TYPE_SHORT_ASCII_INTERNED 'Z'
|
|
|
|
|
2009-04-21 11:57:38 +00:00
|
|
|
#define WFERR_OK 0
|
|
|
|
#define WFERR_UNMARSHALLABLE 1
|
|
|
|
#define WFERR_NESTEDTOODEEP 2
|
|
|
|
#define WFERR_NOMEMORY 3
|
2024-01-16 16:05:15 +00:00
|
|
|
#define WFERR_CODE_NOT_ALLOWED 4
|
2009-04-21 11:57:38 +00:00
|
|
|
|
1993-01-21 16:07:51 +00:00
|
|
|
typedef struct {
|
2010-05-09 15:52:27 +00:00
|
|
|
FILE *fp;
|
|
|
|
int error; /* see WFERR_* values */
|
|
|
|
int depth;
|
|
|
|
PyObject *str;
|
|
|
|
char *ptr;
|
2020-03-31 20:23:21 +00:00
|
|
|
const char *end;
|
2013-10-12 20:25:39 +00:00
|
|
|
char *buf;
|
2015-02-11 13:53:31 +00:00
|
|
|
_Py_hashtable_t *hashtable;
|
2010-05-09 15:52:27 +00:00
|
|
|
int version;
|
2024-01-16 16:05:15 +00:00
|
|
|
int allow_code;
|
1993-01-21 16:07:51 +00:00
|
|
|
} WFILE;
|
1991-06-04 19:42:30 +00:00
|
|
|
|
2015-02-11 13:54:54 +00:00
|
|
|
#define w_byte(c, p) do { \
|
|
|
|
if ((p)->ptr != (p)->end || w_reserve((p), 1)) \
|
|
|
|
*(p)->ptr++ = (c); \
|
|
|
|
} while(0)
|
1993-01-21 16:07:51 +00:00
|
|
|
|
|
|
|
static void
|
2015-02-11 13:54:54 +00:00
|
|
|
w_flush(WFILE *p)
|
|
|
|
{
|
|
|
|
assert(p->fp != NULL);
|
|
|
|
fwrite(p->buf, 1, p->ptr - p->buf, p->fp);
|
|
|
|
p->ptr = p->buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
w_reserve(WFILE *p, Py_ssize_t needed)
|
1993-01-21 16:07:51 +00:00
|
|
|
{
|
2015-02-11 13:54:54 +00:00
|
|
|
Py_ssize_t pos, size, delta;
|
|
|
|
if (p->ptr == NULL)
|
|
|
|
return 0; /* An error already occurred */
|
|
|
|
if (p->fp != NULL) {
|
|
|
|
w_flush(p);
|
|
|
|
return needed <= p->end - p->ptr;
|
|
|
|
}
|
|
|
|
assert(p->str != NULL);
|
|
|
|
pos = p->ptr - p->buf;
|
2020-03-31 20:23:21 +00:00
|
|
|
size = PyBytes_GET_SIZE(p->str);
|
2015-02-11 13:54:54 +00:00
|
|
|
if (size > 16*1024*1024)
|
|
|
|
delta = (size >> 3); /* 12.5% overallocation */
|
|
|
|
else
|
|
|
|
delta = size + 1024;
|
|
|
|
delta = Py_MAX(delta, needed);
|
|
|
|
if (delta > PY_SSIZE_T_MAX - size) {
|
|
|
|
p->error = WFERR_NOMEMORY;
|
|
|
|
return 0;
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
2015-02-11 13:54:54 +00:00
|
|
|
size += delta;
|
|
|
|
if (_PyBytes_Resize(&p->str, size) != 0) {
|
2020-03-31 20:23:21 +00:00
|
|
|
p->end = p->ptr = p->buf = NULL;
|
2015-02-11 13:54:54 +00:00
|
|
|
return 0;
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
else {
|
2015-02-11 13:54:54 +00:00
|
|
|
p->buf = PyBytes_AS_STRING(p->str);
|
|
|
|
p->ptr = p->buf + pos;
|
|
|
|
p->end = p->buf + size;
|
|
|
|
return 1;
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
1993-01-21 16:07:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2020-03-31 20:23:21 +00:00
|
|
|
w_string(const void *s, Py_ssize_t n, WFILE *p)
|
1993-01-21 16:07:51 +00:00
|
|
|
{
|
2015-02-11 13:54:54 +00:00
|
|
|
Py_ssize_t m;
|
|
|
|
if (!n || p->ptr == NULL)
|
|
|
|
return;
|
|
|
|
m = p->end - p->ptr;
|
2010-05-09 15:52:27 +00:00
|
|
|
if (p->fp != NULL) {
|
2015-02-11 13:54:54 +00:00
|
|
|
if (n <= m) {
|
2016-09-13 18:22:02 +00:00
|
|
|
memcpy(p->ptr, s, n);
|
2015-02-11 13:54:54 +00:00
|
|
|
p->ptr += n;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
w_flush(p);
|
|
|
|
fwrite(s, 1, n, p->fp);
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
else {
|
2015-02-11 13:54:54 +00:00
|
|
|
if (n <= m || w_reserve(p, n - m)) {
|
2016-09-13 18:22:02 +00:00
|
|
|
memcpy(p->ptr, s, n);
|
2015-02-11 13:54:54 +00:00
|
|
|
p->ptr += n;
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
}
|
1993-01-21 16:07:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2000-07-22 18:47:25 +00:00
|
|
|
w_short(int x, WFILE *p)
|
1991-06-04 19:42:30 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
w_byte((char)( x & 0xff), p);
|
|
|
|
w_byte((char)((x>> 8) & 0xff), p);
|
1991-06-04 19:42:30 +00:00
|
|
|
}
|
|
|
|
|
1993-01-21 16:07:51 +00:00
|
|
|
static void
|
2000-07-22 18:47:25 +00:00
|
|
|
w_long(long x, WFILE *p)
|
1991-06-04 19:42:30 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
w_byte((char)( x & 0xff), p);
|
|
|
|
w_byte((char)((x>> 8) & 0xff), p);
|
|
|
|
w_byte((char)((x>>16) & 0xff), p);
|
|
|
|
w_byte((char)((x>>24) & 0xff), p);
|
1991-06-04 19:42:30 +00:00
|
|
|
}
|
|
|
|
|
2013-02-13 10:08:15 +00:00
|
|
|
#define SIZE32_MAX 0x7FFFFFFF
|
|
|
|
|
|
|
|
#if SIZEOF_SIZE_T > 4
|
|
|
|
# define W_SIZE(n, p) do { \
|
|
|
|
if ((n) > SIZE32_MAX) { \
|
|
|
|
(p)->depth--; \
|
|
|
|
(p)->error = WFERR_UNMARSHALLABLE; \
|
|
|
|
return; \
|
|
|
|
} \
|
|
|
|
w_long((long)(n), p); \
|
|
|
|
} while(0)
|
|
|
|
#else
|
|
|
|
# define W_SIZE w_long
|
|
|
|
#endif
|
|
|
|
|
2013-07-11 16:14:26 +00:00
|
|
|
static void
|
2020-03-31 20:23:21 +00:00
|
|
|
w_pstring(const void *s, Py_ssize_t n, WFILE *p)
|
2013-07-11 16:14:26 +00:00
|
|
|
{
|
|
|
|
W_SIZE(n, p);
|
|
|
|
w_string(s, n, p);
|
|
|
|
}
|
|
|
|
|
2013-10-12 20:25:39 +00:00
|
|
|
static void
|
2020-03-31 20:23:21 +00:00
|
|
|
w_short_pstring(const void *s, Py_ssize_t n, WFILE *p)
|
2013-10-12 20:25:39 +00:00
|
|
|
{
|
2013-10-12 21:14:47 +00:00
|
|
|
w_byte(Py_SAFE_DOWNCAST(n, Py_ssize_t, unsigned char), p);
|
2013-10-12 20:25:39 +00:00
|
|
|
w_string(s, n, p);
|
|
|
|
}
|
|
|
|
|
2013-08-27 16:40:23 +00:00
|
|
|
/* We assume that Python ints are stored internally in base some power of
|
2009-03-18 20:06:12 +00:00
|
|
|
2**15; for the sake of portability we'll always read and write them in base
|
|
|
|
exactly 2**15. */
|
|
|
|
|
|
|
|
#define PyLong_MARSHAL_SHIFT 15
|
|
|
|
#define PyLong_MARSHAL_BASE ((short)1 << PyLong_MARSHAL_SHIFT)
|
|
|
|
#define PyLong_MARSHAL_MASK (PyLong_MARSHAL_BASE - 1)
|
|
|
|
#if PyLong_SHIFT % PyLong_MARSHAL_SHIFT != 0
|
|
|
|
#error "PyLong_SHIFT must be a multiple of PyLong_MARSHAL_SHIFT"
|
|
|
|
#endif
|
|
|
|
#define PyLong_MARSHAL_RATIO (PyLong_SHIFT / PyLong_MARSHAL_SHIFT)
|
|
|
|
|
2013-03-20 01:02:10 +00:00
|
|
|
#define W_TYPE(t, p) do { \
|
|
|
|
w_byte((t) | flag, (p)); \
|
|
|
|
} while(0)
|
|
|
|
|
2024-01-16 16:05:15 +00:00
|
|
|
static PyObject *
|
|
|
|
_PyMarshal_WriteObjectToString(PyObject *x, int version, int allow_code);
|
|
|
|
|
2009-03-18 20:06:12 +00:00
|
|
|
static void
|
2013-03-20 01:02:10 +00:00
|
|
|
w_PyLong(const PyLongObject *ob, char flag, WFILE *p)
|
2009-03-18 20:06:12 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_ssize_t i, j, n, l;
|
|
|
|
digit d;
|
|
|
|
|
2013-03-20 01:02:10 +00:00
|
|
|
W_TYPE(TYPE_LONG, p);
|
2023-03-22 14:49:51 +00:00
|
|
|
if (_PyLong_IsZero(ob)) {
|
2010-05-09 15:52:27 +00:00
|
|
|
w_long((long)0, p);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set l to number of base PyLong_MARSHAL_BASE digits */
|
2023-03-22 14:49:51 +00:00
|
|
|
n = _PyLong_DigitCount(ob);
|
2010-05-09 15:52:27 +00:00
|
|
|
l = (n-1) * PyLong_MARSHAL_RATIO;
|
2023-01-30 10:03:04 +00:00
|
|
|
d = ob->long_value.ob_digit[n-1];
|
2010-05-09 15:52:27 +00:00
|
|
|
assert(d != 0); /* a PyLong is always normalized */
|
|
|
|
do {
|
|
|
|
d >>= PyLong_MARSHAL_SHIFT;
|
|
|
|
l++;
|
|
|
|
} while (d != 0);
|
2013-02-13 10:08:15 +00:00
|
|
|
if (l > SIZE32_MAX) {
|
|
|
|
p->depth--;
|
|
|
|
p->error = WFERR_UNMARSHALLABLE;
|
|
|
|
return;
|
|
|
|
}
|
2023-03-22 14:49:51 +00:00
|
|
|
w_long((long)(_PyLong_IsNegative(ob) ? -l : l), p);
|
2010-05-09 15:52:27 +00:00
|
|
|
|
|
|
|
for (i=0; i < n-1; i++) {
|
2023-01-30 10:03:04 +00:00
|
|
|
d = ob->long_value.ob_digit[i];
|
2010-05-09 15:52:27 +00:00
|
|
|
for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
|
|
|
|
w_short(d & PyLong_MARSHAL_MASK, p);
|
|
|
|
d >>= PyLong_MARSHAL_SHIFT;
|
|
|
|
}
|
|
|
|
assert (d == 0);
|
|
|
|
}
|
2023-01-30 10:03:04 +00:00
|
|
|
d = ob->long_value.ob_digit[n-1];
|
2010-05-09 15:52:27 +00:00
|
|
|
do {
|
|
|
|
w_short(d & PyLong_MARSHAL_MASK, p);
|
|
|
|
d >>= PyLong_MARSHAL_SHIFT;
|
|
|
|
} while (d != 0);
|
2009-03-18 20:06:12 +00:00
|
|
|
}
|
|
|
|
|
2018-07-24 07:55:47 +00:00
|
|
|
static void
|
|
|
|
w_float_bin(double v, WFILE *p)
|
|
|
|
{
|
2022-03-11 23:10:02 +00:00
|
|
|
char buf[8];
|
|
|
|
if (PyFloat_Pack8(v, buf, 1) < 0) {
|
2018-07-24 07:55:47 +00:00
|
|
|
p->error = WFERR_UNMARSHALLABLE;
|
|
|
|
return;
|
|
|
|
}
|
2020-03-31 20:23:21 +00:00
|
|
|
w_string(buf, 8, p);
|
2018-07-24 07:55:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
w_float_str(double v, WFILE *p)
|
|
|
|
{
|
|
|
|
char *buf = PyOS_double_to_string(v, 'g', 17, 0, NULL);
|
|
|
|
if (!buf) {
|
|
|
|
p->error = WFERR_NOMEMORY;
|
|
|
|
return;
|
|
|
|
}
|
2020-03-31 20:23:21 +00:00
|
|
|
w_short_pstring(buf, strlen(buf), p);
|
2018-07-24 07:55:47 +00:00
|
|
|
PyMem_Free(buf);
|
|
|
|
}
|
|
|
|
|
2013-03-20 01:02:10 +00:00
|
|
|
static int
|
|
|
|
w_ref(PyObject *v, char *flag, WFILE *p)
|
|
|
|
{
|
2015-02-11 13:53:31 +00:00
|
|
|
_Py_hashtable_entry_t *entry;
|
|
|
|
int w;
|
2013-03-20 01:02:10 +00:00
|
|
|
|
2015-02-11 13:53:31 +00:00
|
|
|
if (p->version < 3 || p->hashtable == NULL)
|
2013-03-20 01:02:10 +00:00
|
|
|
return 0; /* not writing object references */
|
|
|
|
|
2022-05-04 01:01:15 +00:00
|
|
|
/* If it has only one reference, it definitely isn't shared.
|
|
|
|
* But we use TYPE_REF always for interned string, to PYC file stable
|
|
|
|
* as possible.
|
|
|
|
*/
|
|
|
|
if (Py_REFCNT(v) == 1 &&
|
|
|
|
!(PyUnicode_CheckExact(v) && PyUnicode_CHECK_INTERNED(v))) {
|
2013-03-20 01:02:10 +00:00
|
|
|
return 0;
|
2022-05-04 01:01:15 +00:00
|
|
|
}
|
2013-03-20 01:02:10 +00:00
|
|
|
|
2020-05-13 02:40:30 +00:00
|
|
|
entry = _Py_hashtable_get_entry(p->hashtable, v);
|
2015-02-11 13:53:31 +00:00
|
|
|
if (entry != NULL) {
|
2013-03-20 01:02:10 +00:00
|
|
|
/* write the reference index to the stream */
|
2020-05-13 02:40:30 +00:00
|
|
|
w = (int)(uintptr_t)entry->value;
|
2013-03-20 01:02:10 +00:00
|
|
|
/* we don't store "long" indices in the dict */
|
|
|
|
assert(0 <= w && w <= 0x7fffffff);
|
|
|
|
w_byte(TYPE_REF, p);
|
|
|
|
w_long(w, p);
|
|
|
|
return 1;
|
|
|
|
} else {
|
2020-05-14 19:55:47 +00:00
|
|
|
size_t s = p->hashtable->nentries;
|
2013-03-20 01:02:10 +00:00
|
|
|
/* we don't support long indices */
|
|
|
|
if (s >= 0x7fffffff) {
|
|
|
|
PyErr_SetString(PyExc_ValueError, "too many objects");
|
|
|
|
goto err;
|
|
|
|
}
|
2015-02-16 18:52:17 +00:00
|
|
|
w = (int)s;
|
2022-11-16 17:34:24 +00:00
|
|
|
if (_Py_hashtable_set(p->hashtable, Py_NewRef(v),
|
|
|
|
(void *)(uintptr_t)w) < 0) {
|
2015-02-11 13:53:31 +00:00
|
|
|
Py_DECREF(v);
|
2013-03-20 01:02:10 +00:00
|
|
|
goto err;
|
2015-02-11 13:53:31 +00:00
|
|
|
}
|
2013-03-20 01:02:10 +00:00
|
|
|
*flag |= FLAG_REF;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
err:
|
|
|
|
p->error = WFERR_UNMARSHALLABLE;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
w_complex_object(PyObject *v, char flag, WFILE *p);
|
|
|
|
|
1993-01-21 16:07:51 +00:00
|
|
|
static void
|
2000-07-22 18:47:25 +00:00
|
|
|
w_object(PyObject *v, WFILE *p)
|
1991-06-04 19:42:30 +00:00
|
|
|
{
|
2013-03-20 01:02:10 +00:00
|
|
|
char flag = '\0';
|
2010-05-09 15:52:27 +00:00
|
|
|
|
|
|
|
p->depth++;
|
|
|
|
|
|
|
|
if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
|
|
|
|
p->error = WFERR_NESTEDTOODEEP;
|
|
|
|
}
|
|
|
|
else if (v == NULL) {
|
|
|
|
w_byte(TYPE_NULL, p);
|
|
|
|
}
|
|
|
|
else if (v == Py_None) {
|
|
|
|
w_byte(TYPE_NONE, p);
|
|
|
|
}
|
|
|
|
else if (v == PyExc_StopIteration) {
|
|
|
|
w_byte(TYPE_STOPITER, p);
|
|
|
|
}
|
|
|
|
else if (v == Py_Ellipsis) {
|
|
|
|
w_byte(TYPE_ELLIPSIS, p);
|
|
|
|
}
|
|
|
|
else if (v == Py_False) {
|
|
|
|
w_byte(TYPE_FALSE, p);
|
|
|
|
}
|
|
|
|
else if (v == Py_True) {
|
|
|
|
w_byte(TYPE_TRUE, p);
|
|
|
|
}
|
2013-03-20 01:02:10 +00:00
|
|
|
else if (!w_ref(v, &flag, p))
|
|
|
|
w_complex_object(v, flag, p);
|
|
|
|
|
|
|
|
p->depth--;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
w_complex_object(PyObject *v, char flag, WFILE *p)
|
|
|
|
{
|
|
|
|
Py_ssize_t i, n;
|
|
|
|
|
|
|
|
if (PyLong_CheckExact(v)) {
|
2020-03-31 20:23:21 +00:00
|
|
|
int overflow;
|
|
|
|
long x = PyLong_AsLongAndOverflow(v, &overflow);
|
|
|
|
if (overflow) {
|
|
|
|
w_PyLong((PyLongObject *)v, flag, p);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
else {
|
1996-12-10 15:39:04 +00:00
|
|
|
#if SIZEOF_LONG > 4
|
2010-05-09 15:52:27 +00:00
|
|
|
long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);
|
|
|
|
if (y && y != -1) {
|
2012-07-28 17:44:05 +00:00
|
|
|
/* Too large for TYPE_INT */
|
2013-03-20 01:02:10 +00:00
|
|
|
w_PyLong((PyLongObject*)v, flag, p);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
else
|
1996-12-10 15:39:04 +00:00
|
|
|
#endif
|
2010-05-09 15:52:27 +00:00
|
|
|
{
|
2013-03-20 01:02:10 +00:00
|
|
|
W_TYPE(TYPE_INT, p);
|
2010-05-09 15:52:27 +00:00
|
|
|
w_long(x, p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (PyFloat_CheckExact(v)) {
|
|
|
|
if (p->version > 1) {
|
2013-03-20 01:02:10 +00:00
|
|
|
W_TYPE(TYPE_BINARY_FLOAT, p);
|
2018-07-24 07:55:47 +00:00
|
|
|
w_float_bin(PyFloat_AS_DOUBLE(v), p);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
else {
|
2013-03-20 01:02:10 +00:00
|
|
|
W_TYPE(TYPE_FLOAT, p);
|
2018-07-24 07:55:47 +00:00
|
|
|
w_float_str(PyFloat_AS_DOUBLE(v), p);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (PyComplex_CheckExact(v)) {
|
|
|
|
if (p->version > 1) {
|
2013-03-20 01:02:10 +00:00
|
|
|
W_TYPE(TYPE_BINARY_COMPLEX, p);
|
2018-07-24 07:55:47 +00:00
|
|
|
w_float_bin(PyComplex_RealAsDouble(v), p);
|
|
|
|
w_float_bin(PyComplex_ImagAsDouble(v), p);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
else {
|
2013-03-20 01:02:10 +00:00
|
|
|
W_TYPE(TYPE_COMPLEX, p);
|
2018-07-24 07:55:47 +00:00
|
|
|
w_float_str(PyComplex_RealAsDouble(v), p);
|
|
|
|
w_float_str(PyComplex_ImagAsDouble(v), p);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (PyBytes_CheckExact(v)) {
|
2013-03-20 01:02:10 +00:00
|
|
|
W_TYPE(TYPE_STRING, p);
|
2013-07-11 16:14:26 +00:00
|
|
|
w_pstring(PyBytes_AS_STRING(v), PyBytes_GET_SIZE(v), p);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
else if (PyUnicode_CheckExact(v)) {
|
2013-10-12 20:25:39 +00:00
|
|
|
if (p->version >= 4 && PyUnicode_IS_ASCII(v)) {
|
|
|
|
int is_short = PyUnicode_GET_LENGTH(v) < 256;
|
|
|
|
if (is_short) {
|
|
|
|
if (PyUnicode_CHECK_INTERNED(v))
|
|
|
|
W_TYPE(TYPE_SHORT_ASCII_INTERNED, p);
|
|
|
|
else
|
|
|
|
W_TYPE(TYPE_SHORT_ASCII, p);
|
2020-03-31 20:23:21 +00:00
|
|
|
w_short_pstring(PyUnicode_1BYTE_DATA(v),
|
2013-10-12 20:25:39 +00:00
|
|
|
PyUnicode_GET_LENGTH(v), p);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (PyUnicode_CHECK_INTERNED(v))
|
|
|
|
W_TYPE(TYPE_ASCII_INTERNED, p);
|
|
|
|
else
|
|
|
|
W_TYPE(TYPE_ASCII, p);
|
2020-03-31 20:23:21 +00:00
|
|
|
w_pstring(PyUnicode_1BYTE_DATA(v),
|
2013-10-12 20:25:39 +00:00
|
|
|
PyUnicode_GET_LENGTH(v), p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
PyObject *utf8;
|
|
|
|
utf8 = PyUnicode_AsEncodedString(v, "utf8", "surrogatepass");
|
|
|
|
if (utf8 == NULL) {
|
|
|
|
p->depth--;
|
|
|
|
p->error = WFERR_UNMARSHALLABLE;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (p->version >= 3 && PyUnicode_CHECK_INTERNED(v))
|
|
|
|
W_TYPE(TYPE_INTERNED, p);
|
|
|
|
else
|
|
|
|
W_TYPE(TYPE_UNICODE, p);
|
|
|
|
w_pstring(PyBytes_AS_STRING(utf8), PyBytes_GET_SIZE(utf8), p);
|
|
|
|
Py_DECREF(utf8);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (PyTuple_CheckExact(v)) {
|
2020-03-31 20:23:21 +00:00
|
|
|
n = PyTuple_GET_SIZE(v);
|
2013-10-12 20:25:39 +00:00
|
|
|
if (p->version >= 4 && n < 256) {
|
|
|
|
W_TYPE(TYPE_SMALL_TUPLE, p);
|
2013-11-15 23:13:29 +00:00
|
|
|
w_byte((unsigned char)n, p);
|
2013-10-12 20:25:39 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
W_TYPE(TYPE_TUPLE, p);
|
|
|
|
W_SIZE(n, p);
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
w_object(PyTuple_GET_ITEM(v, i), p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (PyList_CheckExact(v)) {
|
2013-03-20 01:02:10 +00:00
|
|
|
W_TYPE(TYPE_LIST, p);
|
2010-05-09 15:52:27 +00:00
|
|
|
n = PyList_GET_SIZE(v);
|
2013-02-13 10:08:15 +00:00
|
|
|
W_SIZE(n, p);
|
2010-05-09 15:52:27 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
w_object(PyList_GET_ITEM(v, i), p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (PyDict_CheckExact(v)) {
|
|
|
|
Py_ssize_t pos;
|
|
|
|
PyObject *key, *value;
|
2013-03-20 01:02:10 +00:00
|
|
|
W_TYPE(TYPE_DICT, p);
|
2010-05-09 15:52:27 +00:00
|
|
|
/* This one is NULL object terminated! */
|
|
|
|
pos = 0;
|
|
|
|
while (PyDict_Next(v, &pos, &key, &value)) {
|
|
|
|
w_object(key, p);
|
|
|
|
w_object(value, p);
|
|
|
|
}
|
|
|
|
w_object((PyObject *)NULL, p);
|
|
|
|
}
|
|
|
|
else if (PyAnySet_CheckExact(v)) {
|
2020-03-31 20:23:21 +00:00
|
|
|
PyObject *value;
|
|
|
|
Py_ssize_t pos = 0;
|
|
|
|
Py_hash_t hash;
|
2010-05-09 15:52:27 +00:00
|
|
|
|
2020-03-31 20:23:21 +00:00
|
|
|
if (PyFrozenSet_CheckExact(v))
|
2013-03-20 01:02:10 +00:00
|
|
|
W_TYPE(TYPE_FROZENSET, p);
|
2020-03-31 20:23:21 +00:00
|
|
|
else
|
|
|
|
W_TYPE(TYPE_SET, p);
|
|
|
|
n = PySet_GET_SIZE(v);
|
2013-02-13 10:08:15 +00:00
|
|
|
W_SIZE(n, p);
|
2021-08-25 11:14:34 +00:00
|
|
|
// bpo-37596: To support reproducible builds, sets and frozensets need
|
|
|
|
// to have their elements serialized in a consistent order (even when
|
|
|
|
// they have been scrambled by hash randomization). To ensure this, we
|
|
|
|
// use an order equivalent to sorted(v, key=marshal.dumps):
|
2021-08-31 16:18:33 +00:00
|
|
|
PyObject *pairs = PyList_New(n);
|
2021-08-25 11:14:34 +00:00
|
|
|
if (pairs == NULL) {
|
|
|
|
p->error = WFERR_NOMEMORY;
|
|
|
|
return;
|
|
|
|
}
|
2021-08-31 16:18:33 +00:00
|
|
|
Py_ssize_t i = 0;
|
2024-04-18 15:18:22 +00:00
|
|
|
Py_BEGIN_CRITICAL_SECTION(v);
|
|
|
|
while (_PySet_NextEntryRef(v, &pos, &value, &hash)) {
|
2024-01-16 16:05:15 +00:00
|
|
|
PyObject *dump = _PyMarshal_WriteObjectToString(value,
|
|
|
|
p->version, p->allow_code);
|
2021-08-25 11:14:34 +00:00
|
|
|
if (dump == NULL) {
|
|
|
|
p->error = WFERR_UNMARSHALLABLE;
|
2024-04-18 15:18:22 +00:00
|
|
|
Py_DECREF(value);
|
|
|
|
break;
|
2021-08-25 11:14:34 +00:00
|
|
|
}
|
|
|
|
PyObject *pair = PyTuple_Pack(2, dump, value);
|
|
|
|
Py_DECREF(dump);
|
2024-04-18 15:18:22 +00:00
|
|
|
Py_DECREF(value);
|
2021-08-31 16:18:33 +00:00
|
|
|
if (pair == NULL) {
|
2021-08-25 11:14:34 +00:00
|
|
|
p->error = WFERR_NOMEMORY;
|
2024-04-18 15:18:22 +00:00
|
|
|
break;
|
2021-08-25 11:14:34 +00:00
|
|
|
}
|
2021-08-31 16:18:33 +00:00
|
|
|
PyList_SET_ITEM(pairs, i++, pair);
|
2021-08-25 11:14:34 +00:00
|
|
|
}
|
2024-04-18 15:18:22 +00:00
|
|
|
Py_END_CRITICAL_SECTION();
|
|
|
|
if (p->error == WFERR_UNMARSHALLABLE || p->error == WFERR_NOMEMORY) {
|
|
|
|
Py_DECREF(pairs);
|
|
|
|
return;
|
|
|
|
}
|
2021-08-31 16:18:33 +00:00
|
|
|
assert(i == n);
|
2021-08-25 11:14:34 +00:00
|
|
|
if (PyList_Sort(pairs)) {
|
|
|
|
p->error = WFERR_NOMEMORY;
|
2021-08-31 16:18:33 +00:00
|
|
|
Py_DECREF(pairs);
|
|
|
|
return;
|
2021-08-25 11:14:34 +00:00
|
|
|
}
|
|
|
|
for (Py_ssize_t i = 0; i < n; i++) {
|
|
|
|
PyObject *pair = PyList_GET_ITEM(pairs, i);
|
|
|
|
value = PyTuple_GET_ITEM(pair, 1);
|
2010-05-09 15:52:27 +00:00
|
|
|
w_object(value, p);
|
|
|
|
}
|
2021-08-25 11:14:34 +00:00
|
|
|
Py_DECREF(pairs);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
else if (PyCode_Check(v)) {
|
2024-01-16 16:05:15 +00:00
|
|
|
if (!p->allow_code) {
|
|
|
|
p->error = WFERR_CODE_NOT_ALLOWED;
|
|
|
|
return;
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
PyCodeObject *co = (PyCodeObject *)v;
|
2022-03-21 11:11:17 +00:00
|
|
|
PyObject *co_code = _PyCode_GetCode(co);
|
|
|
|
if (co_code == NULL) {
|
|
|
|
p->error = WFERR_NOMEMORY;
|
|
|
|
return;
|
|
|
|
}
|
2013-03-20 01:02:10 +00:00
|
|
|
W_TYPE(TYPE_CODE, p);
|
2010-05-09 15:52:27 +00:00
|
|
|
w_long(co->co_argcount, p);
|
2019-04-29 12:36:57 +00:00
|
|
|
w_long(co->co_posonlyargcount, p);
|
2010-05-09 15:52:27 +00:00
|
|
|
w_long(co->co_kwonlyargcount, p);
|
|
|
|
w_long(co->co_stacksize, p);
|
|
|
|
w_long(co->co_flags, p);
|
2022-03-21 11:11:17 +00:00
|
|
|
w_object(co_code, p);
|
2010-05-09 15:52:27 +00:00
|
|
|
w_object(co->co_consts, p);
|
|
|
|
w_object(co->co_names, p);
|
2021-06-07 18:22:26 +00:00
|
|
|
w_object(co->co_localsplusnames, p);
|
2021-06-21 20:53:04 +00:00
|
|
|
w_object(co->co_localspluskinds, p);
|
2010-05-09 15:52:27 +00:00
|
|
|
w_object(co->co_filename, p);
|
|
|
|
w_object(co->co_name, p);
|
2021-07-07 11:21:51 +00:00
|
|
|
w_object(co->co_qualname, p);
|
2010-05-09 15:52:27 +00:00
|
|
|
w_long(co->co_firstlineno, p);
|
2020-11-12 09:43:29 +00:00
|
|
|
w_object(co->co_linetable, p);
|
2021-05-07 14:19:19 +00:00
|
|
|
w_object(co->co_exceptiontable, p);
|
2022-03-21 11:11:17 +00:00
|
|
|
Py_DECREF(co_code);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
else if (PyObject_CheckBuffer(v)) {
|
2017-03-12 06:53:22 +00:00
|
|
|
/* Write unknown bytes-like objects as a bytes object */
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_buffer view;
|
2012-03-02 17:12:43 +00:00
|
|
|
if (PyObject_GetBuffer(v, &view, PyBUF_SIMPLE) != 0) {
|
2010-05-09 15:52:27 +00:00
|
|
|
w_byte(TYPE_UNKNOWN, p);
|
2012-03-02 17:12:43 +00:00
|
|
|
p->depth--;
|
2010-05-09 15:52:27 +00:00
|
|
|
p->error = WFERR_UNMARSHALLABLE;
|
2012-03-02 17:12:43 +00:00
|
|
|
return;
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
2013-03-20 01:02:10 +00:00
|
|
|
W_TYPE(TYPE_STRING, p);
|
2013-07-11 16:14:26 +00:00
|
|
|
w_pstring(view.buf, view.len, p);
|
2012-03-02 17:12:43 +00:00
|
|
|
PyBuffer_Release(&view);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
else {
|
2013-03-20 01:02:10 +00:00
|
|
|
W_TYPE(TYPE_UNKNOWN, p);
|
2010-05-09 15:52:27 +00:00
|
|
|
p->error = WFERR_UNMARSHALLABLE;
|
|
|
|
}
|
1991-06-04 19:42:30 +00:00
|
|
|
}
|
|
|
|
|
2020-05-13 00:50:18 +00:00
|
|
|
static void
|
|
|
|
w_decref_entry(void *key)
|
|
|
|
{
|
|
|
|
PyObject *entry_key = (PyObject *)key;
|
|
|
|
Py_XDECREF(entry_key);
|
|
|
|
}
|
|
|
|
|
2015-02-11 13:53:31 +00:00
|
|
|
static int
|
|
|
|
w_init_refs(WFILE *wf, int version)
|
|
|
|
{
|
|
|
|
if (version >= 3) {
|
2020-05-13 02:40:30 +00:00
|
|
|
wf->hashtable = _Py_hashtable_new_full(_Py_hashtable_hash_ptr,
|
2020-05-13 00:50:18 +00:00
|
|
|
_Py_hashtable_compare_direct,
|
|
|
|
w_decref_entry, NULL, NULL);
|
2015-02-11 13:53:31 +00:00
|
|
|
if (wf->hashtable == NULL) {
|
|
|
|
PyErr_NoMemory();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
w_clear_refs(WFILE *wf)
|
|
|
|
{
|
|
|
|
if (wf->hashtable != NULL) {
|
|
|
|
_Py_hashtable_destroy(wf->hashtable);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-27 16:40:23 +00:00
|
|
|
/* version currently has no effect for writing ints. */
|
2023-06-02 07:59:18 +00:00
|
|
|
/* Note that while the documentation states that this function
|
|
|
|
* can error, currently it never does. Setting an exception in
|
|
|
|
* this function should be regarded as an API-breaking change.
|
|
|
|
*/
|
1993-01-21 16:07:51 +00:00
|
|
|
void
|
2004-06-27 16:51:46 +00:00
|
|
|
PyMarshal_WriteLongToFile(long x, FILE *fp, int version)
|
1993-01-21 16:07:51 +00:00
|
|
|
{
|
2015-02-11 13:54:54 +00:00
|
|
|
char buf[4];
|
2010-05-09 15:52:27 +00:00
|
|
|
WFILE wf;
|
2015-02-11 13:53:31 +00:00
|
|
|
memset(&wf, 0, sizeof(wf));
|
2010-05-09 15:52:27 +00:00
|
|
|
wf.fp = fp;
|
2015-02-11 13:54:54 +00:00
|
|
|
wf.ptr = wf.buf = buf;
|
|
|
|
wf.end = wf.ptr + sizeof(buf);
|
2010-05-09 15:52:27 +00:00
|
|
|
wf.error = WFERR_OK;
|
|
|
|
wf.version = version;
|
|
|
|
w_long(x, &wf);
|
2015-02-11 13:54:54 +00:00
|
|
|
w_flush(&wf);
|
1993-01-21 16:07:51 +00:00
|
|
|
}
|
1991-06-04 19:42:30 +00:00
|
|
|
|
1993-01-21 16:07:51 +00:00
|
|
|
void
|
2004-06-27 16:51:46 +00:00
|
|
|
PyMarshal_WriteObjectToFile(PyObject *x, FILE *fp, int version)
|
1993-01-21 16:07:51 +00:00
|
|
|
{
|
2015-02-11 13:54:54 +00:00
|
|
|
char buf[BUFSIZ];
|
2010-05-09 15:52:27 +00:00
|
|
|
WFILE wf;
|
2021-06-30 16:21:37 +00:00
|
|
|
if (PySys_Audit("marshal.dumps", "Oi", x, version) < 0) {
|
|
|
|
return; /* caller must check PyErr_Occurred() */
|
|
|
|
}
|
2015-02-11 13:53:31 +00:00
|
|
|
memset(&wf, 0, sizeof(wf));
|
2010-05-09 15:52:27 +00:00
|
|
|
wf.fp = fp;
|
2015-02-11 13:54:54 +00:00
|
|
|
wf.ptr = wf.buf = buf;
|
|
|
|
wf.end = wf.ptr + sizeof(buf);
|
2010-05-09 15:52:27 +00:00
|
|
|
wf.error = WFERR_OK;
|
|
|
|
wf.version = version;
|
2024-01-16 16:05:15 +00:00
|
|
|
wf.allow_code = 1;
|
2021-06-30 16:21:37 +00:00
|
|
|
if (w_init_refs(&wf, version)) {
|
|
|
|
return; /* caller must check PyErr_Occurred() */
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
w_object(x, &wf);
|
2015-02-11 13:53:31 +00:00
|
|
|
w_clear_refs(&wf);
|
2015-02-11 13:54:54 +00:00
|
|
|
w_flush(&wf);
|
1993-01-21 16:07:51 +00:00
|
|
|
}
|
|
|
|
|
2015-02-11 14:18:09 +00:00
|
|
|
typedef struct {
|
|
|
|
FILE *fp;
|
|
|
|
int depth;
|
|
|
|
PyObject *readable; /* Stream-like object being read from */
|
2020-03-31 20:23:21 +00:00
|
|
|
const char *ptr;
|
|
|
|
const char *end;
|
2015-02-11 14:18:09 +00:00
|
|
|
char *buf;
|
|
|
|
Py_ssize_t buf_size;
|
|
|
|
PyObject *refs; /* a list */
|
2024-01-16 16:05:15 +00:00
|
|
|
int allow_code;
|
2015-02-11 14:18:09 +00:00
|
|
|
} RFILE;
|
1993-01-21 16:07:51 +00:00
|
|
|
|
2015-12-25 18:01:53 +00:00
|
|
|
static const char *
|
2013-10-12 20:25:39 +00:00
|
|
|
r_string(Py_ssize_t n, RFILE *p)
|
1993-01-21 16:07:51 +00:00
|
|
|
{
|
2013-10-12 20:25:39 +00:00
|
|
|
Py_ssize_t read = -1;
|
|
|
|
|
|
|
|
if (p->ptr != NULL) {
|
|
|
|
/* Fast path for loads() */
|
2020-03-31 20:23:21 +00:00
|
|
|
const char *res = p->ptr;
|
2013-10-12 20:25:39 +00:00
|
|
|
Py_ssize_t left = p->end - p->ptr;
|
|
|
|
if (left < n) {
|
|
|
|
PyErr_SetString(PyExc_EOFError,
|
|
|
|
"marshal data too short");
|
|
|
|
return NULL;
|
2011-07-02 15:42:47 +00:00
|
|
|
}
|
2013-10-12 20:25:39 +00:00
|
|
|
p->ptr += n;
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
if (p->buf == NULL) {
|
2020-12-01 08:56:42 +00:00
|
|
|
p->buf = PyMem_Malloc(n);
|
2013-10-12 20:25:39 +00:00
|
|
|
if (p->buf == NULL) {
|
|
|
|
PyErr_NoMemory();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
p->buf_size = n;
|
|
|
|
}
|
|
|
|
else if (p->buf_size < n) {
|
2020-12-01 08:56:42 +00:00
|
|
|
char *tmp = PyMem_Realloc(p->buf, n);
|
2018-12-07 10:11:30 +00:00
|
|
|
if (tmp == NULL) {
|
2013-10-12 20:25:39 +00:00
|
|
|
PyErr_NoMemory();
|
|
|
|
return NULL;
|
|
|
|
}
|
2018-12-07 10:11:30 +00:00
|
|
|
p->buf = tmp;
|
2013-10-12 20:25:39 +00:00
|
|
|
p->buf_size = n;
|
|
|
|
}
|
2013-10-31 15:56:38 +00:00
|
|
|
|
2013-10-12 20:25:39 +00:00
|
|
|
if (!p->readable) {
|
|
|
|
assert(p->fp != NULL);
|
|
|
|
read = fread(p->buf, 1, n, p->fp);
|
2011-07-02 15:42:47 +00:00
|
|
|
}
|
|
|
|
else {
|
2013-10-12 20:25:39 +00:00
|
|
|
PyObject *res, *mview;
|
|
|
|
Py_buffer buf;
|
|
|
|
|
|
|
|
if (PyBuffer_FillInfo(&buf, NULL, p->buf, n, 0, PyBUF_CONTIG) == -1)
|
|
|
|
return NULL;
|
|
|
|
mview = PyMemoryView_FromBuffer(&buf);
|
|
|
|
if (mview == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2022-02-08 20:39:07 +00:00
|
|
|
res = _PyObject_CallMethod(p->readable, &_Py_ID(readinto), "N", mview);
|
2013-10-12 20:25:39 +00:00
|
|
|
if (res != NULL) {
|
|
|
|
read = PyNumber_AsSsize_t(res, PyExc_ValueError);
|
|
|
|
Py_DECREF(res);
|
2011-07-02 15:42:47 +00:00
|
|
|
}
|
|
|
|
}
|
2013-10-12 20:25:39 +00:00
|
|
|
if (read != n) {
|
|
|
|
if (!PyErr_Occurred()) {
|
|
|
|
if (read > n)
|
|
|
|
PyErr_Format(PyExc_ValueError,
|
|
|
|
"read() returned too much data: "
|
|
|
|
"%zd bytes requested, %zd returned",
|
|
|
|
n, read);
|
|
|
|
else
|
|
|
|
PyErr_SetString(PyExc_EOFError,
|
|
|
|
"EOF read where not expected");
|
|
|
|
}
|
|
|
|
return NULL;
|
2011-07-02 15:42:47 +00:00
|
|
|
}
|
2013-10-12 20:25:39 +00:00
|
|
|
return p->buf;
|
2011-07-02 15:42:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
r_byte(RFILE *p)
|
|
|
|
{
|
2013-10-12 20:25:39 +00:00
|
|
|
if (p->ptr != NULL) {
|
2023-06-29 09:22:19 +00:00
|
|
|
if (p->ptr < p->end) {
|
|
|
|
return (unsigned char) *p->ptr++;
|
|
|
|
}
|
2013-10-12 20:25:39 +00:00
|
|
|
}
|
2023-06-29 09:22:19 +00:00
|
|
|
else if (!p->readable) {
|
2013-10-12 20:25:39 +00:00
|
|
|
assert(p->fp);
|
2023-06-29 09:22:19 +00:00
|
|
|
int c = getc(p->fp);
|
|
|
|
if (c != EOF) {
|
|
|
|
return c;
|
|
|
|
}
|
2013-10-12 20:25:39 +00:00
|
|
|
}
|
2011-07-02 15:42:47 +00:00
|
|
|
else {
|
2015-12-25 18:01:53 +00:00
|
|
|
const char *ptr = r_string(1, p);
|
2023-06-29 09:22:19 +00:00
|
|
|
if (ptr != NULL) {
|
|
|
|
return *(const unsigned char *) ptr;
|
|
|
|
}
|
|
|
|
return EOF;
|
2011-07-02 15:42:47 +00:00
|
|
|
}
|
2023-06-29 09:22:19 +00:00
|
|
|
PyErr_SetString(PyExc_EOFError,
|
|
|
|
"EOF read where not expected");
|
|
|
|
return EOF;
|
1993-01-21 16:07:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2000-07-22 18:47:25 +00:00
|
|
|
r_short(RFILE *p)
|
1991-06-04 19:42:30 +00:00
|
|
|
{
|
2013-10-12 20:25:39 +00:00
|
|
|
short x = -1;
|
2015-12-25 18:01:53 +00:00
|
|
|
const unsigned char *buffer;
|
2013-10-12 20:25:39 +00:00
|
|
|
|
2015-12-25 18:01:53 +00:00
|
|
|
buffer = (const unsigned char *) r_string(2, p);
|
2013-10-12 20:25:39 +00:00
|
|
|
if (buffer != NULL) {
|
|
|
|
x = buffer[0];
|
|
|
|
x |= buffer[1] << 8;
|
|
|
|
/* Sign-extension, in case short greater than 16 bits */
|
|
|
|
x |= -(x & 0x8000);
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
return x;
|
1991-06-04 19:42:30 +00:00
|
|
|
}
|
|
|
|
|
1993-01-21 16:07:51 +00:00
|
|
|
static long
|
2000-07-22 18:47:25 +00:00
|
|
|
r_long(RFILE *p)
|
1991-06-04 19:42:30 +00:00
|
|
|
{
|
2013-10-12 20:25:39 +00:00
|
|
|
long x = -1;
|
2015-12-25 18:01:53 +00:00
|
|
|
const unsigned char *buffer;
|
2013-10-12 20:25:39 +00:00
|
|
|
|
2015-12-25 18:01:53 +00:00
|
|
|
buffer = (const unsigned char *) r_string(4, p);
|
2013-10-12 20:25:39 +00:00
|
|
|
if (buffer != NULL) {
|
|
|
|
x = buffer[0];
|
|
|
|
x |= (long)buffer[1] << 8;
|
|
|
|
x |= (long)buffer[2] << 16;
|
|
|
|
x |= (long)buffer[3] << 24;
|
1996-12-10 15:39:04 +00:00
|
|
|
#if SIZEOF_LONG > 4
|
2013-10-12 20:25:39 +00:00
|
|
|
/* Sign extension for 64-bit machines */
|
|
|
|
x |= -(x & 0x80000000L);
|
1996-12-10 15:39:04 +00:00
|
|
|
#endif
|
2013-10-12 20:25:39 +00:00
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
return x;
|
1996-12-05 23:15:02 +00:00
|
|
|
}
|
|
|
|
|
2017-11-15 15:41:05 +00:00
|
|
|
/* r_long64 deals with the TYPE_INT64 code. */
|
|
|
|
static PyObject *
|
|
|
|
r_long64(RFILE *p)
|
|
|
|
{
|
|
|
|
const unsigned char *buffer = (const unsigned char *) r_string(8, p);
|
|
|
|
if (buffer == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return _PyLong_FromByteArray(buffer, 8,
|
|
|
|
1 /* little endian */,
|
|
|
|
1 /* signed */);
|
|
|
|
}
|
|
|
|
|
2009-03-18 20:06:12 +00:00
|
|
|
static PyObject *
|
|
|
|
r_PyLong(RFILE *p)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyLongObject *ob;
|
2013-02-13 10:08:15 +00:00
|
|
|
long n, size, i;
|
|
|
|
int j, md, shorts_in_top_digit;
|
2010-05-09 15:52:27 +00:00
|
|
|
digit d;
|
|
|
|
|
|
|
|
n = r_long(p);
|
|
|
|
if (n == 0)
|
|
|
|
return (PyObject *)_PyLong_New(0);
|
2023-06-29 09:22:19 +00:00
|
|
|
if (n == -1 && PyErr_Occurred()) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-02-13 10:08:15 +00:00
|
|
|
if (n < -SIZE32_MAX || n > SIZE32_MAX) {
|
2010-05-09 15:52:27 +00:00
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"bad marshal data (long size out of range)");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-05-14 15:24:35 +00:00
|
|
|
size = 1 + (Py_ABS(n) - 1) / PyLong_MARSHAL_RATIO;
|
|
|
|
shorts_in_top_digit = 1 + (Py_ABS(n) - 1) % PyLong_MARSHAL_RATIO;
|
2010-05-09 15:52:27 +00:00
|
|
|
ob = _PyLong_New(size);
|
|
|
|
if (ob == NULL)
|
|
|
|
return NULL;
|
2013-10-31 15:56:38 +00:00
|
|
|
|
2023-03-22 14:49:51 +00:00
|
|
|
_PyLong_SetSignAndDigitCount(ob, n < 0 ? -1 : 1, size);
|
2010-05-09 15:52:27 +00:00
|
|
|
|
|
|
|
for (i = 0; i < size-1; i++) {
|
|
|
|
d = 0;
|
|
|
|
for (j=0; j < PyLong_MARSHAL_RATIO; j++) {
|
|
|
|
md = r_short(p);
|
|
|
|
if (md < 0 || md > PyLong_MARSHAL_BASE)
|
|
|
|
goto bad_digit;
|
|
|
|
d += (digit)md << j*PyLong_MARSHAL_SHIFT;
|
|
|
|
}
|
2023-01-30 10:03:04 +00:00
|
|
|
ob->long_value.ob_digit[i] = d;
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
2013-10-31 15:56:38 +00:00
|
|
|
|
2010-05-09 15:52:27 +00:00
|
|
|
d = 0;
|
|
|
|
for (j=0; j < shorts_in_top_digit; j++) {
|
|
|
|
md = r_short(p);
|
|
|
|
if (md < 0 || md > PyLong_MARSHAL_BASE)
|
|
|
|
goto bad_digit;
|
|
|
|
/* topmost marshal digit should be nonzero */
|
|
|
|
if (md == 0 && j == shorts_in_top_digit - 1) {
|
|
|
|
Py_DECREF(ob);
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"bad marshal data (unnormalized long data)");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
d += (digit)md << j*PyLong_MARSHAL_SHIFT;
|
|
|
|
}
|
2023-06-29 09:22:19 +00:00
|
|
|
assert(!PyErr_Occurred());
|
2010-05-09 15:52:27 +00:00
|
|
|
/* top digit should be nonzero, else the resulting PyLong won't be
|
|
|
|
normalized */
|
2023-01-30 10:03:04 +00:00
|
|
|
ob->long_value.ob_digit[size-1] = d;
|
2010-05-09 15:52:27 +00:00
|
|
|
return (PyObject *)ob;
|
2009-03-18 20:06:12 +00:00
|
|
|
bad_digit:
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_DECREF(ob);
|
2023-06-29 09:22:19 +00:00
|
|
|
if (!PyErr_Occurred()) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"bad marshal data (digit out of range in long)");
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
return NULL;
|
2009-03-18 20:06:12 +00:00
|
|
|
}
|
|
|
|
|
2018-07-24 07:55:47 +00:00
|
|
|
static double
|
|
|
|
r_float_bin(RFILE *p)
|
|
|
|
{
|
2022-03-11 23:10:02 +00:00
|
|
|
const char *buf = r_string(8, p);
|
2018-07-24 07:55:47 +00:00
|
|
|
if (buf == NULL)
|
|
|
|
return -1;
|
2022-03-11 23:10:02 +00:00
|
|
|
return PyFloat_Unpack8(buf, 1);
|
2018-07-24 07:55:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Issue #33720: Disable inlining for reducing the C stack consumption
|
|
|
|
on PGO builds. */
|
2021-09-03 14:44:02 +00:00
|
|
|
Py_NO_INLINE static double
|
2018-07-24 07:55:47 +00:00
|
|
|
r_float_str(RFILE *p)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
char buf[256];
|
|
|
|
const char *ptr;
|
|
|
|
n = r_byte(p);
|
|
|
|
if (n == EOF) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
ptr = r_string(n, p);
|
|
|
|
if (ptr == NULL) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
memcpy(buf, ptr, n);
|
|
|
|
buf[n] = '\0';
|
|
|
|
return PyOS_string_to_double(buf, NULL, NULL);
|
|
|
|
}
|
|
|
|
|
2013-03-20 18:43:57 +00:00
|
|
|
/* allocate the reflist index for a new object. Return -1 on failure */
|
|
|
|
static Py_ssize_t
|
|
|
|
r_ref_reserve(int flag, RFILE *p)
|
2013-03-20 01:02:10 +00:00
|
|
|
{
|
|
|
|
if (flag) { /* currently only FLAG_REF is defined */
|
2013-10-12 20:25:39 +00:00
|
|
|
Py_ssize_t idx = PyList_GET_SIZE(p->refs);
|
2013-03-20 18:43:57 +00:00
|
|
|
if (idx >= 0x7ffffffe) {
|
2013-03-20 01:02:10 +00:00
|
|
|
PyErr_SetString(PyExc_ValueError, "bad marshal data (index list too large)");
|
2013-03-20 18:43:57 +00:00
|
|
|
return -1;
|
2013-03-20 01:02:10 +00:00
|
|
|
}
|
|
|
|
if (PyList_Append(p->refs, Py_None) < 0)
|
2013-03-20 18:43:57 +00:00
|
|
|
return -1;
|
|
|
|
return idx;
|
2013-03-20 01:02:10 +00:00
|
|
|
} else
|
2013-03-20 18:43:57 +00:00
|
|
|
return 0;
|
2013-03-20 01:02:10 +00:00
|
|
|
}
|
|
|
|
|
2013-03-20 18:43:57 +00:00
|
|
|
/* insert the new object 'o' to the reflist at previously
|
|
|
|
* allocated index 'idx'.
|
|
|
|
* 'o' can be NULL, in which case nothing is done.
|
|
|
|
* if 'o' was non-NULL, and the function succeeds, 'o' is returned.
|
|
|
|
* if 'o' was non-NULL, and the function fails, 'o' is released and
|
|
|
|
* NULL returned. This simplifies error checking at the call site since
|
|
|
|
* a single test for NULL for the function result is enough.
|
|
|
|
*/
|
2013-03-20 01:02:10 +00:00
|
|
|
static PyObject *
|
|
|
|
r_ref_insert(PyObject *o, Py_ssize_t idx, int flag, RFILE *p)
|
|
|
|
{
|
2013-03-20 18:43:57 +00:00
|
|
|
if (o != NULL && flag) { /* currently only FLAG_REF is defined */
|
2013-10-12 20:25:39 +00:00
|
|
|
PyObject *tmp = PyList_GET_ITEM(p->refs, idx);
|
2022-11-10 08:03:39 +00:00
|
|
|
PyList_SET_ITEM(p->refs, idx, Py_NewRef(o));
|
2013-10-12 20:25:39 +00:00
|
|
|
Py_DECREF(tmp);
|
2013-03-20 01:02:10 +00:00
|
|
|
}
|
|
|
|
return o;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* combination of both above, used when an object can be
|
|
|
|
* created whenever it is seen in the file, as opposed to
|
|
|
|
* after having loaded its sub-objects.
|
|
|
|
*/
|
|
|
|
static PyObject *
|
|
|
|
r_ref(PyObject *o, int flag, RFILE *p)
|
|
|
|
{
|
2013-10-31 16:09:01 +00:00
|
|
|
assert(flag & FLAG_REF);
|
|
|
|
if (o == NULL)
|
|
|
|
return NULL;
|
|
|
|
if (PyList_Append(p->refs, o) < 0) {
|
|
|
|
Py_DECREF(o); /* release the new object */
|
|
|
|
return NULL;
|
2013-03-20 01:02:10 +00:00
|
|
|
}
|
|
|
|
return o;
|
|
|
|
}
|
2009-03-18 20:06:12 +00:00
|
|
|
|
1997-04-29 20:08:16 +00:00
|
|
|
static PyObject *
|
2000-07-22 18:47:25 +00:00
|
|
|
r_object(RFILE *p)
|
1991-06-04 19:42:30 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
/* NULL is a valid return value, it does not necessarily means that
|
|
|
|
an exception is set. */
|
|
|
|
PyObject *v, *v2;
|
2013-03-20 05:40:07 +00:00
|
|
|
Py_ssize_t idx = 0;
|
2010-05-09 15:52:27 +00:00
|
|
|
long i, n;
|
2013-03-20 21:26:33 +00:00
|
|
|
int type, code = r_byte(p);
|
2013-10-12 20:25:39 +00:00
|
|
|
int flag, is_interned = 0;
|
2013-10-13 00:29:06 +00:00
|
|
|
PyObject *retval = NULL;
|
2010-05-09 15:52:27 +00:00
|
|
|
|
2013-03-20 21:26:33 +00:00
|
|
|
if (code == EOF) {
|
2023-06-29 09:22:19 +00:00
|
|
|
if (PyErr_ExceptionMatches(PyExc_EOFError)) {
|
|
|
|
PyErr_SetString(PyExc_EOFError,
|
|
|
|
"EOF read where object expected");
|
|
|
|
}
|
2013-03-20 21:26:33 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-05-09 15:52:27 +00:00
|
|
|
p->depth++;
|
|
|
|
|
|
|
|
if (p->depth > MAX_MARSHAL_STACK_DEPTH) {
|
|
|
|
p->depth--;
|
|
|
|
PyErr_SetString(PyExc_ValueError, "recursion limit exceeded");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-03-20 21:26:33 +00:00
|
|
|
flag = code & FLAG_REF;
|
|
|
|
type = code & ~FLAG_REF;
|
2013-03-20 01:02:10 +00:00
|
|
|
|
|
|
|
#define R_REF(O) do{\
|
2013-03-20 18:43:57 +00:00
|
|
|
if (flag) \
|
|
|
|
O = r_ref(O, flag, p);\
|
2013-03-20 01:02:10 +00:00
|
|
|
} while (0)
|
|
|
|
|
2010-05-09 15:52:27 +00:00
|
|
|
switch (type) {
|
|
|
|
|
|
|
|
case TYPE_NULL:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TYPE_NONE:
|
2023-06-05 13:38:36 +00:00
|
|
|
retval = Py_None;
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TYPE_STOPITER:
|
2022-11-10 08:03:39 +00:00
|
|
|
retval = Py_NewRef(PyExc_StopIteration);
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TYPE_ELLIPSIS:
|
2023-06-05 13:38:36 +00:00
|
|
|
retval = Py_Ellipsis;
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TYPE_FALSE:
|
2023-06-05 13:38:36 +00:00
|
|
|
retval = Py_False;
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TYPE_TRUE:
|
2023-06-05 13:38:36 +00:00
|
|
|
retval = Py_True;
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TYPE_INT:
|
2011-07-02 15:42:47 +00:00
|
|
|
n = r_long(p);
|
2023-06-29 09:22:19 +00:00
|
|
|
if (n == -1 && PyErr_Occurred()) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
retval = PyLong_FromLong(n);
|
2013-03-20 01:02:10 +00:00
|
|
|
R_REF(retval);
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
|
2017-11-15 15:41:05 +00:00
|
|
|
case TYPE_INT64:
|
|
|
|
retval = r_long64(p);
|
|
|
|
R_REF(retval);
|
|
|
|
break;
|
|
|
|
|
2010-05-09 15:52:27 +00:00
|
|
|
case TYPE_LONG:
|
|
|
|
retval = r_PyLong(p);
|
2013-03-20 01:02:10 +00:00
|
|
|
R_REF(retval);
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TYPE_FLOAT:
|
|
|
|
{
|
2018-07-24 07:55:47 +00:00
|
|
|
double x = r_float_str(p);
|
|
|
|
if (x == -1.0 && PyErr_Occurred())
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
2018-07-24 07:55:47 +00:00
|
|
|
retval = PyFloat_FromDouble(x);
|
2013-03-20 01:02:10 +00:00
|
|
|
R_REF(retval);
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TYPE_BINARY_FLOAT:
|
|
|
|
{
|
2018-07-24 07:55:47 +00:00
|
|
|
double x = r_float_bin(p);
|
2013-10-13 13:41:59 +00:00
|
|
|
if (x == -1.0 && PyErr_Occurred())
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
retval = PyFloat_FromDouble(x);
|
2013-03-20 01:02:10 +00:00
|
|
|
R_REF(retval);
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TYPE_COMPLEX:
|
|
|
|
{
|
|
|
|
Py_complex c;
|
2018-07-24 07:55:47 +00:00
|
|
|
c.real = r_float_str(p);
|
2010-05-09 15:52:27 +00:00
|
|
|
if (c.real == -1.0 && PyErr_Occurred())
|
|
|
|
break;
|
2018-07-24 07:55:47 +00:00
|
|
|
c.imag = r_float_str(p);
|
2010-05-09 15:52:27 +00:00
|
|
|
if (c.imag == -1.0 && PyErr_Occurred())
|
|
|
|
break;
|
|
|
|
retval = PyComplex_FromCComplex(c);
|
2013-03-20 01:02:10 +00:00
|
|
|
R_REF(retval);
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TYPE_BINARY_COMPLEX:
|
|
|
|
{
|
|
|
|
Py_complex c;
|
2018-07-24 07:55:47 +00:00
|
|
|
c.real = r_float_bin(p);
|
2013-10-13 13:41:59 +00:00
|
|
|
if (c.real == -1.0 && PyErr_Occurred())
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
2018-07-24 07:55:47 +00:00
|
|
|
c.imag = r_float_bin(p);
|
2013-10-13 13:41:59 +00:00
|
|
|
if (c.imag == -1.0 && PyErr_Occurred())
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
retval = PyComplex_FromCComplex(c);
|
2013-03-20 01:02:10 +00:00
|
|
|
R_REF(retval);
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TYPE_STRING:
|
2013-10-12 20:25:39 +00:00
|
|
|
{
|
2015-12-25 18:01:53 +00:00
|
|
|
const char *ptr;
|
2013-10-12 20:25:39 +00:00
|
|
|
n = r_long(p);
|
|
|
|
if (n < 0 || n > SIZE32_MAX) {
|
2023-06-29 09:22:19 +00:00
|
|
|
if (!PyErr_Occurred()) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"bad marshal data (bytes object size out of range)");
|
|
|
|
}
|
2013-10-12 20:25:39 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
v = PyBytes_FromStringAndSize((char *)NULL, n);
|
2013-10-13 13:41:59 +00:00
|
|
|
if (v == NULL)
|
2013-10-12 20:25:39 +00:00
|
|
|
break;
|
|
|
|
ptr = r_string(n, p);
|
|
|
|
if (ptr == NULL) {
|
|
|
|
Py_DECREF(v);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
memcpy(PyBytes_AS_STRING(v), ptr, n);
|
|
|
|
retval = v;
|
|
|
|
R_REF(retval);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TYPE_ASCII_INTERNED:
|
|
|
|
is_interned = 1;
|
2024-06-27 09:58:44 +00:00
|
|
|
_Py_FALLTHROUGH;
|
2013-10-12 20:25:39 +00:00
|
|
|
case TYPE_ASCII:
|
2010-05-09 15:52:27 +00:00
|
|
|
n = r_long(p);
|
2013-02-13 10:08:15 +00:00
|
|
|
if (n < 0 || n > SIZE32_MAX) {
|
2023-06-29 09:22:19 +00:00
|
|
|
if (!PyErr_Occurred()) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"bad marshal data (string size out of range)");
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
2013-10-12 20:25:39 +00:00
|
|
|
goto _read_ascii;
|
|
|
|
|
|
|
|
case TYPE_SHORT_ASCII_INTERNED:
|
|
|
|
is_interned = 1;
|
2024-06-27 09:58:44 +00:00
|
|
|
_Py_FALLTHROUGH;
|
2013-10-12 20:25:39 +00:00
|
|
|
case TYPE_SHORT_ASCII:
|
|
|
|
n = r_byte(p);
|
|
|
|
if (n == EOF) {
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
2013-10-12 20:25:39 +00:00
|
|
|
_read_ascii:
|
|
|
|
{
|
2015-12-25 18:01:53 +00:00
|
|
|
const char *ptr;
|
2013-10-12 20:25:39 +00:00
|
|
|
ptr = r_string(n, p);
|
2013-10-13 13:41:59 +00:00
|
|
|
if (ptr == NULL)
|
2013-10-12 20:25:39 +00:00
|
|
|
break;
|
|
|
|
v = PyUnicode_FromKindAndData(PyUnicode_1BYTE_KIND, ptr, n);
|
2013-10-13 13:41:59 +00:00
|
|
|
if (v == NULL)
|
2013-10-12 20:25:39 +00:00
|
|
|
break;
|
2024-06-21 15:19:31 +00:00
|
|
|
if (is_interned) {
|
|
|
|
// marshal is meant to serialize .pyc files with code
|
|
|
|
// objects, and code-related strings are currently immortal.
|
|
|
|
PyInterpreterState *interp = _PyInterpreterState_GET();
|
|
|
|
_PyUnicode_InternImmortal(interp, &v);
|
|
|
|
}
|
2013-10-12 20:25:39 +00:00
|
|
|
retval = v;
|
|
|
|
R_REF(retval);
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-03-20 01:02:10 +00:00
|
|
|
case TYPE_INTERNED:
|
2013-10-12 20:25:39 +00:00
|
|
|
is_interned = 1;
|
2024-06-27 09:58:44 +00:00
|
|
|
_Py_FALLTHROUGH;
|
2013-10-12 20:25:39 +00:00
|
|
|
case TYPE_UNICODE:
|
2010-05-09 15:52:27 +00:00
|
|
|
{
|
2015-12-25 18:01:53 +00:00
|
|
|
const char *buffer;
|
2010-05-09 15:52:27 +00:00
|
|
|
|
|
|
|
n = r_long(p);
|
2013-02-13 10:08:15 +00:00
|
|
|
if (n < 0 || n > SIZE32_MAX) {
|
2023-06-29 09:22:19 +00:00
|
|
|
if (!PyErr_Occurred()) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"bad marshal data (string size out of range)");
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
2013-06-21 17:08:06 +00:00
|
|
|
if (n != 0) {
|
2013-10-12 20:25:39 +00:00
|
|
|
buffer = r_string(n, p);
|
2013-10-13 13:41:59 +00:00
|
|
|
if (buffer == NULL)
|
2013-06-21 17:08:06 +00:00
|
|
|
break;
|
|
|
|
v = PyUnicode_DecodeUTF8(buffer, n, "surrogatepass");
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
2013-06-21 17:08:06 +00:00
|
|
|
else {
|
|
|
|
v = PyUnicode_New(0, 0);
|
|
|
|
}
|
2013-10-13 13:41:59 +00:00
|
|
|
if (v == NULL)
|
2013-07-08 20:23:32 +00:00
|
|
|
break;
|
2024-06-21 15:19:31 +00:00
|
|
|
if (is_interned) {
|
|
|
|
// marshal is meant to serialize .pyc files with code
|
|
|
|
// objects, and code-related strings are currently immortal.
|
|
|
|
PyInterpreterState *interp = _PyInterpreterState_GET();
|
|
|
|
_PyUnicode_InternImmortal(interp, &v);
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
retval = v;
|
2013-03-20 01:02:10 +00:00
|
|
|
R_REF(retval);
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-10-12 20:25:39 +00:00
|
|
|
case TYPE_SMALL_TUPLE:
|
2023-06-29 09:22:19 +00:00
|
|
|
n = r_byte(p);
|
|
|
|
if (n == EOF) {
|
2013-10-31 16:07:08 +00:00
|
|
|
break;
|
2023-06-29 09:22:19 +00:00
|
|
|
}
|
2013-10-12 20:25:39 +00:00
|
|
|
goto _read_tuple;
|
2010-05-09 15:52:27 +00:00
|
|
|
case TYPE_TUPLE:
|
|
|
|
n = r_long(p);
|
2013-02-13 10:08:15 +00:00
|
|
|
if (n < 0 || n > SIZE32_MAX) {
|
2023-06-29 09:22:19 +00:00
|
|
|
if (!PyErr_Occurred()) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"bad marshal data (tuple size out of range)");
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
2013-10-12 20:25:39 +00:00
|
|
|
_read_tuple:
|
2013-02-13 10:08:15 +00:00
|
|
|
v = PyTuple_New(n);
|
2013-03-20 01:02:10 +00:00
|
|
|
R_REF(v);
|
2013-10-13 13:41:59 +00:00
|
|
|
if (v == NULL)
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
2013-10-31 16:14:52 +00:00
|
|
|
|
2010-05-09 15:52:27 +00:00
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
v2 = r_object(p);
|
|
|
|
if ( v2 == NULL ) {
|
|
|
|
if (!PyErr_Occurred())
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"NULL object in marshal data for tuple");
|
2022-11-23 13:57:50 +00:00
|
|
|
Py_SETREF(v, NULL);
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
2013-02-13 10:08:15 +00:00
|
|
|
PyTuple_SET_ITEM(v, i, v2);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
retval = v;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TYPE_LIST:
|
|
|
|
n = r_long(p);
|
2013-02-13 10:08:15 +00:00
|
|
|
if (n < 0 || n > SIZE32_MAX) {
|
2023-06-29 09:22:19 +00:00
|
|
|
if (!PyErr_Occurred()) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"bad marshal data (list size out of range)");
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
2013-02-13 10:08:15 +00:00
|
|
|
v = PyList_New(n);
|
2013-03-20 01:02:10 +00:00
|
|
|
R_REF(v);
|
2013-10-13 13:41:59 +00:00
|
|
|
if (v == NULL)
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
v2 = r_object(p);
|
|
|
|
if ( v2 == NULL ) {
|
|
|
|
if (!PyErr_Occurred())
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"NULL object in marshal data for list");
|
2022-11-23 13:57:50 +00:00
|
|
|
Py_SETREF(v, NULL);
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
2013-02-13 10:08:15 +00:00
|
|
|
PyList_SET_ITEM(v, i, v2);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
retval = v;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TYPE_DICT:
|
|
|
|
v = PyDict_New();
|
2013-03-20 01:02:10 +00:00
|
|
|
R_REF(v);
|
2013-10-13 13:41:59 +00:00
|
|
|
if (v == NULL)
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
for (;;) {
|
|
|
|
PyObject *key, *val;
|
|
|
|
key = r_object(p);
|
|
|
|
if (key == NULL)
|
|
|
|
break;
|
|
|
|
val = r_object(p);
|
2013-10-31 16:14:52 +00:00
|
|
|
if (val == NULL) {
|
|
|
|
Py_DECREF(key);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (PyDict_SetItem(v, key, val) < 0) {
|
|
|
|
Py_DECREF(key);
|
|
|
|
Py_DECREF(val);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_DECREF(key);
|
2013-10-31 16:14:52 +00:00
|
|
|
Py_DECREF(val);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
if (PyErr_Occurred()) {
|
2022-11-23 13:57:50 +00:00
|
|
|
Py_SETREF(v, NULL);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
retval = v;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TYPE_SET:
|
|
|
|
case TYPE_FROZENSET:
|
|
|
|
n = r_long(p);
|
2013-02-13 10:08:15 +00:00
|
|
|
if (n < 0 || n > SIZE32_MAX) {
|
2023-06-29 09:22:19 +00:00
|
|
|
if (!PyErr_Occurred()) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"bad marshal data (set size out of range)");
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
|
|
|
}
|
2013-10-31 16:14:52 +00:00
|
|
|
|
2016-01-23 13:15:48 +00:00
|
|
|
if (n == 0 && type == TYPE_FROZENSET) {
|
|
|
|
/* call frozenset() to get the empty frozenset singleton */
|
2021-10-11 22:42:23 +00:00
|
|
|
v = _PyObject_CallNoArgs((PyObject*)&PyFrozenSet_Type);
|
2016-01-23 13:15:48 +00:00
|
|
|
if (v == NULL)
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
2016-01-23 13:15:48 +00:00
|
|
|
R_REF(v);
|
|
|
|
retval = v;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
v = (type == TYPE_SET) ? PySet_New(NULL) : PyFrozenSet_New(NULL);
|
|
|
|
if (type == TYPE_SET) {
|
|
|
|
R_REF(v);
|
|
|
|
} else {
|
|
|
|
/* must use delayed registration of frozensets because they must
|
|
|
|
* be init with a refcount of 1
|
|
|
|
*/
|
|
|
|
idx = r_ref_reserve(flag, p);
|
|
|
|
if (idx < 0)
|
|
|
|
Py_CLEAR(v); /* signal error */
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
2016-01-23 13:15:48 +00:00
|
|
|
if (v == NULL)
|
2010-05-09 15:52:27 +00:00
|
|
|
break;
|
2016-01-23 13:15:48 +00:00
|
|
|
|
|
|
|
for (i = 0; i < n; i++) {
|
|
|
|
v2 = r_object(p);
|
|
|
|
if ( v2 == NULL ) {
|
|
|
|
if (!PyErr_Occurred())
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"NULL object in marshal data for set");
|
2022-11-23 13:57:50 +00:00
|
|
|
Py_SETREF(v, NULL);
|
2016-01-23 13:15:48 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (PySet_Add(v, v2) == -1) {
|
|
|
|
Py_DECREF(v);
|
|
|
|
Py_DECREF(v2);
|
|
|
|
v = NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
Py_DECREF(v2);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
2016-01-23 13:15:48 +00:00
|
|
|
if (type != TYPE_SET)
|
|
|
|
v = r_ref_insert(v, idx, flag, p);
|
|
|
|
retval = v;
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TYPE_CODE:
|
|
|
|
{
|
|
|
|
int argcount;
|
2019-04-29 12:36:57 +00:00
|
|
|
int posonlyargcount;
|
2010-05-09 15:52:27 +00:00
|
|
|
int kwonlyargcount;
|
|
|
|
int stacksize;
|
|
|
|
int flags;
|
|
|
|
PyObject *code = NULL;
|
|
|
|
PyObject *consts = NULL;
|
|
|
|
PyObject *names = NULL;
|
2021-06-07 18:22:26 +00:00
|
|
|
PyObject *localsplusnames = NULL;
|
2021-06-21 20:53:04 +00:00
|
|
|
PyObject *localspluskinds = NULL;
|
2010-05-09 15:52:27 +00:00
|
|
|
PyObject *filename = NULL;
|
|
|
|
PyObject *name = NULL;
|
2021-07-07 11:21:51 +00:00
|
|
|
PyObject *qualname = NULL;
|
2010-05-09 15:52:27 +00:00
|
|
|
int firstlineno;
|
2022-04-21 15:10:37 +00:00
|
|
|
PyObject* linetable = NULL;
|
2021-05-07 14:19:19 +00:00
|
|
|
PyObject *exceptiontable = NULL;
|
2013-04-13 20:41:09 +00:00
|
|
|
|
2024-01-16 16:05:15 +00:00
|
|
|
if (!p->allow_code) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"unmarshalling code objects is disallowed");
|
|
|
|
break;
|
|
|
|
}
|
2013-03-20 18:43:57 +00:00
|
|
|
idx = r_ref_reserve(flag, p);
|
2013-10-13 13:41:59 +00:00
|
|
|
if (idx < 0)
|
2013-03-20 01:02:10 +00:00
|
|
|
break;
|
2010-05-09 15:52:27 +00:00
|
|
|
|
|
|
|
v = NULL;
|
|
|
|
|
|
|
|
/* XXX ignore long->int overflows for now */
|
|
|
|
argcount = (int)r_long(p);
|
2023-06-29 09:22:19 +00:00
|
|
|
if (argcount == -1 && PyErr_Occurred())
|
2011-07-02 15:42:47 +00:00
|
|
|
goto code_error;
|
2019-04-29 12:36:57 +00:00
|
|
|
posonlyargcount = (int)r_long(p);
|
2023-06-29 09:22:19 +00:00
|
|
|
if (posonlyargcount == -1 && PyErr_Occurred()) {
|
2019-04-29 12:36:57 +00:00
|
|
|
goto code_error;
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
kwonlyargcount = (int)r_long(p);
|
2023-06-29 09:22:19 +00:00
|
|
|
if (kwonlyargcount == -1 && PyErr_Occurred())
|
2011-07-02 15:42:47 +00:00
|
|
|
goto code_error;
|
2010-05-09 15:52:27 +00:00
|
|
|
stacksize = (int)r_long(p);
|
2023-06-29 09:22:19 +00:00
|
|
|
if (stacksize == -1 && PyErr_Occurred())
|
2011-07-02 15:42:47 +00:00
|
|
|
goto code_error;
|
2010-05-09 15:52:27 +00:00
|
|
|
flags = (int)r_long(p);
|
2023-06-29 09:22:19 +00:00
|
|
|
if (flags == -1 && PyErr_Occurred())
|
2011-07-02 15:42:47 +00:00
|
|
|
goto code_error;
|
2010-05-09 15:52:27 +00:00
|
|
|
code = r_object(p);
|
|
|
|
if (code == NULL)
|
|
|
|
goto code_error;
|
|
|
|
consts = r_object(p);
|
|
|
|
if (consts == NULL)
|
|
|
|
goto code_error;
|
|
|
|
names = r_object(p);
|
|
|
|
if (names == NULL)
|
|
|
|
goto code_error;
|
2021-06-07 18:22:26 +00:00
|
|
|
localsplusnames = r_object(p);
|
|
|
|
if (localsplusnames == NULL)
|
2010-05-09 15:52:27 +00:00
|
|
|
goto code_error;
|
2021-06-21 20:53:04 +00:00
|
|
|
localspluskinds = r_object(p);
|
|
|
|
if (localspluskinds == NULL)
|
|
|
|
goto code_error;
|
2010-05-09 15:52:27 +00:00
|
|
|
filename = r_object(p);
|
|
|
|
if (filename == NULL)
|
|
|
|
goto code_error;
|
|
|
|
name = r_object(p);
|
|
|
|
if (name == NULL)
|
|
|
|
goto code_error;
|
2021-07-07 11:21:51 +00:00
|
|
|
qualname = r_object(p);
|
|
|
|
if (qualname == NULL)
|
|
|
|
goto code_error;
|
2010-05-09 15:52:27 +00:00
|
|
|
firstlineno = (int)r_long(p);
|
2013-10-13 15:19:56 +00:00
|
|
|
if (firstlineno == -1 && PyErr_Occurred())
|
|
|
|
break;
|
2020-11-12 09:43:29 +00:00
|
|
|
linetable = r_object(p);
|
|
|
|
if (linetable == NULL)
|
2010-05-09 15:52:27 +00:00
|
|
|
goto code_error;
|
2021-05-07 14:19:19 +00:00
|
|
|
exceptiontable = r_object(p);
|
|
|
|
if (exceptiontable == NULL)
|
|
|
|
goto code_error;
|
|
|
|
|
2021-05-27 15:54:34 +00:00
|
|
|
struct _PyCodeConstructor con = {
|
|
|
|
.filename = filename,
|
|
|
|
.name = name,
|
2021-07-07 11:21:51 +00:00
|
|
|
.qualname = qualname,
|
2021-05-27 15:54:34 +00:00
|
|
|
.flags = flags,
|
|
|
|
|
|
|
|
.code = code,
|
|
|
|
.firstlineno = firstlineno,
|
|
|
|
.linetable = linetable,
|
|
|
|
|
|
|
|
.consts = consts,
|
|
|
|
.names = names,
|
|
|
|
|
2021-06-07 18:22:26 +00:00
|
|
|
.localsplusnames = localsplusnames,
|
|
|
|
.localspluskinds = localspluskinds,
|
2021-05-27 15:54:34 +00:00
|
|
|
|
|
|
|
.argcount = argcount,
|
|
|
|
.posonlyargcount = posonlyargcount,
|
|
|
|
.kwonlyargcount = kwonlyargcount,
|
|
|
|
|
|
|
|
.stacksize = stacksize,
|
|
|
|
|
|
|
|
.exceptiontable = exceptiontable,
|
|
|
|
};
|
2021-06-07 18:22:26 +00:00
|
|
|
|
2021-05-27 15:54:34 +00:00
|
|
|
if (_PyCode_Validate(&con) < 0) {
|
|
|
|
goto code_error;
|
|
|
|
}
|
2021-06-07 18:22:26 +00:00
|
|
|
|
2021-05-27 15:54:34 +00:00
|
|
|
v = (PyObject *)_PyCode_New(&con);
|
|
|
|
if (v == NULL) {
|
|
|
|
goto code_error;
|
|
|
|
}
|
2021-06-07 18:22:26 +00:00
|
|
|
|
2013-03-20 01:02:10 +00:00
|
|
|
v = r_ref_insert(v, idx, flag, p);
|
2010-05-09 15:52:27 +00:00
|
|
|
|
|
|
|
code_error:
|
2023-06-29 09:22:19 +00:00
|
|
|
if (v == NULL && !PyErr_Occurred()) {
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"NULL object in marshal data for code object");
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_XDECREF(code);
|
|
|
|
Py_XDECREF(consts);
|
|
|
|
Py_XDECREF(names);
|
2021-06-07 18:22:26 +00:00
|
|
|
Py_XDECREF(localsplusnames);
|
2021-06-21 20:53:04 +00:00
|
|
|
Py_XDECREF(localspluskinds);
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_XDECREF(filename);
|
|
|
|
Py_XDECREF(name);
|
2021-07-07 11:21:51 +00:00
|
|
|
Py_XDECREF(qualname);
|
2020-11-12 09:43:29 +00:00
|
|
|
Py_XDECREF(linetable);
|
2021-05-07 14:19:19 +00:00
|
|
|
Py_XDECREF(exceptiontable);
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
retval = v;
|
|
|
|
break;
|
|
|
|
|
2013-03-20 01:02:10 +00:00
|
|
|
case TYPE_REF:
|
|
|
|
n = r_long(p);
|
|
|
|
if (n < 0 || n >= PyList_GET_SIZE(p->refs)) {
|
2023-06-29 09:22:19 +00:00
|
|
|
if (!PyErr_Occurred()) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"bad marshal data (invalid reference)");
|
|
|
|
}
|
2013-03-20 01:02:10 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
v = PyList_GET_ITEM(p->refs, n);
|
|
|
|
if (v == Py_None) {
|
|
|
|
PyErr_SetString(PyExc_ValueError, "bad marshal data (invalid reference)");
|
|
|
|
break;
|
|
|
|
}
|
2022-11-10 08:03:39 +00:00
|
|
|
retval = Py_NewRef(v);
|
2013-03-20 01:02:10 +00:00
|
|
|
break;
|
|
|
|
|
2010-05-09 15:52:27 +00:00
|
|
|
default:
|
|
|
|
/* Bogus data got written, which isn't ideal.
|
|
|
|
This will let you keep working and recover. */
|
|
|
|
PyErr_SetString(PyExc_ValueError, "bad marshal data (unknown type code)");
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
p->depth--;
|
|
|
|
return retval;
|
1991-06-04 19:42:30 +00:00
|
|
|
}
|
|
|
|
|
2004-06-13 20:31:49 +00:00
|
|
|
static PyObject *
|
2004-03-26 15:09:27 +00:00
|
|
|
read_object(RFILE *p)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyObject *v;
|
|
|
|
if (PyErr_Occurred()) {
|
|
|
|
fprintf(stderr, "XXX readobject called with exception set\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
2021-06-30 16:21:37 +00:00
|
|
|
if (p->ptr && p->end) {
|
|
|
|
if (PySys_Audit("marshal.loads", "y#", p->ptr, (Py_ssize_t)(p->end - p->ptr)) < 0) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
} else if (p->fp || p->readable) {
|
|
|
|
if (PySys_Audit("marshal.load", NULL) < 0) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
v = r_object(p);
|
|
|
|
if (v == NULL && !PyErr_Occurred())
|
|
|
|
PyErr_SetString(PyExc_TypeError, "NULL object in marshal data for object");
|
|
|
|
return v;
|
2004-03-26 15:09:27 +00:00
|
|
|
}
|
|
|
|
|
2001-10-19 01:46:21 +00:00
|
|
|
int
|
|
|
|
PyMarshal_ReadShortFromFile(FILE *fp)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
RFILE rf;
|
2013-10-12 20:25:39 +00:00
|
|
|
int res;
|
2010-05-09 15:52:27 +00:00
|
|
|
assert(fp);
|
2011-07-02 15:42:47 +00:00
|
|
|
rf.readable = NULL;
|
2010-05-09 15:52:27 +00:00
|
|
|
rf.fp = fp;
|
|
|
|
rf.end = rf.ptr = NULL;
|
2013-10-12 20:25:39 +00:00
|
|
|
rf.buf = NULL;
|
|
|
|
res = r_short(&rf);
|
|
|
|
if (rf.buf != NULL)
|
2020-12-01 08:56:42 +00:00
|
|
|
PyMem_Free(rf.buf);
|
2013-10-12 20:25:39 +00:00
|
|
|
return res;
|
2001-10-19 01:46:21 +00:00
|
|
|
}
|
|
|
|
|
1993-01-21 16:07:51 +00:00
|
|
|
long
|
2000-07-22 18:47:25 +00:00
|
|
|
PyMarshal_ReadLongFromFile(FILE *fp)
|
1993-01-21 16:07:51 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
RFILE rf;
|
2013-10-12 20:25:39 +00:00
|
|
|
long res;
|
2010-05-09 15:52:27 +00:00
|
|
|
rf.fp = fp;
|
2011-07-02 15:42:47 +00:00
|
|
|
rf.readable = NULL;
|
2010-05-09 15:52:27 +00:00
|
|
|
rf.ptr = rf.end = NULL;
|
2013-10-12 20:25:39 +00:00
|
|
|
rf.buf = NULL;
|
|
|
|
res = r_long(&rf);
|
|
|
|
if (rf.buf != NULL)
|
2020-12-01 08:56:42 +00:00
|
|
|
PyMem_Free(rf.buf);
|
2013-10-12 20:25:39 +00:00
|
|
|
return res;
|
1993-01-21 16:07:51 +00:00
|
|
|
}
|
|
|
|
|
2015-02-21 16:44:05 +00:00
|
|
|
/* Return size of file in bytes; < 0 if unknown or INT_MAX if too big */
|
2001-01-18 04:39:16 +00:00
|
|
|
static off_t
|
|
|
|
getfilesize(FILE *fp)
|
|
|
|
{
|
2015-02-21 16:44:05 +00:00
|
|
|
struct _Py_stat_struct st;
|
2015-03-30 08:09:31 +00:00
|
|
|
if (_Py_fstat_noraise(fileno(fp), &st) != 0)
|
2010-05-09 15:52:27 +00:00
|
|
|
return -1;
|
2015-02-21 16:44:05 +00:00
|
|
|
#if SIZEOF_OFF_T == 4
|
|
|
|
else if (st.st_size >= INT_MAX)
|
|
|
|
return (off_t)INT_MAX;
|
|
|
|
#endif
|
2010-05-09 15:52:27 +00:00
|
|
|
else
|
2015-02-21 16:44:05 +00:00
|
|
|
return (off_t)st.st_size;
|
2001-01-18 04:39:16 +00:00
|
|
|
}
|
2001-01-28 00:27:39 +00:00
|
|
|
|
2001-01-18 04:39:16 +00:00
|
|
|
/* If we can get the size of the file up-front, and it's reasonably small,
|
|
|
|
* read it in one gulp and delegate to ...FromString() instead. Much quicker
|
|
|
|
* than reading a byte at a time from file; speeds .pyc imports.
|
2001-01-28 00:27:39 +00:00
|
|
|
* CAUTION: since this may read the entire remainder of the file, don't
|
|
|
|
* call it unless you know you're done with the file.
|
2001-01-18 04:39:16 +00:00
|
|
|
*/
|
1997-04-29 20:08:16 +00:00
|
|
|
PyObject *
|
2001-01-28 00:27:39 +00:00
|
|
|
PyMarshal_ReadLastObjectFromFile(FILE *fp)
|
1993-01-21 16:07:51 +00:00
|
|
|
{
|
2010-04-21 22:56:22 +00:00
|
|
|
/* REASONABLE_FILE_LIMIT is by defn something big enough for Tkinter.pyc. */
|
2001-01-18 04:39:16 +00:00
|
|
|
#define REASONABLE_FILE_LIMIT (1L << 18)
|
2010-05-09 15:52:27 +00:00
|
|
|
off_t filesize;
|
|
|
|
filesize = getfilesize(fp);
|
|
|
|
if (filesize > 0 && filesize <= REASONABLE_FILE_LIMIT) {
|
2020-12-01 08:56:42 +00:00
|
|
|
char* pBuf = (char *)PyMem_Malloc(filesize);
|
2010-05-09 15:52:27 +00:00
|
|
|
if (pBuf != NULL) {
|
2013-02-13 10:08:15 +00:00
|
|
|
size_t n = fread(pBuf, 1, (size_t)filesize, fp);
|
|
|
|
PyObject* v = PyMarshal_ReadObjectFromString(pBuf, n);
|
2020-12-01 08:56:42 +00:00
|
|
|
PyMem_Free(pBuf);
|
2010-05-09 15:52:27 +00:00
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
/* We don't have fstat, or we do but the file is larger than
|
|
|
|
* REASONABLE_FILE_LIMIT or malloc failed -- read a byte at a time.
|
|
|
|
*/
|
|
|
|
return PyMarshal_ReadObjectFromFile(fp);
|
2001-01-28 00:27:39 +00:00
|
|
|
|
2001-01-18 04:39:16 +00:00
|
|
|
#undef REASONABLE_FILE_LIMIT
|
1993-01-21 16:07:51 +00:00
|
|
|
}
|
|
|
|
|
2001-01-28 00:27:39 +00:00
|
|
|
PyObject *
|
|
|
|
PyMarshal_ReadObjectFromFile(FILE *fp)
|
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
RFILE rf;
|
|
|
|
PyObject *result;
|
2024-01-16 16:05:15 +00:00
|
|
|
rf.allow_code = 1;
|
2010-05-09 15:52:27 +00:00
|
|
|
rf.fp = fp;
|
2011-07-02 15:42:47 +00:00
|
|
|
rf.readable = NULL;
|
2010-05-09 15:52:27 +00:00
|
|
|
rf.depth = 0;
|
|
|
|
rf.ptr = rf.end = NULL;
|
2013-10-12 20:25:39 +00:00
|
|
|
rf.buf = NULL;
|
2013-03-20 01:02:10 +00:00
|
|
|
rf.refs = PyList_New(0);
|
|
|
|
if (rf.refs == NULL)
|
|
|
|
return NULL;
|
2021-06-30 16:21:37 +00:00
|
|
|
result = read_object(&rf);
|
2013-03-20 01:02:10 +00:00
|
|
|
Py_DECREF(rf.refs);
|
2013-10-12 20:25:39 +00:00
|
|
|
if (rf.buf != NULL)
|
2020-12-01 08:56:42 +00:00
|
|
|
PyMem_Free(rf.buf);
|
2010-05-09 15:52:27 +00:00
|
|
|
return result;
|
2001-01-28 00:27:39 +00:00
|
|
|
}
|
|
|
|
|
1997-04-29 20:08:16 +00:00
|
|
|
PyObject *
|
2013-10-19 18:03:34 +00:00
|
|
|
PyMarshal_ReadObjectFromString(const char *str, Py_ssize_t len)
|
1993-04-01 20:59:32 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
RFILE rf;
|
|
|
|
PyObject *result;
|
2024-01-16 16:05:15 +00:00
|
|
|
rf.allow_code = 1;
|
2010-05-09 15:52:27 +00:00
|
|
|
rf.fp = NULL;
|
2011-07-02 15:42:47 +00:00
|
|
|
rf.readable = NULL;
|
2020-03-31 20:23:21 +00:00
|
|
|
rf.ptr = str;
|
|
|
|
rf.end = str + len;
|
2013-10-12 20:25:39 +00:00
|
|
|
rf.buf = NULL;
|
2010-05-09 15:52:27 +00:00
|
|
|
rf.depth = 0;
|
2013-03-20 01:02:10 +00:00
|
|
|
rf.refs = PyList_New(0);
|
|
|
|
if (rf.refs == NULL)
|
|
|
|
return NULL;
|
2021-06-30 16:21:37 +00:00
|
|
|
result = read_object(&rf);
|
2013-03-20 01:02:10 +00:00
|
|
|
Py_DECREF(rf.refs);
|
2013-10-12 20:25:39 +00:00
|
|
|
if (rf.buf != NULL)
|
2020-12-01 08:56:42 +00:00
|
|
|
PyMem_Free(rf.buf);
|
2010-05-09 15:52:27 +00:00
|
|
|
return result;
|
1993-04-01 20:59:32 +00:00
|
|
|
}
|
|
|
|
|
2024-01-16 16:05:15 +00:00
|
|
|
static PyObject *
|
|
|
|
_PyMarshal_WriteObjectToString(PyObject *x, int version, int allow_code)
|
1996-08-19 22:07:17 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
WFILE wf;
|
|
|
|
|
2021-06-30 16:21:37 +00:00
|
|
|
if (PySys_Audit("marshal.dumps", "Oi", x, version) < 0) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-02-11 13:53:31 +00:00
|
|
|
memset(&wf, 0, sizeof(wf));
|
2010-05-09 15:52:27 +00:00
|
|
|
wf.str = PyBytes_FromStringAndSize((char *)NULL, 50);
|
|
|
|
if (wf.str == NULL)
|
|
|
|
return NULL;
|
2020-03-31 20:23:21 +00:00
|
|
|
wf.ptr = wf.buf = PyBytes_AS_STRING(wf.str);
|
|
|
|
wf.end = wf.ptr + PyBytes_GET_SIZE(wf.str);
|
2010-05-09 15:52:27 +00:00
|
|
|
wf.error = WFERR_OK;
|
|
|
|
wf.version = version;
|
2024-01-16 16:05:15 +00:00
|
|
|
wf.allow_code = allow_code;
|
2015-02-11 13:53:31 +00:00
|
|
|
if (w_init_refs(&wf, version)) {
|
|
|
|
Py_DECREF(wf.str);
|
|
|
|
return NULL;
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
w_object(x, &wf);
|
2015-02-11 13:53:31 +00:00
|
|
|
w_clear_refs(&wf);
|
2010-05-09 15:52:27 +00:00
|
|
|
if (wf.str != NULL) {
|
2020-03-31 20:23:21 +00:00
|
|
|
const char *base = PyBytes_AS_STRING(wf.str);
|
2010-05-09 15:52:27 +00:00
|
|
|
if (_PyBytes_Resize(&wf.str, (Py_ssize_t)(wf.ptr - base)) < 0)
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (wf.error != WFERR_OK) {
|
|
|
|
Py_XDECREF(wf.str);
|
2024-01-16 16:05:15 +00:00
|
|
|
switch (wf.error) {
|
|
|
|
case WFERR_NOMEMORY:
|
2010-05-09 15:52:27 +00:00
|
|
|
PyErr_NoMemory();
|
2024-01-16 16:05:15 +00:00
|
|
|
break;
|
|
|
|
case WFERR_NESTEDTOODEEP:
|
2010-05-09 15:52:27 +00:00
|
|
|
PyErr_SetString(PyExc_ValueError,
|
2024-01-16 16:05:15 +00:00
|
|
|
"object too deeply nested to marshal");
|
|
|
|
break;
|
|
|
|
case WFERR_CODE_NOT_ALLOWED:
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"marshalling code objects is disallowed");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case WFERR_UNMARSHALLABLE:
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"unmarshallable object");
|
|
|
|
break;
|
|
|
|
}
|
2010-05-09 15:52:27 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
2012-03-02 17:22:23 +00:00
|
|
|
return wf.str;
|
1996-08-19 22:07:17 +00:00
|
|
|
}
|
|
|
|
|
2024-01-16 16:05:15 +00:00
|
|
|
PyObject *
|
|
|
|
PyMarshal_WriteObjectToString(PyObject *x, int version)
|
|
|
|
{
|
|
|
|
return _PyMarshal_WriteObjectToString(x, version, 1);
|
|
|
|
}
|
|
|
|
|
1991-06-07 13:58:22 +00:00
|
|
|
/* And an interface for Python programs... */
|
2017-03-12 07:20:15 +00:00
|
|
|
/*[clinic input]
|
|
|
|
marshal.dump
|
|
|
|
|
|
|
|
value: object
|
|
|
|
Must be a supported type.
|
|
|
|
file: object
|
|
|
|
Must be a writeable binary file.
|
|
|
|
version: int(c_default="Py_MARSHAL_VERSION") = version
|
|
|
|
Indicates the data format that dump should use.
|
|
|
|
/
|
2024-01-16 16:05:15 +00:00
|
|
|
*
|
|
|
|
allow_code: bool = True
|
|
|
|
Allow to write code objects.
|
2017-03-12 07:20:15 +00:00
|
|
|
|
|
|
|
Write the value on the open file.
|
|
|
|
|
|
|
|
If the value has (or contains an object that has) an unsupported type, a
|
|
|
|
ValueError exception is raised - but garbage data will also be written
|
|
|
|
to the file. The object will not be properly read back by load().
|
|
|
|
[clinic start generated code]*/
|
1991-06-04 19:42:30 +00:00
|
|
|
|
1997-04-29 20:08:16 +00:00
|
|
|
static PyObject *
|
2017-03-12 07:20:15 +00:00
|
|
|
marshal_dump_impl(PyObject *module, PyObject *value, PyObject *file,
|
2024-01-16 16:05:15 +00:00
|
|
|
int version, int allow_code)
|
|
|
|
/*[clinic end generated code: output=429e5fd61c2196b9 input=041f7f6669b0aafb]*/
|
1991-06-04 19:42:30 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
/* XXX Quick hack -- need to do this differently */
|
|
|
|
PyObject *s;
|
|
|
|
PyObject *res;
|
2011-10-09 08:38:36 +00:00
|
|
|
|
2024-01-16 16:05:15 +00:00
|
|
|
s = _PyMarshal_WriteObjectToString(value, version, allow_code);
|
2010-05-09 15:52:27 +00:00
|
|
|
if (s == NULL)
|
|
|
|
return NULL;
|
2023-06-26 06:08:12 +00:00
|
|
|
res = PyObject_CallMethodOneArg(file, &_Py_ID(write), s);
|
2010-05-09 15:52:27 +00:00
|
|
|
Py_DECREF(s);
|
|
|
|
return res;
|
1991-06-04 19:42:30 +00:00
|
|
|
}
|
|
|
|
|
2017-03-12 07:20:15 +00:00
|
|
|
/*[clinic input]
|
|
|
|
marshal.load
|
|
|
|
|
|
|
|
file: object
|
|
|
|
Must be readable binary file.
|
|
|
|
/
|
2024-01-16 16:05:15 +00:00
|
|
|
*
|
|
|
|
allow_code: bool = True
|
|
|
|
Allow to load code objects.
|
2017-03-12 07:20:15 +00:00
|
|
|
|
|
|
|
Read one value from the open file and return it.
|
|
|
|
|
|
|
|
If no valid value is read (e.g. because the data has a different Python
|
|
|
|
version's incompatible marshal format), raise EOFError, ValueError or
|
|
|
|
TypeError.
|
|
|
|
|
|
|
|
Note: If an object containing an unsupported type was marshalled with
|
|
|
|
dump(), load() will substitute None for the unmarshallable type.
|
|
|
|
[clinic start generated code]*/
|
2009-05-13 12:27:21 +00:00
|
|
|
|
1997-04-29 20:08:16 +00:00
|
|
|
static PyObject *
|
2024-01-16 16:05:15 +00:00
|
|
|
marshal_load_impl(PyObject *module, PyObject *file, int allow_code)
|
|
|
|
/*[clinic end generated code: output=0c1aaf3546ae3ed3 input=2dca7b570653b82f]*/
|
1991-06-04 19:42:30 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
PyObject *data, *result;
|
|
|
|
RFILE rf;
|
2011-07-02 15:42:47 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Make a call to the read method, but read zero bytes.
|
|
|
|
* This is to ensure that the object passed in at least
|
|
|
|
* has a read method which returns bytes.
|
2013-03-20 01:02:10 +00:00
|
|
|
* This can be removed if we guarantee good error handling
|
|
|
|
* for r_string()
|
2011-07-02 15:42:47 +00:00
|
|
|
*/
|
2022-02-08 20:39:07 +00:00
|
|
|
data = _PyObject_CallMethod(file, &_Py_ID(read), "i", 0);
|
2010-05-09 15:52:27 +00:00
|
|
|
if (data == NULL)
|
|
|
|
return NULL;
|
2011-07-02 15:42:47 +00:00
|
|
|
if (!PyBytes_Check(data)) {
|
2010-05-09 15:52:27 +00:00
|
|
|
PyErr_Format(PyExc_TypeError,
|
2017-03-12 07:20:15 +00:00
|
|
|
"file.read() returned not bytes but %.100s",
|
2020-02-07 01:24:48 +00:00
|
|
|
Py_TYPE(data)->tp_name);
|
2011-07-02 15:42:47 +00:00
|
|
|
result = NULL;
|
|
|
|
}
|
|
|
|
else {
|
2024-01-16 16:05:15 +00:00
|
|
|
rf.allow_code = allow_code;
|
2011-07-02 15:42:47 +00:00
|
|
|
rf.depth = 0;
|
|
|
|
rf.fp = NULL;
|
2017-03-12 07:20:15 +00:00
|
|
|
rf.readable = file;
|
2013-10-12 20:25:39 +00:00
|
|
|
rf.ptr = rf.end = NULL;
|
|
|
|
rf.buf = NULL;
|
2013-03-20 01:02:10 +00:00
|
|
|
if ((rf.refs = PyList_New(0)) != NULL) {
|
|
|
|
result = read_object(&rf);
|
|
|
|
Py_DECREF(rf.refs);
|
2013-10-12 20:25:39 +00:00
|
|
|
if (rf.buf != NULL)
|
2020-12-01 08:56:42 +00:00
|
|
|
PyMem_Free(rf.buf);
|
2013-03-20 01:02:10 +00:00
|
|
|
} else
|
|
|
|
result = NULL;
|
2010-05-09 15:52:27 +00:00
|
|
|
}
|
|
|
|
Py_DECREF(data);
|
|
|
|
return result;
|
1993-01-21 16:07:51 +00:00
|
|
|
}
|
|
|
|
|
2017-03-12 07:20:15 +00:00
|
|
|
/*[clinic input]
|
|
|
|
marshal.dumps
|
|
|
|
|
|
|
|
value: object
|
|
|
|
Must be a supported type.
|
|
|
|
version: int(c_default="Py_MARSHAL_VERSION") = version
|
|
|
|
Indicates the data format that dumps should use.
|
|
|
|
/
|
2024-01-16 16:05:15 +00:00
|
|
|
*
|
|
|
|
allow_code: bool = True
|
|
|
|
Allow to write code objects.
|
2009-05-13 12:27:21 +00:00
|
|
|
|
2017-03-12 07:20:15 +00:00
|
|
|
Return the bytes object that would be written to a file by dump(value, file).
|
|
|
|
|
|
|
|
Raise a ValueError exception if value has (or contains an object that has) an
|
|
|
|
unsupported type.
|
|
|
|
[clinic start generated code]*/
|
2009-05-13 12:27:21 +00:00
|
|
|
|
1997-04-29 20:08:16 +00:00
|
|
|
static PyObject *
|
2024-01-16 16:05:15 +00:00
|
|
|
marshal_dumps_impl(PyObject *module, PyObject *value, int version,
|
|
|
|
int allow_code)
|
|
|
|
/*[clinic end generated code: output=115f90da518d1d49 input=167eaecceb63f0a8]*/
|
1993-01-21 16:07:51 +00:00
|
|
|
{
|
2024-01-16 16:05:15 +00:00
|
|
|
return _PyMarshal_WriteObjectToString(value, version, allow_code);
|
1993-01-21 16:07:51 +00:00
|
|
|
}
|
|
|
|
|
2017-03-12 07:20:15 +00:00
|
|
|
/*[clinic input]
|
|
|
|
marshal.loads
|
|
|
|
|
|
|
|
bytes: Py_buffer
|
|
|
|
/
|
2024-01-16 16:05:15 +00:00
|
|
|
*
|
|
|
|
allow_code: bool = True
|
|
|
|
Allow to load code objects.
|
2017-03-12 07:20:15 +00:00
|
|
|
|
|
|
|
Convert the bytes-like object to a value.
|
2009-05-13 12:27:21 +00:00
|
|
|
|
2017-03-12 07:20:15 +00:00
|
|
|
If no valid value is found, raise EOFError, ValueError or TypeError. Extra
|
|
|
|
bytes in the input are ignored.
|
|
|
|
[clinic start generated code]*/
|
2009-05-13 12:27:21 +00:00
|
|
|
|
1997-04-29 20:08:16 +00:00
|
|
|
static PyObject *
|
2024-01-16 16:05:15 +00:00
|
|
|
marshal_loads_impl(PyObject *module, Py_buffer *bytes, int allow_code)
|
|
|
|
/*[clinic end generated code: output=62c0c538d3edc31f input=14de68965b45aaa7]*/
|
1993-01-21 16:07:51 +00:00
|
|
|
{
|
2010-05-09 15:52:27 +00:00
|
|
|
RFILE rf;
|
2017-03-12 07:20:15 +00:00
|
|
|
char *s = bytes->buf;
|
|
|
|
Py_ssize_t n = bytes->len;
|
2010-05-09 15:52:27 +00:00
|
|
|
PyObject* result;
|
2024-01-16 16:05:15 +00:00
|
|
|
rf.allow_code = allow_code;
|
2010-05-09 15:52:27 +00:00
|
|
|
rf.fp = NULL;
|
2011-07-02 15:42:47 +00:00
|
|
|
rf.readable = NULL;
|
2010-05-09 15:52:27 +00:00
|
|
|
rf.ptr = s;
|
|
|
|
rf.end = s + n;
|
|
|
|
rf.depth = 0;
|
2013-03-20 01:02:10 +00:00
|
|
|
if ((rf.refs = PyList_New(0)) == NULL)
|
|
|
|
return NULL;
|
2010-05-09 15:52:27 +00:00
|
|
|
result = read_object(&rf);
|
2013-03-20 01:02:10 +00:00
|
|
|
Py_DECREF(rf.refs);
|
2010-05-09 15:52:27 +00:00
|
|
|
return result;
|
1991-06-04 19:42:30 +00:00
|
|
|
}
|
|
|
|
|
1997-04-29 20:08:16 +00:00
|
|
|
static PyMethodDef marshal_methods[] = {
|
2017-03-12 07:20:15 +00:00
|
|
|
MARSHAL_DUMP_METHODDEF
|
|
|
|
MARSHAL_LOAD_METHODDEF
|
|
|
|
MARSHAL_DUMPS_METHODDEF
|
|
|
|
MARSHAL_LOADS_METHODDEF
|
2010-05-09 15:52:27 +00:00
|
|
|
{NULL, NULL} /* sentinel */
|
1991-06-04 19:42:30 +00:00
|
|
|
};
|
|
|
|
|
2009-05-13 12:27:21 +00:00
|
|
|
|
|
|
|
PyDoc_STRVAR(module_doc,
|
|
|
|
"This module contains functions that can read and write Python values in\n\
|
|
|
|
a binary format. The format is specific to Python, but independent of\n\
|
|
|
|
machine architecture issues.\n\
|
|
|
|
\n\
|
|
|
|
Not all Python object types are supported; in general, only objects\n\
|
|
|
|
whose value is independent from a particular invocation of Python can be\n\
|
|
|
|
written and read by this module. The following types are supported:\n\
|
|
|
|
None, integers, floating point numbers, strings, bytes, bytearrays,\n\
|
|
|
|
tuples, lists, sets, dictionaries, and code objects, where it\n\
|
|
|
|
should be understood that tuples, lists and dictionaries are only\n\
|
|
|
|
supported as long as the values contained therein are themselves\n\
|
|
|
|
supported; and recursive lists and dictionaries should not be written\n\
|
|
|
|
(they will cause infinite loops).\n\
|
|
|
|
\n\
|
|
|
|
Variables:\n\
|
|
|
|
\n\
|
|
|
|
version -- indicates the format that the module uses. Version 0 is the\n\
|
|
|
|
historical format, version 1 shares interned strings and version 2\n\
|
|
|
|
uses a binary format for floating point numbers.\n\
|
2013-03-20 01:02:10 +00:00
|
|
|
Version 3 shares common object references (New in version 3.4).\n\
|
2009-05-13 12:27:21 +00:00
|
|
|
\n\
|
|
|
|
Functions:\n\
|
|
|
|
\n\
|
|
|
|
dump() -- write value to a file\n\
|
|
|
|
load() -- read value from a file\n\
|
2017-03-12 06:53:22 +00:00
|
|
|
dumps() -- marshal value as a bytes object\n\
|
|
|
|
loads() -- read value from a bytes-like object");
|
2009-05-13 12:27:21 +00:00
|
|
|
|
|
|
|
|
2020-09-08 13:33:52 +00:00
|
|
|
static int
|
|
|
|
marshal_module_exec(PyObject *mod)
|
|
|
|
{
|
|
|
|
if (PyModule_AddIntConstant(mod, "version", Py_MARSHAL_VERSION) < 0) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyModuleDef_Slot marshalmodule_slots[] = {
|
|
|
|
{Py_mod_exec, marshal_module_exec},
|
2023-05-05 21:11:27 +00:00
|
|
|
{Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
|
2024-05-03 15:30:55 +00:00
|
|
|
{Py_mod_gil, Py_MOD_GIL_NOT_USED},
|
2020-09-08 13:33:52 +00:00
|
|
|
{0, NULL}
|
|
|
|
};
|
2009-05-13 12:27:21 +00:00
|
|
|
|
2008-06-27 00:35:35 +00:00
|
|
|
static struct PyModuleDef marshalmodule = {
|
2010-05-09 15:52:27 +00:00
|
|
|
PyModuleDef_HEAD_INIT,
|
2020-09-08 13:33:52 +00:00
|
|
|
.m_name = "marshal",
|
|
|
|
.m_doc = module_doc,
|
|
|
|
.m_methods = marshal_methods,
|
|
|
|
.m_slots = marshalmodule_slots,
|
2008-06-11 05:26:20 +00:00
|
|
|
};
|
|
|
|
|
2003-09-04 11:59:50 +00:00
|
|
|
PyMODINIT_FUNC
|
2000-07-22 18:47:25 +00:00
|
|
|
PyMarshal_Init(void)
|
1991-06-04 19:42:30 +00:00
|
|
|
{
|
2020-09-08 13:33:52 +00:00
|
|
|
return PyModuleDef_Init(&marshalmodule);
|
1991-06-04 19:42:30 +00:00
|
|
|
}
|