/src/Python-3.8.3/Python/modsupport.c

Source

/* Module support implementation */

#include "Python.h"

#define FLAG_SIZE_T 1
typedef double va_double;

static PyObject *va_build_value(const char *, va_list, int);
static PyObject **va_build_stack(PyObject **small_stack, Py_ssize_t small_stack_len, const char *, va_list, int, Py_ssize_t*);

/* Package context -- the full module name for package imports */
const char *_Py_PackageContext = NULL;


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, int);
static int do_mkstack(PyObject **, const char**, va_list *, char, Py_ssize_t, int);
static PyObject *do_mklist(const char**, va_list *, char, Py_ssize_t, int);
static PyObject *do_mkdict(const char**, va_list *, char, Py_ssize_t, int);
static PyObject *do_mkvalue(const char**, va_list *, int);


static void
do_ignore(const char **p_format, va_list *p_va, char endchar, Py_ssize_t n, int flags)
{
    PyObject *v;
    Py_ssize_t i;
    assert(PyErr_Occurred());
    v = PyTuple_New(n);
    for (i = 0; i < n; i++) {
        PyObject *exception, *value, *tb, *w;

        PyErr_Fetch(&exception, &value, &tb);
        w = do_mkvalue(p_format, p_va, flags);
        PyErr_Restore(exception, value, tb);
        if (w != NULL) {
            if (v != NULL) {
                PyTuple_SET_ITEM(v, i, w);
            }
            else {
                Py_DECREF(w);
            }
        }
    }
    Py_XDECREF(v);
    if (**p_format != endchar) {
        PyErr_SetString(PyExc_SystemError,
                        "Unmatched paren in format");
        return;
    }
    if (endchar) {
        ++*p_format;
    }
}

static PyObject *
do_mkdict(const char **p_format, va_list *p_va, char endchar, Py_ssize_t n, int flags)
{
    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, flags);
        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, flags);
        return NULL;
    }
    for (i = 0; i < n; i+= 2) {
        PyObject *k, *v;

        k = do_mkvalue(p_format, p_va, flags);
        if (k == NULL) {
            do_ignore(p_format, p_va, endchar, n - i - 1, flags);
            Py_DECREF(d);
            return NULL;
        }
        v = do_mkvalue(p_format, p_va, flags);
        if (v == NULL || PyDict_SetItem(d, k, v) < 0) {
            do_ignore(p_format, p_va, endchar, n - i - 2, flags);
            Py_DECREF(k);
            Py_XDECREF(v);
            Py_DECREF(d);
            return NULL;
        }
        Py_DECREF(k);
        Py_DECREF(v);
    }
    if (**p_format != endchar) {
        Py_DECREF(d);
        PyErr_SetString(PyExc_SystemError,
                        "Unmatched paren in format");
        return NULL;
    }
    if (endchar)
        ++*p_format;
    return d;
}

static PyObject *
do_mklist(const char **p_format, va_list *p_va, char endchar, Py_ssize_t n, int flags)
{
    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, flags);
        return NULL;
    }
    for (i = 0; i < n; i++) {
        PyObject *w = do_mkvalue(p_format, p_va, flags);
        if (w == NULL) {
            do_ignore(p_format, p_va, endchar, n - i - 1, flags);
            Py_DECREF(v);
            return NULL;
        }
        PyList_SET_ITEM(v, i, w);
    }
    if (**p_format != endchar) {
        Py_DECREF(v);
        PyErr_SetString(PyExc_SystemError,
                        "Unmatched paren in format");
        return NULL;
    }
    if (endchar)
        ++*p_format;
    return v;
}

static int
do_mkstack(PyObject **stack, const char **p_format, va_list *p_va,
           char endchar, Py_ssize_t n, int flags)
{
    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, flags);
        if (w == NULL) {
            do_ignore(p_format, p_va, endchar, n - i - 1, flags);
            goto error;
        }
        stack[i] = w;
    }
    if (**p_format != endchar) {
        PyErr_SetString(PyExc_SystemError,
                        "Unmatched paren in format");
        goto error;
    }
    if (endchar) {
        ++*p_format;
    }
    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, int flags)
{
    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, flags);
        return NULL;
    }
    for (i = 0; i < n; i++) {
        PyObject *w = do_mkvalue(p_format, p_va, flags);
        if (w == NULL) {
            do_ignore(p_format, p_va, endchar, n - i - 1, flags);
            Py_DECREF(v);
            return NULL;
        }
        PyTuple_SET_ITEM(v, i, w);
    }
    if (**p_format != endchar) {
        Py_DECREF(v);
        PyErr_SetString(PyExc_SystemError,
                        "Unmatched paren in format");
        return NULL;
    }
    if (endchar)
        ++*p_format;
    return v;
}

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

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

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

        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 */
        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((long long)va_arg(*p_va, unsigned long long));

        case 'u':
        {
            PyObject *v;
            Py_UNICODE *u = va_arg(*p_va, Py_UNICODE *);
            Py_ssize_t n;
            if (**p_format == '#') {
                ++*p_format;
                if (flags & FLAG_SIZE_T)
                    n = va_arg(*p_va, Py_ssize_t);
                else {
                    n = va_arg(*p_va, int);
                    if (PyErr_WarnEx(PyExc_DeprecationWarning,
                                "PY_SSIZE_T_CLEAN will be required for '#' formats", 1)) {
                        return NULL;
                    }
                }
            }
            else
                n = -1;
            if (u == NULL) {
                v = Py_None;
                Py_INCREF(v);
            }
            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 '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;
                if (flags & FLAG_SIZE_T)
                    n = va_arg(*p_va, Py_ssize_t);
                else {
                    n = va_arg(*p_va, int);
                    if (PyErr_WarnEx(PyExc_DeprecationWarning,
                                "PY_SSIZE_T_CLEAN will be required for '#' formats", 1)) {
                        return NULL;
                    }
                }
            }
            else
                n = -1;
            if (str == NULL) {
                v = Py_None;
                Py_INCREF(v);
            }
            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;
                if (flags & FLAG_SIZE_T)
                    n = va_arg(*p_va, Py_ssize_t);
                else {
                    n = va_arg(*p_va, int);
                    if (PyErr_WarnEx(PyExc_DeprecationWarning,
                                "PY_SSIZE_T_CLEAN will be required for '#' formats", 1)) {
                        return NULL;
                    }
                }
            }
            else
                n = -1;
            if (str == NULL) {
                v = Py_None;
                Py_INCREF(v);
            }
            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, 0);
    va_end(va);
    return retval;
}

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

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

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

static PyObject *
va_build_value(const char *format, va_list va, int flags)
{
    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, flags);
    } else {
        retval = do_mktuple(&f, &lva, '\0', n, flags);
    }
    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)
{
    return va_build_stack(small_stack, small_stack_len, format, va, 0, p_nargs);
}

PyObject **
_Py_VaBuildStack_SizeT(PyObject **small_stack, Py_ssize_t small_stack_len,
                       const char *format, va_list va, Py_ssize_t *p_nargs)
{
    return va_build_stack(small_stack, small_stack_len, format, va, FLAG_SIZE_T, p_nargs);
}

static PyObject **
va_build_stack(PyObject **small_stack, Py_ssize_t small_stack_len,
               const char *format, va_list va, int flags, 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, flags);
    va_end(lva);

    if (res < 0) {
        return NULL;
    }

    *p_nargs = n;
    return stack;
}


int
PyModule_AddObject(PyObject *m, const char *name, PyObject *o)
{
    PyObject *dict;
    if (!PyModule_Check(m)) {
        PyErr_SetString(PyExc_TypeError,
                    "PyModule_AddObject() needs module as first arg");
        return -1;
    }
    if (!o) {
        if (!PyErr_Occurred())
            PyErr_SetString(PyExc_TypeError,
                            "PyModule_AddObject() needs non-NULL value");
        return -1;
    }

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

int
PyModule_AddIntConstant(PyObject *m, const char *name, long value)
{
    PyObject *o = PyLong_FromLong(value);
    if (!o)
        return -1;
    if (PyModule_AddObject(m, name, o) == 0)
        return 0;
    Py_DECREF(o);
    return -1;
}

int
PyModule_AddStringConstant(PyObject *m, const char *name, const char *value)
{
    PyObject *o = PyUnicode_FromString(value);
    if (!o)
        return -1;
    if (PyModule_AddObject(m, name, o) == 0)
        return 0;
    Py_DECREF(o);
    return -1;
}

Coverage Report

Created: 2025-10-27 06:40

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