/src/cpython/Python/modsupport.c

Source (jump to first uncovered line)

/* Module support implementation */

#include "Python.h"
#include "pycore_abstract.h"   // _PyIndex_Check()
#include "pycore_object.h"     // _PyType_IsReady()

typedef double va_double;

static PyObject *va_build_value(const char *, va_list);


int
_Py_convert_optional_to_ssize_t(PyObject *obj, void *result)
{
    Py_ssize_t limit;
    if (obj == Py_None) {
        return 1;
    }
    else if (_PyIndex_Check(obj)) {
        limit = PyNumber_AsSsize_t(obj, PyExc_OverflowError);
        if (limit == -1 && PyErr_Occurred()) {
            return 0;
        }
    }
    else {
        PyErr_Format(PyExc_TypeError,
                     "argument should be integer or None, not '%.200s'",
                     Py_TYPE(obj)->tp_name);
        return 0;
    }
    *((Py_ssize_t *)result) = limit;
    return 1;
}

int
_Py_convert_optional_to_non_negative_ssize_t(PyObject *obj, void *result)
{
    if (!_Py_convert_optional_to_ssize_t(obj, result)) {
        return 0;
    }
    if (obj != Py_None && *((Py_ssize_t *)result) < 0) {
        PyErr_SetString(PyExc_ValueError, "argument cannot be negative");
        return 0;
    }
    return 1;
}


/* Helper for mkvalue() to scan the length of a format */

static Py_ssize_t
countformat(const char *format, char endchar)
{
    Py_ssize_t count = 0;
    int level = 0;
    while (level > 0 || *format != endchar) {
        switch (*format) {
        case '\0':
            /* Premature end */
            PyErr_SetString(PyExc_SystemError,
                            "unmatched paren in format");
            return -1;
        case '(':
        case '[':
        case '{':
            if (level == 0) {
                count++;
            }
            level++;
            break;
        case ')':
        case ']':
        case '}':
            level--;
            break;
        case '#':
        case '&':
        case ',':
        case ':':
        case ' ':
        case '\t':
            break;
        default:
            if (level == 0) {
                count++;
            }
        }
        format++;
    }
    return count;
}


/* Generic function to create a value -- the inverse of getargs() */
/* After an original idea and first implementation by Steven Miale */

static PyObject *do_mktuple(const char**, va_list *, char, Py_ssize_t);
static int do_mkstack(PyObject **, const char**, va_list *, char, Py_ssize_t);
static PyObject *do_mklist(const char**, va_list *, char, Py_ssize_t);
static PyObject *do_mkdict(const char**, va_list *, char, Py_ssize_t);
static PyObject *do_mkvalue(const char**, va_list *);

static int
check_end(const char **p_format, char endchar)
{
    const char *f = *p_format;
    while (*f != endchar) {
        if (*f != ' ' && *f != '\t' && *f != ',' && *f != ':') {
            PyErr_SetString(PyExc_SystemError,
                            "Unmatched paren in format");
            return 0;
        }
        f++;
    }
    if (endchar) {
        f++;
    }
    *p_format = f;
    return 1;
}

static void
do_ignore(const char **p_format, va_list *p_va, char endchar, Py_ssize_t n)
{
    assert(PyErr_Occurred());
    PyObject *v = PyTuple_New(n);
    for (Py_ssize_t i = 0; i < n; i++) {
        PyObject *exc = PyErr_GetRaisedException();
        PyObject *w = do_mkvalue(p_format, p_va);
        PyErr_SetRaisedException(exc);
        if (w != NULL) {
            if (v != NULL) {
                PyTuple_SET_ITEM(v, i, w);
            }
            else {
                Py_DECREF(w);
            }
        }
    }
    Py_XDECREF(v);
    if (!check_end(p_format, endchar)) {
        return;
    }
}

static PyObject *
do_mkdict(const char **p_format, va_list *p_va, char endchar, Py_ssize_t n)
{
    PyObject *d;
    Py_ssize_t i;
    if (n < 0)
        return NULL;
    if (n % 2) {
        PyErr_SetString(PyExc_SystemError,
                        "Bad dict format");
        do_ignore(p_format, p_va, endchar, n);
        return NULL;
    }
    /* Note that we can't bail immediately on error as this will leak
       refcounts on any 'N' arguments. */
    if ((d = PyDict_New()) == NULL) {
        do_ignore(p_format, p_va, endchar, n);
        return NULL;
    }
    for (i = 0; i < n; i+= 2) {
        PyObject *k, *v;

        k = do_mkvalue(p_format, p_va);
        if (k == NULL) {
            do_ignore(p_format, p_va, endchar, n - i - 1);
            Py_DECREF(d);
            return NULL;
        }
        v = do_mkvalue(p_format, p_va);
        if (v == NULL || PyDict_SetItem(d, k, v) < 0) {
            do_ignore(p_format, p_va, endchar, n - i - 2);
            Py_DECREF(k);
            Py_XDECREF(v);
            Py_DECREF(d);
            return NULL;
        }
        Py_DECREF(k);
        Py_DECREF(v);
    }
    if (!check_end(p_format, endchar)) {
        Py_DECREF(d);
        return NULL;
    }
    return d;
}

static PyObject *
do_mklist(const char **p_format, va_list *p_va, char endchar, Py_ssize_t n)
{
    PyObject *v;
    Py_ssize_t i;
    if (n < 0)
        return NULL;
    /* Note that we can't bail immediately on error as this will leak
       refcounts on any 'N' arguments. */
    v = PyList_New(n);
    if (v == NULL) {
        do_ignore(p_format, p_va, endchar, n);
        return NULL;
    }
    for (i = 0; i < n; i++) {
        PyObject *w = do_mkvalue(p_format, p_va);
        if (w == NULL) {
            do_ignore(p_format, p_va, endchar, n - i - 1);
            Py_DECREF(v);
            return NULL;
        }
        PyList_SET_ITEM(v, i, w);
    }
    if (!check_end(p_format, endchar)) {
        Py_DECREF(v);
        return NULL;
    }
    return v;
}

static int
do_mkstack(PyObject **stack, const char **p_format, va_list *p_va,
           char endchar, Py_ssize_t n)
{
    Py_ssize_t i;

    if (n < 0) {
        return -1;
    }
    /* Note that we can't bail immediately on error as this will leak
       refcounts on any 'N' arguments. */
    for (i = 0; i < n; i++) {
        PyObject *w = do_mkvalue(p_format, p_va);
        if (w == NULL) {
            do_ignore(p_format, p_va, endchar, n - i - 1);
            goto error;
        }
        stack[i] = w;
    }
    if (!check_end(p_format, endchar)) {
        goto error;
    }
    return 0;

error:
    n = i;
    for (i=0; i < n; i++) {
        Py_DECREF(stack[i]);
    }
    return -1;
}

static PyObject *
do_mktuple(const char **p_format, va_list *p_va, char endchar, Py_ssize_t n)
{
    PyObject *v;
    Py_ssize_t i;
    if (n < 0)
        return NULL;
    /* Note that we can't bail immediately on error as this will leak
       refcounts on any 'N' arguments. */
    if ((v = PyTuple_New(n)) == NULL) {
        do_ignore(p_format, p_va, endchar, n);
        return NULL;
    }
    for (i = 0; i < n; i++) {
        PyObject *w = do_mkvalue(p_format, p_va);
        if (w == NULL) {
            do_ignore(p_format, p_va, endchar, n - i - 1);
            Py_DECREF(v);
            return NULL;
        }
        PyTuple_SET_ITEM(v, i, w);
    }
    if (!check_end(p_format, endchar)) {
        Py_DECREF(v);
        return NULL;
    }
    return v;
}

static PyObject *
do_mkvalue(const char **p_format, va_list *p_va)
{
    for (;;) {
        switch (*(*p_format)++) {
        case '(':
            return do_mktuple(p_format, p_va, ')',
                              countformat(*p_format, ')'));

        case '[':
            return do_mklist(p_format, p_va, ']',
                             countformat(*p_format, ']'));

        case '{':
            return do_mkdict(p_format, p_va, '}',
                             countformat(*p_format, '}'));

        case 'b':
        case 'B':
        case 'h':
        case 'i':
            return PyLong_FromLong((long)va_arg(*p_va, int));

        case 'H':
            return PyLong_FromLong((long)va_arg(*p_va, unsigned int));

        case 'I':
        {
            unsigned int n;
            n = va_arg(*p_va, unsigned int);
            return PyLong_FromUnsignedLong(n);
        }

        case 'n':
#if SIZEOF_SIZE_T!=SIZEOF_LONG
            return PyLong_FromSsize_t(va_arg(*p_va, Py_ssize_t));
#endif
            /* Fall through from 'n' to 'l' if Py_ssize_t is long */
            _Py_FALLTHROUGH;
        case 'l':
            return PyLong_FromLong(va_arg(*p_va, long));

        case 'k':
        {
            unsigned long n;
            n = va_arg(*p_va, unsigned long);
            return PyLong_FromUnsignedLong(n);
        }

        case 'L':
            return PyLong_FromLongLong((long long)va_arg(*p_va, long long));

        case 'K':
            return PyLong_FromUnsignedLongLong(
                va_arg(*p_va, unsigned long long));

        case 'u':
        {
            PyObject *v;
            const wchar_t *u = va_arg(*p_va, wchar_t*);
            Py_ssize_t n;
            if (**p_format == '#') {
                ++*p_format;
                n = va_arg(*p_va, Py_ssize_t);
            }
            else
                n = -1;
            if (u == NULL) {
                v = Py_NewRef(Py_None);
            }
            else {
                if (n < 0)
                    n = wcslen(u);
                v = PyUnicode_FromWideChar(u, n);
            }
            return v;
        }
        case 'f':
        case 'd':
            return PyFloat_FromDouble(
                (double)va_arg(*p_va, va_double));

        case 'D':
            return PyComplex_FromCComplex(
                *((Py_complex *)va_arg(*p_va, Py_complex *)));

        case 'c':
        {
            char p[1];
            p[0] = (char)va_arg(*p_va, int);
            return PyBytes_FromStringAndSize(p, 1);
        }
        case 'C':
        {
            int i = va_arg(*p_va, int);
            return PyUnicode_FromOrdinal(i);
        }
        case 'p':
        {
            int i = va_arg(*p_va, int);
            return PyBool_FromLong(i);
        }

        case 's':
        case 'z':
        case 'U':   /* XXX deprecated alias */
        {
            PyObject *v;
            const char *str = va_arg(*p_va, const char *);
            Py_ssize_t n;
            if (**p_format == '#') {
                ++*p_format;
                n = va_arg(*p_va, Py_ssize_t);
            }
            else
                n = -1;
            if (str == NULL) {
                v = Py_NewRef(Py_None);
            }
            else {
                if (n < 0) {
                    size_t m = strlen(str);
                    if (m > PY_SSIZE_T_MAX) {
                        PyErr_SetString(PyExc_OverflowError,
                            "string too long for Python string");
                        return NULL;
                    }
                    n = (Py_ssize_t)m;
                }
                v = PyUnicode_FromStringAndSize(str, n);
            }
            return v;
        }

        case 'y':
        {
            PyObject *v;
            const char *str = va_arg(*p_va, const char *);
            Py_ssize_t n;
            if (**p_format == '#') {
                ++*p_format;
                n = va_arg(*p_va, Py_ssize_t);
            }
            else
                n = -1;
            if (str == NULL) {
                v = Py_NewRef(Py_None);
            }
            else {
                if (n < 0) {
                    size_t m = strlen(str);
                    if (m > PY_SSIZE_T_MAX) {
                        PyErr_SetString(PyExc_OverflowError,
                            "string too long for Python bytes");
                        return NULL;
                    }
                    n = (Py_ssize_t)m;
                }
                v = PyBytes_FromStringAndSize(str, n);
            }
            return v;
        }

        case 'N':
        case 'S':
        case 'O':
        if (**p_format == '&') {
            typedef PyObject *(*converter)(void *);
            converter func = va_arg(*p_va, converter);
            void *arg = va_arg(*p_va, void *);
            ++*p_format;
            return (*func)(arg);
        }
        else {
            PyObject *v;
            v = va_arg(*p_va, PyObject *);
            if (v != NULL) {
                if (*(*p_format - 1) != 'N')
                    Py_INCREF(v);
            }
            else if (!PyErr_Occurred())
                /* If a NULL was passed
                 * because a call that should
                 * have constructed a value
                 * failed, that's OK, and we
                 * pass the error on; but if
                 * no error occurred it's not
                 * clear that the caller knew
                 * what she was doing. */
                PyErr_SetString(PyExc_SystemError,
                    "NULL object passed to Py_BuildValue");
            return v;
        }

        case ':':
        case ',':
        case ' ':
        case '\t':
            break;

        default:
            PyErr_SetString(PyExc_SystemError,
                "bad format char passed to Py_BuildValue");
            return NULL;

        }
    }
}


PyObject *
Py_BuildValue(const char *format, ...)
{
    va_list va;
    PyObject* retval;
    va_start(va, format);
    retval = va_build_value(format, va);
    va_end(va);
    return retval;
}

PyAPI_FUNC(PyObject *) /* abi only */
_Py_BuildValue_SizeT(const char *format, ...)
{
    va_list va;
    PyObject* retval;
    va_start(va, format);
    retval = va_build_value(format, va);
    va_end(va);
    return retval;
}

PyObject *
Py_VaBuildValue(const char *format, va_list va)
{
    return va_build_value(format, va);
}

PyAPI_FUNC(PyObject *) /* abi only */
_Py_VaBuildValue_SizeT(const char *format, va_list va)
{
    return va_build_value(format, va);
}

static PyObject *
va_build_value(const char *format, va_list va)
{
    const char *f = format;
    Py_ssize_t n = countformat(f, '\0');
    va_list lva;
    PyObject *retval;

    if (n < 0)
        return NULL;
    if (n == 0) {
        Py_RETURN_NONE;
    }
    va_copy(lva, va);
    if (n == 1) {
        retval = do_mkvalue(&f, &lva);
    } else {
        retval = do_mktuple(&f, &lva, '\0', n);
    }
    va_end(lva);
    return retval;
}

PyObject **
_Py_VaBuildStack(PyObject **small_stack, Py_ssize_t small_stack_len,
                const char *format, va_list va, Py_ssize_t *p_nargs)
{
    const char *f;
    Py_ssize_t n;
    va_list lva;
    PyObject **stack;
    int res;

    n = countformat(format, '\0');
    if (n < 0) {
        *p_nargs = 0;
        return NULL;
    }

    if (n == 0) {
        *p_nargs = 0;
        return small_stack;
    }

    if (n <= small_stack_len) {
        stack = small_stack;
    }
    else {
        stack = PyMem_Malloc(n * sizeof(stack[0]));
        if (stack == NULL) {
            PyErr_NoMemory();
            return NULL;
        }
    }

    va_copy(lva, va);
    f = format;
    res = do_mkstack(stack, &f, &lva, '\0', n);
    va_end(lva);

    if (res < 0) {
        if (stack != small_stack) {
            PyMem_Free(stack);
        }
        return NULL;
    }

    *p_nargs = n;
    return stack;
}


int
PyModule_AddObjectRef(PyObject *mod, const char *name, PyObject *value)
{
    if (!PyModule_Check(mod)) {
        PyErr_SetString(PyExc_TypeError,
                        "PyModule_AddObjectRef() first argument "
                        "must be a module");
        return -1;
    }
    if (!value) {
        if (!PyErr_Occurred()) {
            PyErr_SetString(PyExc_SystemError,
                            "PyModule_AddObjectRef() must be called "
                            "with an exception raised if value is NULL");
        }
        return -1;
    }

    PyObject *dict = PyModule_GetDict(mod);
    if (dict == NULL) {
        /* Internal error -- modules must have a dict! */
        PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
                     PyModule_GetName(mod));
        return -1;
    }
    return PyDict_SetItemString(dict, name, value);
}

int
PyModule_Add(PyObject *mod, const char *name, PyObject *value)
{
    int res = PyModule_AddObjectRef(mod, name, value);
    Py_XDECREF(value);
    return res;
}

int
PyModule_AddObject(PyObject *mod, const char *name, PyObject *value)
{
    int res = PyModule_AddObjectRef(mod, name, value);
    if (res == 0) {
        Py_DECREF(value);
    }
    return res;
}

int
PyModule_AddIntConstant(PyObject *m, const char *name, long value)
{
    return PyModule_Add(m, name, PyLong_FromLong(value));
}

int
PyModule_AddStringConstant(PyObject *m, const char *name, const char *value)
{
    return PyModule_Add(m, name, PyUnicode_FromString(value));
}

int
PyModule_AddType(PyObject *module, PyTypeObject *type)
{
    if (!_PyType_IsReady(type) && PyType_Ready(type) < 0) {
        return -1;
    }

    const char *name = _PyType_Name(type);
    assert(name != NULL);

    return PyModule_AddObjectRef(module, name, (PyObject *)type);
}


/* Exported functions for version helper macros */

#undef Py_PACK_FULL_VERSION
uint32_t
Py_PACK_FULL_VERSION(int x, int y, int z, int level, int serial)
{
    return _Py_PACK_FULL_VERSION(x, y, z, level, serial);
}

#undef Py_PACK_VERSION
uint32_t
Py_PACK_VERSION(int x, int y)
{
    return _Py_PACK_VERSION(x, y);
}

Coverage Report

Created: 2025-09-05 07:10

Line	Count	Source (jump to first uncovered line)
1
2		/* Module support implementation */
3
4		#include "Python.h"
5		#include "pycore_abstract.h" // _PyIndex_Check()
6		#include "pycore_object.h" // _PyType_IsReady()
7
8		typedef double va_double;
9
10		static PyObject va_build_value(const char , va_list);
11
12
13		int
14		_Py_convert_optional_to_ssize_t(PyObject obj, void result)
15	192k	{
16	192k	Py_ssize_t limit;
17	192k	if (obj == Py_None) {
18	0	return 1;
19	0	}
20	192k	else if (_PyIndex_Check(obj)) {
21	192k	limit = PyNumber_AsSsize_t(obj, PyExc_OverflowError);
22	192k	if (limit == -1 && PyErr_Occurred()) {
23	0	return 0;
24	0	}
25	192k	}
26	0	else {
27	0	PyErr_Format(PyExc_TypeError,
28	0	"argument should be integer or None, not '%.200s'",
29	0	Py_TYPE(obj)->tp_name);
30	0	return 0;
31	0	}
32	192k	((Py_ssize_t )result) = limit;
33	192k	return 1;
34	192k	}
35
36		int
37		_Py_convert_optional_to_non_negative_ssize_t(PyObject obj, void result)
38	0	{
39	0	if (!_Py_convert_optional_to_ssize_t(obj, result)) {
40	0	return 0;
41	0	}
42	0	if (obj != Py_None && ((Py_ssize_t )result) < 0) {
43	0	PyErr_SetString(PyExc_ValueError, "argument cannot be negative");
44	0	return 0;
45	0	}
46	0	return 1;
47	0	}
48
49
50		/* Helper for mkvalue() to scan the length of a format */
51
52		static Py_ssize_t
53		countformat(const char *format, char endchar)
54	1.71M	{
55	1.71M	Py_ssize_t count = 0;
56	1.71M	int level = 0;
57	6.87M	while (level > 0 \|\| *format != endchar) {
58	5.15M	switch (*format) {
59	0	case '\0':
60		/* Premature end */
61	0	PyErr_SetString(PyExc_SystemError,
62	0	"unmatched paren in format");
63	0	return -1;
64	286k	case '(':
65	286k	case '[':
66	287k	case '{':
67	287k	if (level == 0) {
68	284k	count++;
69	284k	}
70	287k	level++;
71	287k	break;
72	286k	case ')':
73	286k	case ']':
74	287k	case '}':
75	287k	level--;
76	287k	break;
77	76.0k	case '#':
78	76.0k	case '&':
79	76.0k	case ',':
80	76.0k	case ':':
81	76.0k	case ' ':
82	76.0k	case '\t':
83	76.0k	break;
84	4.50M	default:
85	4.50M	if (level == 0) {
86	3.83M	count++;
87	3.83M	}
88	5.15M	}
89	5.15M	format++;
90	5.15M	}
91	1.71M	return count;
92	1.71M	}
93
94
95		/* Generic function to create a value -- the inverse of getargs() */
96		/* After an original idea and first implementation by Steven Miale */
97
98		static PyObject do_mktuple(const char, va_list , char, Py_ssize_t);
99		static int do_mkstack(PyObject , const char, va_list *, char, Py_ssize_t);
100		static PyObject do_mklist(const char, va_list , char, Py_ssize_t);
101		static PyObject do_mkdict(const char, va_list , char, Py_ssize_t);
102		static PyObject do_mkvalue(const char, va_list );
103
104		static int
105		check_end(const char **p_format, char endchar)
106	1.43M	{
107	1.43M	const char f = p_format;
108	1.43M	while (*f != endchar) {
109	0	if (f != ' ' && f != '\t' && f != ',' && f != ':') {
110	0	PyErr_SetString(PyExc_SystemError,
111	0	"Unmatched paren in format");
112	0	return 0;
113	0	}
114	0	f++;
115	0	}
116	1.43M	if (endchar) {
117	284k	f++;
118	284k	}
119	1.43M	*p_format = f;
120	1.43M	return 1;
121	1.43M	}
122
123		static void
124		do_ignore(const char *p_format, va_list p_va, char endchar, Py_ssize_t n)
125	0	{
126	0	assert(PyErr_Occurred());
127	0	PyObject *v = PyTuple_New(n);
128	0	for (Py_ssize_t i = 0; i < n; i++) {
129	0	PyObject *exc = PyErr_GetRaisedException();
130	0	PyObject *w = do_mkvalue(p_format, p_va);
131	0	PyErr_SetRaisedException(exc);
132	0	if (w != NULL) {
133	0	if (v != NULL) {
134	0	PyTuple_SET_ITEM(v, i, w);
135	0	}
136	0	else {
137	0	Py_DECREF(w);
138	0	}
139	0	}
140	0	}
141	0	Py_XDECREF(v);
142	0	if (!check_end(p_format, endchar)) {
143	0	return;
144	0	}
145	0	}
146
147		static PyObject *
148		do_mkdict(const char *p_format, va_list p_va, char endchar, Py_ssize_t n)
149	1.40k	{
150	1.40k	PyObject *d;
151	1.40k	Py_ssize_t i;
152	1.40k	if (n < 0)
153	0	return NULL;
154	1.40k	if (n % 2) {
155	0	PyErr_SetString(PyExc_SystemError,
156	0	"Bad dict format");
157	0	do_ignore(p_format, p_va, endchar, n);
158	0	return NULL;
159	0	}
160		/* Note that we can't bail immediately on error as this will leak
161		refcounts on any 'N' arguments. */
162	1.40k	if ((d = PyDict_New()) == NULL) {
163	0	do_ignore(p_format, p_va, endchar, n);
164	0	return NULL;
165	0	}
166	6.92k	for (i = 0; i < n; i+= 2) {
167	5.51k	PyObject k, v;
168
169	5.51k	k = do_mkvalue(p_format, p_va);
170	5.51k	if (k == NULL) {
171	0	do_ignore(p_format, p_va, endchar, n - i - 1);
172	0	Py_DECREF(d);
173	0	return NULL;
174	0	}
175	5.51k	v = do_mkvalue(p_format, p_va);
176	5.51k	if (v == NULL \|\| PyDict_SetItem(d, k, v) < 0) {
177	0	do_ignore(p_format, p_va, endchar, n - i - 2);
178	0	Py_DECREF(k);
179	0	Py_XDECREF(v);
180	0	Py_DECREF(d);
181	0	return NULL;
182	0	}
183	5.51k	Py_DECREF(k);
184	5.51k	Py_DECREF(v);
185	5.51k	}
186	1.40k	if (!check_end(p_format, endchar)) {
187	0	Py_DECREF(d);
188	0	return NULL;
189	0	}
190	1.40k	return d;
191	1.40k	}
192
193		static PyObject *
194		do_mklist(const char *p_format, va_list p_va, char endchar, Py_ssize_t n)
195	0	{
196	0	PyObject *v;
197	0	Py_ssize_t i;
198	0	if (n < 0)
199	0	return NULL;
200		/* Note that we can't bail immediately on error as this will leak
201		refcounts on any 'N' arguments. */
202	0	v = PyList_New(n);
203	0	if (v == NULL) {
204	0	do_ignore(p_format, p_va, endchar, n);
205	0	return NULL;
206	0	}
207	0	for (i = 0; i < n; i++) {
208	0	PyObject *w = do_mkvalue(p_format, p_va);
209	0	if (w == NULL) {
210	0	do_ignore(p_format, p_va, endchar, n - i - 1);
211	0	Py_DECREF(v);
212	0	return NULL;
213	0	}
214	0	PyList_SET_ITEM(v, i, w);
215	0	}
216	0	if (!check_end(p_format, endchar)) {
217	0	Py_DECREF(v);
218	0	return NULL;
219	0	}
220	0	return v;
221	0	}
222
223		static int
224		do_mkstack(PyObject stack, const char p_format, va_list *p_va,
225		char endchar, Py_ssize_t n)
226	295k	{
227	295k	Py_ssize_t i;
228
229	295k	if (n < 0) {
230	0	return -1;
231	0	}
232		/* Note that we can't bail immediately on error as this will leak
233		refcounts on any 'N' arguments. */
234	1.75M	for (i = 0; i < n; i++) {
235	1.46M	PyObject *w = do_mkvalue(p_format, p_va);
236	1.46M	if (w == NULL) {
237	0	do_ignore(p_format, p_va, endchar, n - i - 1);
238	0	goto error;
239	0	}
240	1.46M	stack[i] = w;
241	1.46M	}
242	295k	if (!check_end(p_format, endchar)) {
243	0	goto error;
244	0	}
245	295k	return 0;
246
247	0	error:
248	0	n = i;
249	0	for (i=0; i < n; i++) {
250	0	Py_DECREF(stack[i]);
251	0	}
252	0	return -1;
253	295k	}
254
255		static PyObject *
256		do_mktuple(const char *p_format, va_list p_va, char endchar, Py_ssize_t n)
257	1.14M	{
258	1.14M	PyObject *v;
259	1.14M	Py_ssize_t i;
260	1.14M	if (n < 0)
261	0	return NULL;
262		/* Note that we can't bail immediately on error as this will leak
263		refcounts on any 'N' arguments. */
264	1.14M	if ((v = PyTuple_New(n)) == NULL) {
265	0	do_ignore(p_format, p_va, endchar, n);
266	0	return NULL;
267	0	}
268	3.50M	for (i = 0; i < n; i++) {
269	2.36M	PyObject *w = do_mkvalue(p_format, p_va);
270	2.36M	if (w == NULL) {
271	0	do_ignore(p_format, p_va, endchar, n - i - 1);
272	0	Py_DECREF(v);
273	0	return NULL;
274	0	}
275	2.36M	PyTuple_SET_ITEM(v, i, w);
276	2.36M	}
277	1.14M	if (!check_end(p_format, endchar)) {
278	0	Py_DECREF(v);
279	0	return NULL;
280	0	}
281	1.14M	return v;
282	1.14M	}
283
284		static PyObject *
285		do_mkvalue(const char *p_format, va_list p_va)
286	4.11M	{
287	4.11M	for (;;) {
288	4.11M	switch ((p_format)++) {
289	283k	case '(':
290	283k	return do_mktuple(p_format, p_va, ')',
291	283k	countformat(*p_format, ')'));
292
293	0	case '[':
294	0	return do_mklist(p_format, p_va, ']',
295	0	countformat(*p_format, ']'));
296
297	1.40k	case '{':
298	1.40k	return do_mkdict(p_format, p_va, '}',
299	1.40k	countformat(*p_format, '}'));
300
301	0	case 'b':
302	0	case 'B':
303	0	case 'h':
304	69.2k	case 'i':
305	69.2k	return PyLong_FromLong((long)va_arg(*p_va, int));
306
307	0	case 'H':
308	0	return PyLong_FromLong((long)va_arg(*p_va, unsigned int));
309
310	40	case 'I':
311	40	{
312	40	unsigned int n;
313	40	n = va_arg(*p_va, unsigned int);
314	40	return PyLong_FromUnsignedLong(n);
315	0	}
316
317	1.70M	case 'n':
318		#if SIZEOF_SIZE_T!=SIZEOF_LONG
319		return PyLong_FromSsize_t(va_arg(*p_va, Py_ssize_t));
320		#endif
321		/* Fall through from 'n' to 'l' if Py_ssize_t is long */
322	1.70M	_Py_FALLTHROUGH;
323	1.70M	case 'l':
324	1.70M	return PyLong_FromLong(va_arg(*p_va, long));
325
326	0	case 'k':
327	0	{
328	0	unsigned long n;
329	0	n = va_arg(*p_va, unsigned long);
330	0	return PyLong_FromUnsignedLong(n);
331	1.70M	}
332
333	0	case 'L':
334	0	return PyLong_FromLongLong((long long)va_arg(*p_va, long long));
335
336	0	case 'K':
337	0	return PyLong_FromUnsignedLongLong(
338	0	va_arg(*p_va, unsigned long long));
339
340	0	case 'u':
341	0	{
342	0	PyObject *v;
343	0	const wchar_t u = va_arg(p_va, wchar_t*);
344	0	Py_ssize_t n;
345	0	if (**p_format == '#') {
346	0	++*p_format;
347	0	n = va_arg(*p_va, Py_ssize_t);
348	0	}
349	0	else
350	0	n = -1;
351	0	if (u == NULL) {
352	0	v = Py_NewRef(Py_None);
353	0	}
354	0	else {
355	0	if (n < 0)
356	0	n = wcslen(u);
357	0	v = PyUnicode_FromWideChar(u, n);
358	0	}
359	0	return v;
360	1.70M	}
361	0	case 'f':
362	0	case 'd':
363	0	return PyFloat_FromDouble(
364	0	(double)va_arg(*p_va, va_double));
365
366	0	case 'D':
367	0	return PyComplex_FromCComplex(
368	0	((Py_complex )va_arg(p_va, Py_complex )));
369
370	146	case 'c':
371	146	{
372	146	char p[1];
373	146	p[0] = (char)va_arg(*p_va, int);
374	146	return PyBytes_FromStringAndSize(p, 1);
375	0	}
376	0	case 'C':
377	0	{
378	0	int i = va_arg(*p_va, int);
379	0	return PyUnicode_FromOrdinal(i);
380	0	}
381	0	case 'p':
382	0	{
383	0	int i = va_arg(*p_va, int);
384	0	return PyBool_FromLong(i);
385	0	}
386
387	570k	case 's':
388	572k	case 'z':
389	572k	case 'U': /* XXX deprecated alias */
390	572k	{
391	572k	PyObject *v;
392	572k	const char str = va_arg(p_va, const char *);
393	572k	Py_ssize_t n;
394	572k	if (**p_format == '#') {
395	0	++*p_format;
396	0	n = va_arg(*p_va, Py_ssize_t);
397	0	}
398	572k	else
399	572k	n = -1;
400	572k	if (str == NULL) {
401	0	v = Py_NewRef(Py_None);
402	0	}
403	572k	else {
404	572k	if (n < 0) {
405	572k	size_t m = strlen(str);
406	572k	if (m > PY_SSIZE_T_MAX) {
407	0	PyErr_SetString(PyExc_OverflowError,
408	0	"string too long for Python string");
409	0	return NULL;
410	0	}
411	572k	n = (Py_ssize_t)m;
412	572k	}
413	572k	v = PyUnicode_FromStringAndSize(str, n);
414	572k	}
415	572k	return v;
416	572k	}
417
418	76.0k	case 'y':
419	76.0k	{
420	76.0k	PyObject *v;
421	76.0k	const char str = va_arg(p_va, const char *);
422	76.0k	Py_ssize_t n;
423	76.0k	if (**p_format == '#') {
424	76.0k	++*p_format;
425	76.0k	n = va_arg(*p_va, Py_ssize_t);
426	76.0k	}
427	0	else
428	0	n = -1;
429	76.0k	if (str == NULL) {
430	0	v = Py_NewRef(Py_None);
431	0	}
432	76.0k	else {
433	76.0k	if (n < 0) {
434	0	size_t m = strlen(str);
435	0	if (m > PY_SSIZE_T_MAX) {
436	0	PyErr_SetString(PyExc_OverflowError,
437	0	"string too long for Python bytes");
438	0	return NULL;
439	0	}
440	0	n = (Py_ssize_t)m;
441	0	}
442	76.0k	v = PyBytes_FromStringAndSize(str, n);
443	76.0k	}
444	76.0k	return v;
445	76.0k	}
446
447	1.11M	case 'N':
448	1.11M	case 'S':
449	1.40M	case 'O':
450	1.40M	if (**p_format == '&') {
451	0	typedef PyObject (converter)(void *);
452	0	converter func = va_arg(*p_va, converter);
453	0	void arg = va_arg(p_va, void *);
454	0	++*p_format;
455	0	return (*func)(arg);
456	0	}
457	1.40M	else {
458	1.40M	PyObject *v;
459	1.40M	v = va_arg(p_va, PyObject );
460	1.40M	if (v != NULL) {
461	1.40M	if ((p_format - 1) != 'N')
462	291k	Py_INCREF(v);
463	1.40M	}
464	0	else if (!PyErr_Occurred())
465		/* If a NULL was passed
466		* because a call that should
467		* have constructed a value
468		* failed, that's OK, and we
469		* pass the error on; but if
470		* no error occurred it's not
471		* clear that the caller knew
472		* what she was doing. */
473	0	PyErr_SetString(PyExc_SystemError,
474	0	"NULL object passed to Py_BuildValue");
475	1.40M	return v;
476	1.40M	}
477
478	0	case ':':
479	0	case ',':
480	0	case ' ':
481	0	case '\t':
482	0	break;
483
484	0	default:
485	0	PyErr_SetString(PyExc_SystemError,
486	0	"bad format char passed to Py_BuildValue");
487	0	return NULL;
488
489	4.11M	}
490	4.11M	}
491	4.11M	}
492
493
494		PyObject *
495		Py_BuildValue(const char *format, ...)
496	1.13M	{
497	1.13M	va_list va;
498	1.13M	PyObject* retval;
499	1.13M	va_start(va, format);
500	1.13M	retval = va_build_value(format, va);
501	1.13M	va_end(va);
502	1.13M	return retval;
503	1.13M	}
504
505		PyAPI_FUNC(PyObject ) / abi only */
506		_Py_BuildValue_SizeT(const char *format, ...)
507	0	{
508	0	va_list va;
509	0	PyObject* retval;
510	0	va_start(va, format);
511	0	retval = va_build_value(format, va);
512	0	va_end(va);
513	0	return retval;
514	0	}
515
516		PyObject *
517		Py_VaBuildValue(const char *format, va_list va)
518	0	{
519	0	return va_build_value(format, va);
520	0	}
521
522		PyAPI_FUNC(PyObject ) / abi only */
523		_Py_VaBuildValue_SizeT(const char *format, va_list va)
524	0	{
525	0	return va_build_value(format, va);
526	0	}
527
528		static PyObject *
529		va_build_value(const char *format, va_list va)
530	1.13M	{
531	1.13M	const char *f = format;
532	1.13M	Py_ssize_t n = countformat(f, '\0');
533	1.13M	va_list lva;
534	1.13M	PyObject *retval;
535
536	1.13M	if (n < 0)
537	0	return NULL;
538	1.13M	if (n == 0) {
539	0	Py_RETURN_NONE;
540	0	}
541	1.13M	va_copy(lva, va);
542	1.13M	if (n == 1) {
543	279k	retval = do_mkvalue(&f, &lva);
544	856k	} else {
545	856k	retval = do_mktuple(&f, &lva, '\0', n);
546	856k	}
547	1.13M	va_end(lva);
548	1.13M	return retval;
549	1.13M	}
550
551		PyObject **
552		_Py_VaBuildStack(PyObject **small_stack, Py_ssize_t small_stack_len,
553		const char format, va_list va, Py_ssize_t p_nargs)
554	295k	{
555	295k	const char *f;
556	295k	Py_ssize_t n;
557	295k	va_list lva;
558	295k	PyObject **stack;
559	295k	int res;
560
561	295k	n = countformat(format, '\0');
562	295k	if (n < 0) {
563	0	*p_nargs = 0;
564	0	return NULL;
565	0	}
566
567	295k	if (n == 0) {
568	0	*p_nargs = 0;
569	0	return small_stack;
570	0	}
571
572	295k	if (n <= small_stack_len) {
573	295k	stack = small_stack;
574	295k	}
575	96	else {
576	96	stack = PyMem_Malloc(n * sizeof(stack[0]));
577	96	if (stack == NULL) {
578	0	PyErr_NoMemory();
579	0	return NULL;
580	0	}
581	96	}
582
583	295k	va_copy(lva, va);
584	295k	f = format;
585	295k	res = do_mkstack(stack, &f, &lva, '\0', n);
586	295k	va_end(lva);
587
588	295k	if (res < 0) {
589	0	if (stack != small_stack) {
590	0	PyMem_Free(stack);
591	0	}
592	0	return NULL;
593	0	}
594
595	295k	*p_nargs = n;
596	295k	return stack;
597	295k	}
598
599
600		int
601		PyModule_AddObjectRef(PyObject mod, const char name, PyObject *value)
602	8.95k	{
603	8.95k	if (!PyModule_Check(mod)) {
604	0	PyErr_SetString(PyExc_TypeError,
605	0	"PyModule_AddObjectRef() first argument "
606	0	"must be a module");
607	0	return -1;
608	0	}
609	8.95k	if (!value) {
610	0	if (!PyErr_Occurred()) {
611	0	PyErr_SetString(PyExc_SystemError,
612	0	"PyModule_AddObjectRef() must be called "
613	0	"with an exception raised if value is NULL");
614	0	}
615	0	return -1;
616	0	}
617
618	8.95k	PyObject *dict = PyModule_GetDict(mod);
619	8.95k	if (dict == NULL) {
620		/* Internal error -- modules must have a dict! */
621	0	PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
622	0	PyModule_GetName(mod));
623	0	return -1;
624	0	}
625	8.95k	return PyDict_SetItemString(dict, name, value);
626	8.95k	}
627
628		int
629		PyModule_Add(PyObject mod, const char name, PyObject *value)
630	6.72k	{
631	6.72k	int res = PyModule_AddObjectRef(mod, name, value);
632	6.72k	Py_XDECREF(value);
633	6.72k	return res;
634	6.72k	}
635
636		int
637		PyModule_AddObject(PyObject mod, const char name, PyObject *value)
638	0	{
639	0	int res = PyModule_AddObjectRef(mod, name, value);
640	0	if (res == 0) {
641	0	Py_DECREF(value);
642	0	}
643	0	return res;
644	0	}
645
646		int
647		PyModule_AddIntConstant(PyObject m, const char name, long value)
648	6.33k	{
649	6.33k	return PyModule_Add(m, name, PyLong_FromLong(value));
650	6.33k	}
651
652		int
653		PyModule_AddStringConstant(PyObject m, const char name, const char *value)
654	40	{
655	40	return PyModule_Add(m, name, PyUnicode_FromString(value));
656	40	}
657
658		int
659		PyModule_AddType(PyObject module, PyTypeObject type)
660	821	{
661	821	if (!_PyType_IsReady(type) && PyType_Ready(type) < 0) {
662	0	return -1;
663	0	}
664
665	821	const char *name = _PyType_Name(type);
666	821	assert(name != NULL);
667
668	821	return PyModule_AddObjectRef(module, name, (PyObject *)type);
669	821	}
670
671
672		/* Exported functions for version helper macros */
673
674		#undef Py_PACK_FULL_VERSION
675		uint32_t
676		Py_PACK_FULL_VERSION(int x, int y, int z, int level, int serial)
677	0	{
678	0	return _Py_PACK_FULL_VERSION(x, y, z, level, serial);
679	0	}
680
681		#undef Py_PACK_VERSION
682		uint32_t
683		Py_PACK_VERSION(int x, int y)
684	0	{
685	0	return _Py_PACK_VERSION(x, y);
686	0	}