#include "Python.h"

#include "pycore_call.h" // _PyObject_CallNoArgs()

#include "pycore_code.h" // _PyCode_New()

#include "pycore_hashtable.h" // _Py_hashtable_t

#include "pycore_long.h" // _PyLong_IsZero()

#include "pycore_object.h" // _PyObject_IsUniquelyReferenced

#include "pycore_pystate.h" // _PyInterpreterState_GET()

#include "pycore_setobject.h" // _PySet_NextEntryRef()

#include "pycore_tuple.h" // _PyTuple_FromPairSteal

#include "pycore_unicodeobject.h" // _PyUnicode_InternImmortal()

#include "marshal.h" // Py_MARSHAL_VERSION

#ifdef __APPLE__

# include "TargetConditionals.h"

#endif /* __APPLE__ */

#include "clinic/marshal.c.h"

#if defined(MS_WINDOWS)

# define MAX_MARSHAL_STACK_DEPTH 1000

#elif defined(__wasm__)

# define MAX_MARSHAL_STACK_DEPTH 1500

#elif defined(__APPLE__) && defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE

# define MAX_MARSHAL_STACK_DEPTH 1500

# define MAX_MARSHAL_STACK_DEPTH 2000

#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_BINARY_FLOAT 'g' // Version 0 uses TYPE_FLOAT instead.

#define TYPE_BINARY_COMPLEX 'y' // Version 0 uses TYPE_COMPLEX instead.

#define TYPE_LONG 'l' // See also TYPE_INT.

#define TYPE_STRING 's' // Bytes. (Name comes from Python 2.)

#define TYPE_TUPLE '(' // See also TYPE_SMALL_TUPLE.

#define TYPE_LIST '['

#define TYPE_DICT '{'

#define TYPE_FROZENDICT '}'

#define TYPE_CODE 'c'

#define TYPE_UNICODE 'u'

#define TYPE_UNKNOWN '?'

#define TYPE_SET '<'

#define TYPE_FROZENSET '>'

#define TYPE_SLICE ':'

#define TYPE_INTERNED 't' // Version 1+

#define TYPE_ASCII 'a'

#define TYPE_ASCII_INTERNED 'A'

#define TYPE_SHORT_ASCII 'z'

#define TYPE_SHORT_ASCII_INTERNED 'Z'

#define TYPE_INT 'i' // All versions. 32-bit encoding.

#define TYPE_SMALL_TUPLE ')' // Version 4+

#define TYPE_COMPLEX 'x' // Generated for version 0 only.

#define TYPE_FLOAT 'f' // Generated for version 0 only.

#define TYPE_INT64 'I' // Not generated any more.

#define TYPE_REF 'r'

#define FLAG_REF '\x80' /* with a type, add obj to index */

#define W_ENTRY_ACTIVE ((uintptr_t)1)

#define W_ENTRY_SHARED ((uintptr_t)2)

#define W_ENTRY_SHIFT 2

#define W_REF_SHARED ((size_t)1)

#define W_MAX_REFS Py_MIN((uintptr_t)0x7fffffff, UINTPTR_MAX >> W_ENTRY_SHIFT)

typedef struct {

bool error; /* An exception has been raised. */

int depth;

PyObject *str;

char *ptr;

const char *end;

char *buf;

_Py_hashtable_t *hashtable; /* object -> index in refs, flags */

size_t *refs; /* In order of the first occurrence. */

size_t refs_allocated;

unsigned char *refpos; /* Where the TYPE_REFs are in the

size_t refpos_size;

size_t refpos_allocated;

size_t refpos_run; /* Index in refpos of the length of

size_t refpos_end; /* Offset of the end of the last

int version;

int allow_code;

} WFILE;

#define w_byte(c, p) do { \

if ((p)->ptr != (p)->end || w_reserve((p), 1)) \

*(p)->ptr++ = (c); \

} while(0)

static int

w_reserve(WFILE *p, Py_ssize_t needed)

{

Py_ssize_t pos, size, delta;

if (p->ptr == NULL)

return 0; /* An error already occurred */

assert(p->str != NULL);

pos = p->ptr - p->buf;

size = PyBytes_GET_SIZE(p->str);

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) {

PyErr_NoMemory();

p->error = true;

return 0;

}

size += delta;

if (_PyBytes_Resize(&p->str, size) != 0) {

p->end = p->ptr = p->buf = NULL;

p->error = true;

return 0;

}

else {

p->buf = PyBytes_AS_STRING(p->str);

p->ptr = p->buf + pos;

p->end = p->buf + size;

return 1;

}

}

static void

w_string(const void *s, Py_ssize_t n, WFILE *p)

{

Py_ssize_t m;

if (!n || p->ptr == NULL)

return;

m = p->end - p->ptr;

if (n <= m || w_reserve(p, n - m)) {

memcpy(p->ptr, s, n);

p->ptr += n;

}

}

static void

w_short(int x, WFILE *p)

{

w_byte((char)( x & 0xff), p);

w_byte((char)((x>> 8) & 0xff), p);

}

static void

w_long(long x, WFILE *p)

{

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);

}

static inline uint32_t

w_get_uint32(const char *ptr)

{

const unsigned char *b = (const unsigned char *)ptr;

return b[0] | (b[1] << 8) | (b[2] << 16) | ((uint32_t)b[3] << 24);

}

static inline void

w_put_uint32(char *ptr, uint32_t x)

{

ptr[0] = (char)( x & 0xff);

ptr[1] = (char)((x>> 8) & 0xff);

ptr[2] = (char)((x>>16) & 0xff);

ptr[3] = (char)((x>>24) & 0xff);

}

#define SIZE32_MAX 0x7FFFFFFF

#if SIZEOF_SIZE_T > 4

# define W_SIZE(n, p) do { \

if ((n) > SIZE32_MAX) { \

(p)->depth--; \

PyErr_SetString(PyExc_ValueError, \

"object too large to marshal"); \

(p)->error = true; \

return; \

} \

w_long((long)(n), p); \

} while(0)

# define W_SIZE w_long

static void

w_pstring(const void *s, Py_ssize_t n, WFILE *p)

{

W_SIZE(n, p);

w_string(s, n, p);

}

static void

w_short_pstring(const void *s, Py_ssize_t n, WFILE *p)

{

w_byte(Py_SAFE_DOWNCAST(n, Py_ssize_t, unsigned char), p);

w_string(s, n, p);

}

#define PyLong_MARSHAL_SHIFT 15

#define PyLong_MARSHAL_BASE ((short)1 << PyLong_MARSHAL_SHIFT)

#define PyLong_MARSHAL_MASK (PyLong_MARSHAL_BASE - 1)

#define W_TYPE(t, p) w_byte((t), (p))

static PyObject *

_PyMarshal_WriteObjectToString(PyObject *x, int version, int allow_code);

#define _r_digits(bitsize) \

static void \

_r_digits##bitsize(const uint ## bitsize ## _t *digits, Py_ssize_t n, \

uint8_t negative, Py_ssize_t marshal_ratio, WFILE *p) \

{ \

/* set l to number of base PyLong_MARSHAL_BASE digits */ \

Py_ssize_t l = (n - 1)*marshal_ratio; \

uint ## bitsize ## _t d = digits[n - 1]; \

\

assert(marshal_ratio > 0); \

assert(n >= 1); \

assert(d != 0); /* a PyLong is always normalized */ \

do { \

d >>= PyLong_MARSHAL_SHIFT; \

l++; \

} while (d != 0); \

if (l > SIZE32_MAX) { \

p->depth--; \

PyErr_SetString(PyExc_ValueError, "int too large to marshal"); \

p->error = true; \

return; \

} \

w_long((long)(negative ? -l : l), p); \

\

for (Py_ssize_t i = 0; i < n - 1; i++) { \

d = digits[i]; \

for (Py_ssize_t j = 0; j < marshal_ratio; j++) { \

w_short(d & PyLong_MARSHAL_MASK, p); \

d >>= PyLong_MARSHAL_SHIFT; \

} \

assert(d == 0); \

} \

d = digits[n - 1]; \

do { \

w_short(d & PyLong_MARSHAL_MASK, p); \

d >>= PyLong_MARSHAL_SHIFT; \

} while (d != 0); \

}

_r_digits(16)

_r_digits(32)

#undef _r_digits

static void

w_PyLong(const PyLongObject *ob, WFILE *p)

{

W_TYPE(TYPE_LONG, p);

if (_PyLong_IsZero(ob)) {

w_long((long)0, p);

return;

}

PyLongExport long_export;

if (PyLong_Export((PyObject *)ob, &long_export) < 0) {

p->depth--;

p->error = true;

return;

}

if (!long_export.digits) {

int8_t sign = long_export.value < 0 ? -1 : 1;

uint64_t abs_value = _Py_ABS_CAST(uint64_t, long_export.value);

uint64_t d = abs_value;

long l = 0;

/* set l to number of base PyLong_MARSHAL_BASE digits */

do {

d >>= PyLong_MARSHAL_SHIFT;

l += sign;

} while (d);

w_long(l, p);

d = abs_value;

do {

w_short(d & PyLong_MARSHAL_MASK, p);

d >>= PyLong_MARSHAL_SHIFT;

} while (d);

return;

}

const PyLongLayout *layout = PyLong_GetNativeLayout();

Py_ssize_t marshal_ratio = layout->bits_per_digit/PyLong_MARSHAL_SHIFT;

/* must be a multiple of PyLong_MARSHAL_SHIFT */

assert(layout->bits_per_digit % PyLong_MARSHAL_SHIFT == 0);

assert(layout->bits_per_digit >= PyLong_MARSHAL_SHIFT);

/* other assumptions on PyLongObject internals */

assert(layout->bits_per_digit <= 32);

assert(layout->digits_order == -1);

assert(layout->digit_endianness == (PY_LITTLE_ENDIAN ? -1 : 1));

assert(layout->digit_size == 2 || layout->digit_size == 4);

if (layout->digit_size == 4) {

_r_digits32(long_export.digits, long_export.ndigits,

long_export.negative, marshal_ratio, p);

}

else {

_r_digits16(long_export.digits, long_export.ndigits,

long_export.negative, marshal_ratio, p);

}

PyLong_FreeExport(&long_export);

}

static void

w_float_bin(double v, WFILE *p)

{

char buf[8];

if (PyFloat_Pack8(v, buf, 1) < 0) {

p->error = true;

return;

}

w_string(buf, 8, p);

}

static void

w_float_str(double v, WFILE *p)

{

char *buf = PyOS_double_to_string(v, 'g', 17, 0, NULL);

if (!buf) {

p->error = true;

return;

}

w_short_pstring(buf, strlen(buf), p);

PyMem_Free(buf);

}

static void *

w_array_grow(void *items, size_t n, size_t *allocated, size_t itemsize)

{

if (n < *allocated) {

return items;

}

size_t new_allocated = *allocated ? *allocated * 2 : 16;

if (new_allocated > (size_t)PY_SSIZE_T_MAX / itemsize) {

return NULL;

}

items = PyMem_Realloc(items, new_allocated * itemsize);

if (items != NULL) {

*allocated = new_allocated;

}

return items;

}

static int

w_add_refpos(WFILE *p)

{

size_t pos = (size_t)(p->ptr - p->buf);

size_t gap = pos - p->refpos_end;

p->refpos_end = pos + 5;

if (gap == 0 && p->refpos_run != 0 && p->refpos[p->refpos_run] < 255) {

p->refpos[p->refpos_run]++;

return 1;

}

unsigned char *refpos = w_array_grow(p->refpos,

p->refpos_size + sizeof(size_t),

&p->refpos_allocated, 1);

if (refpos == NULL) {

PyErr_NoMemory();

return 0;

}

p->refpos = refpos;

size_t size = p->refpos_size;

if (gap == 0) {

refpos[size++] = 0;

p->refpos_run = size;

refpos[size++] = 1;

}

else {

p->refpos_run = 0;

if (gap < 255) {

refpos[size++] = (unsigned char)gap;

}

else {

refpos[size++] = 255;

memcpy(refpos + size, &gap, sizeof(gap));

size += sizeof(gap);

}

}

p->refpos_size = size;

return 1;

}

static int

w_ref(PyObject *v, WFILE *p)

{

_Py_hashtable_entry_t *entry;

if (p->version < 3 || p->hashtable == NULL)

return 0; /* not writing object references */

/* An object with only one reference cannot occur twice in the object

if (_PyObject_IsUniquelyReferenced(v)) {

return 0;

}

entry = _Py_hashtable_get_entry(p->hashtable, v);

if (entry != NULL) {

/* write the reference index to the stream */

uintptr_t w = (uintptr_t)entry->value;

if (w & W_ENTRY_ACTIVE) {

PyErr_Format(PyExc_ValueError, "cannot marshal recursion %T objects", v);

goto err;

}

if (!(w & W_ENTRY_SHARED)) {

entry->value = (void *)(w | W_ENTRY_SHARED);

p->refs[w >> W_ENTRY_SHIFT] |= W_REF_SHARED;

}

w >>= W_ENTRY_SHIFT;

assert(w < p->hashtable->nentries);

if (p->end - p->ptr < 5 && !w_reserve(p, 5)) {

return 1;

}

if (!w_add_refpos(p)) {

goto err;

}

*p->ptr++ = TYPE_REF;

/* The index in the reader's reference list is not known yet.

w_put_uint32(p->ptr, (uint32_t)w);

p->ptr += 4;

return 1;

} else {

size_t w = p->hashtable->nentries;

/* we don't support long indices */

if (w >= W_MAX_REFS) {

PyErr_SetString(PyExc_ValueError, "too many objects");

goto err;

}

size_t *refs = w_array_grow(p->refs, w, &p->refs_allocated,

sizeof(*refs));

if (refs == NULL) {

PyErr_NoMemory();

goto err;

}

p->refs = refs;

refs[w] = (size_t)(p->ptr - p->buf) << 1;

uintptr_t value = (uintptr_t)w << W_ENTRY_SHIFT;

// Corresponding code should call w_complete() after

// writing the object.

if (PyTuple_CheckExact(v) || PyCode_Check(v) || PySlice_Check(v) ||

PyFrozenDict_CheckExact(v))

{

value |= W_ENTRY_ACTIVE;

}

if (_Py_hashtable_set(p->hashtable, Py_NewRef(v),

(void *)value) < 0) {

Py_DECREF(v);

PyErr_NoMemory();

goto err;

}

return 0;

}

err:

p->error = true;

return 1;

}

static void

w_resolve_refs(WFILE *p)

{

if (p->error || p->refpos == NULL) {

return;

}

assert(p->hashtable != NULL);

/* Replace the state of each object in p->refs with its index in the

size_t nrefs = p->hashtable->nentries;

size_t *refs = p->refs;

uint32_t index = 0;

for (size_t i = 0; i < nrefs; i++) {

size_t shared = refs[i] & W_REF_SHARED;

char *type = p->buf + (refs[i] >> 1);

assert(!(*type & FLAG_REF));

/* No branch on shared: it would not be predictable. */

*type |= (char)(-(int)shared & FLAG_REF);

refs[i] = index;

index += (uint32_t)shared;

#ifdef Py_DEBUG

if (!shared) {

refs[i] = (size_t)-1;

}

}

const unsigned char *pos = p->refpos;

const unsigned char *end = pos + p->refpos_size;

char *ptr = p->buf;

while (pos < end) {

size_t gap = *pos++;

size_t count = 1;

if (gap == 0) {

count = *pos++;

}

else if (gap == 255) {

memcpy(&gap, pos, sizeof(gap));

pos += sizeof(gap);

}

ptr += gap;

do {

assert(ptr + 5 <= p->ptr);

assert(*ptr == TYPE_REF);

uint32_t w = w_get_uint32(ptr + 1);

assert(w < nrefs);

assert(refs[w] < index);

w_put_uint32(ptr + 1, (uint32_t)refs[w]);

ptr += 5;

} while (--count);

}

}

static void

w_complete(PyObject *v, WFILE *p)

{

if (p->version < 3 || p->hashtable == NULL) {

return;

}

if (_PyObject_IsUniquelyReferenced(v)) {

return;

}

_Py_hashtable_entry_t *entry = _Py_hashtable_get_entry(p->hashtable, v);

if (entry == NULL) {

return;

}

assert(entry != NULL);

uintptr_t w = (uintptr_t)entry->value;

assert(w & W_ENTRY_ACTIVE);

w &= ~W_ENTRY_ACTIVE;

entry->value = (void *)w;

}

static void

w_complex_object(PyObject *v, WFILE *p);

static void

w_object(PyObject *v, WFILE *p)

{

if (p->error) {

return;

}

p->depth++;

if (p->depth > MAX_MARSHAL_STACK_DEPTH) {

PyErr_SetString(PyExc_ValueError,

"object too deeply nested to marshal");

p->error = true;

}

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);

}

else if (!w_ref(v, p))

w_complex_object(v, p);

p->depth--;

}

static void

w_complex_object(PyObject *v, WFILE *p)

{

Py_ssize_t i, n;

if (PyLong_CheckExact(v)) {

int overflow;

long x = PyLong_AsLongAndOverflow(v, &overflow);

if (overflow) {

w_PyLong((PyLongObject *)v, p);

}

else {

#if SIZEOF_LONG > 4

long y = Py_ARITHMETIC_RIGHT_SHIFT(long, x, 31);

if (y && y != -1) {

/* Too large for TYPE_INT */

w_PyLong((PyLongObject*)v, p);

}

else

{

W_TYPE(TYPE_INT, p);

w_long(x, p);

}

}

}

else if (PyFloat_CheckExact(v)) {

if (p->version > 1) {

W_TYPE(TYPE_BINARY_FLOAT, p);

w_float_bin(PyFloat_AS_DOUBLE(v), p);

}

else {

W_TYPE(TYPE_FLOAT, p);

w_float_str(PyFloat_AS_DOUBLE(v), p);

}

}

else if (PyComplex_CheckExact(v)) {

if (p->version > 1) {

W_TYPE(TYPE_BINARY_COMPLEX, p);

w_float_bin(PyComplex_RealAsDouble(v), p);

w_float_bin(PyComplex_ImagAsDouble(v), p);

}

else {

W_TYPE(TYPE_COMPLEX, p);

w_float_str(PyComplex_RealAsDouble(v), p);

w_float_str(PyComplex_ImagAsDouble(v), p);

}

}

else if (PyBytes_CheckExact(v)) {

W_TYPE(TYPE_STRING, p);

w_pstring(PyBytes_AS_STRING(v), PyBytes_GET_SIZE(v), p);

}

else if (PyUnicode_CheckExact(v)) {

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);

w_short_pstring(PyUnicode_1BYTE_DATA(v),

PyUnicode_GET_LENGTH(v), p);

}

else {

if (PyUnicode_CHECK_INTERNED(v))

W_TYPE(TYPE_ASCII_INTERNED, p);

else

W_TYPE(TYPE_ASCII, p);

w_pstring(PyUnicode_1BYTE_DATA(v),

PyUnicode_GET_LENGTH(v), p);

}

}

else {

PyObject *utf8;

utf8 = PyUnicode_AsEncodedString(v, "utf8", "surrogatepass");

if (utf8 == NULL) {

p->depth--;

p->error = true;

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);

}

}

else if (PyTuple_CheckExact(v)) {

n = PyTuple_GET_SIZE(v);

if (p->version >= 4 && n < 256) {

W_TYPE(TYPE_SMALL_TUPLE, p);

w_byte((unsigned char)n, p);

}

else {

W_TYPE(TYPE_TUPLE, p);

W_SIZE(n, p);

}

for (i = 0; i < n; i++) {

w_object(PyTuple_GET_ITEM(v, i), p);

}

w_complete(v, p);

}

else if (PyList_CheckExact(v)) {

W_TYPE(TYPE_LIST, p);

n = PyList_GET_SIZE(v);

W_SIZE(n, p);

for (i = 0; i < n; i++) {

w_object(PyList_GET_ITEM(v, i), p);

}

}

else if (PyAnyDict_CheckExact(v)) {

Py_ssize_t pos;

PyObject *key, *value;

if (PyFrozenDict_CheckExact(v)) {

if (p->version < 6) {

w_byte(TYPE_UNKNOWN, p);

PyErr_Format(PyExc_ValueError,

"marshalling %T objects requires version 6 "

"or higher", v);

p->error = true;

return;

}

W_TYPE(TYPE_FROZENDICT, p);

}

else {

W_TYPE(TYPE_DICT, p);

}

/* 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);

if (PyFrozenDict_CheckExact(v)) {

w_complete(v, p);

}

}

else if (PyAnySet_CheckExact(v)) {

PyObject *value;

Py_ssize_t pos = 0;

Py_hash_t hash;

if (PyFrozenSet_CheckExact(v))

W_TYPE(TYPE_FROZENSET, p);

else

W_TYPE(TYPE_SET, p);

n = PySet_GET_SIZE(v);

W_SIZE(n, p);

// 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).

// The list has a (dump, index, element) tuple for each element.

// The indexes are all different, so that sorting never compares

// two elements: elements with the same dump (NaNs which are

// distinct objects) may not be orderable.

PyObject *items = PyList_New(n);

if (items == NULL) {

p->error = true;

return;

}

// Marshalling an element can run arbitrary code (an audit hook, or

// the __buffer__() method of the element), which can add elements

// to the set or remove some: n is not trusted to still be the size

// of the set.

Py_ssize_t i = 0;

bool changed = false;

Py_BEGIN_CRITICAL_SECTION(v);

while (_PySet_NextEntryRef(v, &pos, &value, &hash)) {

if (i == n) {

changed = true;

Py_DECREF(value);

break;

}

PyObject *dump = _PyMarshal_WriteObjectToString(value,

p->version, p->allow_code);

if (dump == NULL) {

p->error = true;

Py_DECREF(value);

break;

}

PyObject *index = PyLong_FromSsize_t(i);

PyObject *item = NULL;

if (index != NULL) {

item = PyTuple_Pack(3, dump, index, value);

Py_DECREF(index);

}

Py_DECREF(dump);

Py_DECREF(value);

if (item == NULL) {

p->error = true;

break;

}

PyList_SET_ITEM(items, i++, item);

}

Py_END_CRITICAL_SECTION();

if (!p->error && (changed || i != n)) {

PyErr_SetString(PyExc_RuntimeError,

"set changed size during iteration");

p->error = true;

}

if (p->error) {

Py_DECREF(items);

return;

}

if (PyList_Sort(items)) {

p->error = true;

Py_DECREF(items);

return;

}

for (Py_ssize_t i = 0; i < n; i++) {

PyObject *item = PyList_GET_ITEM(items, i);

value = PyTuple_GET_ITEM(item, 2);

w_object(value, p);

}

Py_DECREF(items);

}

else if (PyCode_Check(v)) {

if (!p->allow_code) {

PyErr_SetString(PyExc_ValueError,

"marshalling code objects is disallowed");

p->error = true;

return;

}

PyCodeObject *co = (PyCodeObject *)v;

PyObject *co_code = _PyCode_GetCode(co);

if (co_code == NULL) {

p->error = true;

return;

}

W_TYPE(TYPE_CODE, p);

w_long(co->co_argcount, p);

w_long(co->co_posonlyargcount, p);

w_long(co->co_kwonlyargcount, p);

w_long(co->co_stacksize, p);

w_long(co->co_flags, p);

w_object(co_code, p);

w_object(co->co_consts, p);

w_object(co->co_names, p);

w_object(co->co_localsplusnames, p);

w_object(co->co_localspluskinds, p);

w_object(co->co_filename, p);

w_object(co->co_name, p);

w_object(co->co_qualname, p);

w_long(co->co_firstlineno, p);

w_object(co->co_linetable, p);

w_object(co->co_exceptiontable, p);

Py_DECREF(co_code);

w_complete(v, p);

}

else if (PyObject_CheckBuffer(v)) {

/* Write unknown bytes-like objects as a bytes object */

Py_buffer view;

if (PyObject_GetBuffer(v, &view, PyBUF_SIMPLE) != 0) {

w_byte(TYPE_UNKNOWN, p);

p->depth--;

p->error = true;

return;

}

W_TYPE(TYPE_STRING, p);

w_pstring(view.buf, view.len, p);

PyBuffer_Release(&view);

}

else if (PySlice_Check(v)) {

if (p->version < 5) {

w_byte(TYPE_UNKNOWN, p);

PyErr_Format(PyExc_ValueError,

"marshalling %T objects requires version 5 "

"or higher", v);

p->error = true;

return;

}

PySliceObject *slice = (PySliceObject *)v;

W_TYPE(TYPE_SLICE, p);

w_object(slice->start, p);

w_object(slice->stop, p);

w_object(slice->step, p);

w_complete(v, p);

}

else {

W_TYPE(TYPE_UNKNOWN, p);

PyErr_Format(PyExc_ValueError, "cannot marshal %T objects", v);

p->error = true;

}

}

static void

w_decref_entry(void *key)

{

PyObject *entry_key = (PyObject *)key;

Py_XDECREF(entry_key);

}

static int

w_init_refs(WFILE *wf, int version)

{

if (version >= 3) {

wf->hashtable = _Py_hashtable_new_full(_Py_hashtable_hash_ptr,

_Py_hashtable_compare_direct,

w_decref_entry, NULL, NULL);

if (wf->hashtable == NULL) {

PyErr_NoMemory();

return -1;

}