/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;
}


/* 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-07-04 06:49

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