/home/mdboom/Work/builds/cpython/Objects/structseq.c

Source (jump to first uncovered line)
/* Implementation helper: a struct that looks like a tuple.
   See timemodule and posixmodule for example uses.

   The structseq helper is considered an internal CPython implementation
   detail.  Docs for modules using structseqs should call them
   "named tuples" (be sure to include a space between the two
   words and add a link back to the term in Docs/glossary.rst).
*/

#include "Python.h"
#include "pycore_tuple.h"         // _PyTuple_FromArray()
#include "pycore_object.h"        // _PyObject_GC_TRACK()
#include "structmember.h"         // PyMemberDef
#include "pycore_structseq.h"     // PyStructSequence_InitType()
#include "pycore_initconfig.h"    // _PyStatus_OK()

static const char visible_length_key[] = "n_sequence_fields";
static const char real_length_key[] = "n_fields";
static const char unnamed_fields_key[] = "n_unnamed_fields";
static const char match_args_key[] = "__match_args__";

/* Fields with this name have only a field index, not a field name.
   They are only allowed for indices < n_visible_fields. */
const char * const PyStructSequence_UnnamedField = "unnamed field";

static Py_ssize_t
get_type_attr_as_size(PyTypeObject *tp, PyObject *name)
{
    PyObject *v = PyDict_GetItemWithError(tp->tp_dict, name);
    if (v == NULL && !PyErr_Occurred()0) {
        PyErr_Format(PyExc_TypeError,
                     "Missed attribute '%U' of type %s",
                     name, tp->tp_name);
    }
    return PyLong_AsSsize_t(v);
}

#define VISIBLE_SIZE(op) Py_SIZE(op)
#define VISIBLE_SIZE_TP(tp) \
    get_type_attr_as_size(tp, &_Py_ID(n_sequence_fields))
#define REAL_SIZE_TP(tp) \
    get_type_attr_as_size(tp, &_Py_ID(n_fields))
#define REAL_SIZE(op) REAL_SIZE_TP(Py_TYPE(op))

#define UNNAMED_FIELDS_TP(tp) \
    get_type_attr_as_size(tp, &_Py_ID(n_unnamed_fields))
#define UNNAMED_FIELDS(op) UNNAMED_FIELDS_TP(Py_TYPE(op))


PyObject *
PyStructSequence_New(PyTypeObject *type)
{
    PyStructSequence *obj;
    Py_ssize_t size = REAL_SIZE_TP(type), i;
    if (size < 0) {
        return NULL;
    }
    Py_ssize_t vsize = VISIBLE_SIZE_TP(type);
    if (vsize < 0) {
        return NULL;
    }

    obj = PyObject_GC_NewVar(PyStructSequence, type, size);
    if (obj == NULL)
        return NULL;
    /* Hack the size of the variable object, so invisible fields don't appear
     to Python code. */
    Py_SET_SIZE(obj, vsize);
    for (i = 0; i < size; i++6.51M)
        obj->ob_item[i] = NULL;

    return (PyObject*)obj;
}

void
PyStructSequence_SetItem(PyObject* op, Py_ssize_t i, PyObject* v)
{
    PyStructSequence_SET_ITEM(op, i, v);
}

PyObject*
PyStructSequence_GetItem(PyObject* op, Py_ssize_t i)
{
    return PyStructSequence_GET_ITEM(op, i);
}


static int
structseq_traverse(PyStructSequence *obj, visitproc visit, void *arg)
{
    if (Py_TYPE(obj)->tp_flags & Py_TPFLAGS_HEAPTYPE) {
        Py_VISIT(Py_TYPE(obj));
    }
    Py_ssize_t i, size;
    size = REAL_SIZE(obj);
    for (i = 0; i < size; ++i36) {
        Py_VISIT(obj->ob_item[i]);
    }
    return 0;
}

static void
structseq_dealloc(PyStructSequence *obj)
{
    Py_ssize_t i, size;
    PyObject_GC_UnTrack(obj);

    PyTypeObject *tp = Py_TYPE(obj);
    size = REAL_SIZE(obj);
    for (i = 0; i < size; ++i6.51M) {
        Py_XDECREF(obj->ob_item[i]);
    }
    PyObject_GC_Del(obj);
    if (_PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE)) {
        Py_DECREF(tp);
    }
}

/*[clinic input]
class structseq "PyStructSequence *" "NULL"
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=9d781c6922c77752]*/

#include "clinic/structseq.c.h"

/*[clinic input]
@classmethod
structseq.__new__ as structseq_new
    sequence as arg: object
    dict: object(c_default="NULL") = {}
[clinic start generated code]*/

static PyObject *
structseq_new_impl(PyTypeObject *type, PyObject *arg, PyObject *dict)
/*[clinic end generated code: output=baa082e788b171da input=90532511101aa3fb]*/
{
    PyObject *ob;
    PyStructSequence *res = NULL;
    Py_ssize_t len, min_len, max_len, i, n_unnamed_fields;

    min_len = VISIBLE_SIZE_TP(type);
    if (min_len < 0) {
        return NULL;
    }
    max_len = REAL_SIZE_TP(type);
    if (max_len < 0) {
        return NULL;
    }
    n_unnamed_fields = UNNAMED_FIELDS_TP(type);
    if (n_unnamed_fields < 0) {
        return NULL;
    }

    arg = PySequence_Fast(arg, "constructor requires a sequence");

    if (!arg) {
        return NULL;
    }

    if (dict && !123PyDict_Check123(dict)) {
        PyErr_Format(PyExc_TypeError,
                     "%.500s() takes a dict as second arg, if any",
                     type->tp_name);
        Py_DECREF(arg);
        return NULL;
    }

    len = PySequence_Fast_GET_SIZE(arg);
    if (min_len != max_len) {
        if (len < min_len) {
            PyErr_Format(PyExc_TypeError,
                "%.500s() takes an at least %zd-sequence (%zd-sequence given)",
                type->tp_name, min_len, len);
            Py_DECREF(arg);
            return NULL;
        }

        if (len > max_len) {
            PyErr_Format(PyExc_TypeError,
                "%.500s() takes an at most %zd-sequence (%zd-sequence given)",
                type->tp_name, max_len, len);
            Py_DECREF(arg);
            return NULL;
        }
    }
    else {
        if (len != min_len) {
            PyErr_Format(PyExc_TypeError,
                         "%.500s() takes a %zd-sequence (%zd-sequence given)",
                         type->tp_name, min_len, len);
            Py_DECREF(arg);
            return NULL;
        }
    }

    res = (PyStructSequence*) PyStructSequence_New(type);
    if (res == NULL) {
        Py_DECREF(arg);
        return NULL;
    }
    for (i = 0; 14.1ki < len; ++i73.7k) {
        PyObject *v = PySequence_Fast_GET_ITEM(arg, i);
        Py_INCREF(v);
        res->ob_item[i] = v;
    }
    Py_DECREF(arg);
    for (; i < max_len; ++i10.9k) {
        if (dict == NULL) {
            ob = Py_None;
        }
        else {
            ob = _PyDict_GetItemStringWithError(dict,
                type->tp_members[i-n_unnamed_fields].name);
            if (ob == NULL) {
                if (PyErr_Occurred()) {
                    Py_DECREF(res);
                    return NULL;
                }
                ob = Py_None;
            }
        }
        Py_INCREF(ob);
        res->ob_item[i] = ob;
    }

    _PyObject_GC_TRACK(res);
    return (PyObject*) res;
}


static PyObject *
structseq_repr(PyStructSequence *obj)
{
    PyTypeObject *typ = Py_TYPE(obj);
    _PyUnicodeWriter writer;

    /* Write "typename(" */
    PyObject *type_name = PyUnicode_DecodeUTF8(typ->tp_name,
                                               strlen(typ->tp_name),
                                               NULL);
    if (type_name == NULL) {
        return NULL;
    }

    _PyUnicodeWriter_Init(&writer);
    writer.overallocate = 1;
    /* count 5 characters per item: "x=1, " */
    writer.min_length = (PyUnicode_GET_LENGTH(type_name) + 1
                         + VISIBLE_SIZE(obj) * 5 + 1);

    if (_PyUnicodeWriter_WriteStr(&writer, type_name) < 0) {
        Py_DECREF(type_name);
        goto error;
    }
    Py_DECREF(type_name);

    if (_PyUnicodeWriter_WriteChar(&writer, '(') < 0) {
        goto error;
    }

    for (Py_ssize_t i=0; 221i < VISIBLE_SIZE(obj); i++2.20k) {
        if (i > 0) {
            /* Write ", " */
            if (_PyUnicodeWriter_WriteASCIIString(&writer, ", ", 2) < 0) {
                goto error;
            }
        }

        /* Write "name=repr" */
        const char *name_utf8 = typ->tp_members[i].name;
        if (name_utf8 == NULL) {
            PyErr_Format(PyExc_SystemError, "In structseq_repr(), member %zd name is NULL"
                         " for type %.500s", i, typ->tp_name);
            goto error;
        }

        PyObject *name = PyUnicode_DecodeUTF8(name_utf8, strlen(name_utf8), NULL);
        if (name == NULL) {
            goto error;
        }
        if (_PyUnicodeWriter_WriteStr(&writer, name) < 0) {
            Py_DECREF(name);
            goto error;
        }
        Py_DECREF(name);

        if (_PyUnicodeWriter_WriteChar(&writer, '=') < 0) {
            goto error;
        }

        PyObject *value = PyStructSequence_GET_ITEM(obj, i);
        assert(value != NULL);
        PyObject *repr = PyObject_Repr(value);
        if (repr == NULL) {
            goto error;
        }
        if (_PyUnicodeWriter_WriteStr(&writer, repr) < 0) {
            Py_DECREF(repr);
            goto error;
        }
        Py_DECREF(repr);
    }

    if (_PyUnicodeWriter_WriteChar(&writer, ')') < 0) {
        goto error;
    }

    return _PyUnicodeWriter_Finish(&writer);

error:
    _PyUnicodeWriter_Dealloc(&writer);
    return NULL;
}


static PyObject *
structseq_reduce(PyStructSequence* self, PyObject *Py_UNUSED(ignored))
{
    PyObject* tup = NULL;
    PyObject* dict = NULL;
    PyObject* result;
    Py_ssize_t n_fields, n_visible_fields, n_unnamed_fields, i;

    n_fields = REAL_SIZE(self);
    if (n_fields < 0) {
        return NULL;
    }
    n_visible_fields = VISIBLE_SIZE(self);
    n_unnamed_fields = UNNAMED_FIELDS(self);
    if (n_unnamed_fields < 0) {
        return NULL;
    }
    tup = _PyTuple_FromArray(self->ob_item, n_visible_fields);
    if (!tup)
        goto error;

    dict = PyDict_New();
    if (!dict)
        goto error;

    for (i = n_visible_fields; 121i < n_fields; i++464) {
        const char *n = Py_TYPE(self)->tp_members[i-n_unnamed_fields].name;
        if (PyDict_SetItemString(dict, n, self->ob_item[i]) < 0)
            goto error;
    }

    result = Py_BuildValue("(O(OO))", Py_TYPE(self), tup, dict);

    Py_DECREF(tup);
    Py_DECREF(dict);

    return result;

error:
    Py_XDECREF(tup);
    Py_XDECREF(dict);
    return NULL;
}

static PyMethodDef structseq_methods[] = {
    {"__reduce__", (PyCFunction)structseq_reduce, METH_NOARGS, NULL},
    {NULL, NULL}
};

static Py_ssize_t
count_members(PyStructSequence_Desc *desc, Py_ssize_t *n_unnamed_members) {
    Py_ssize_t i;

    *n_unnamed_members = 0;
    for (i = 0; desc->fields[i].name != NULL; ++i24.1k) {
        if (desc->fields[i].name == PyStructSequence_UnnamedField) {
            (*n_unnamed_members)++;
        }
    }
    return i;
}

static int
initialize_structseq_dict(PyStructSequence_Desc *desc, PyObject* dict,
                          Py_ssize_t n_members, Py_ssize_t n_unnamed_members) {
    PyObject *v;

#define SET_DICT_FROM_SIZE(key, value)                                         \
    do {                                                                       \
        v = PyLong_FromSsize_t(value);                                         \
        if (v == NULL) {                                                       \
            return -1;                                                         \
        }                                                                      \
        if (PyDict_SetItemString(dict, key, v) < 0) {                          \
            Py_DECREF(v);                                                      \
            return -1;                                                         \
        }                                                                      \
        Py_DECREF(v);                                                          \
    } while (0)

    SET_DICT_FROM_SIZE(visible_length_key, desc->n_in_sequence);
    SET_DICT_FROM_SIZE(real_length_key, n_members);
    SET_DICT_FROM_SIZE(unnamed_fields_key, n_unnamed_members);

    // Prepare and set __match_args__
    Py_ssize_t i, k;
    PyObject* keys = PyTuple_New(desc->n_in_sequence);
    if (keys == NULL) {
        return -1;
    }

    for (i = k = 0; 3.48ki < desc->n_in_sequence; ++i20.8k) {
        if (desc->fields[i].name == PyStructSequence_UnnamedField) {
            continue;
        }
        PyObject* new_member = PyUnicode_FromString(desc->fields[i].name);
        if (new_member == NULL) {
            goto error;
        }
        PyTuple_SET_ITEM(keys, k, new_member);
        k++;
    }

    if (_PyTuple_Resize(&keys, k) == -1) {
        goto error;
    }

    if (PyDict_SetItemString(dict, match_args_key, keys) < 0) {
        goto error;
    }

    Py_DECREF(keys);
    return 0;

error:
    Py_DECREF(keys);
    return -1;
}

static void
initialize_members(PyStructSequence_Desc *desc, PyMemberDef* members,
                   Py_ssize_t n_members) {
    Py_ssize_t i, k;

    for (i = k = 0; i < n_members; ++i24.1k) {
        if (desc->fields[i].name == PyStructSequence_UnnamedField) {
            continue;
        }

        /* The names and docstrings in these MemberDefs are statically */
        /* allocated so it is expected that they'll outlive the MemberDef */
        members[k].name = desc->fields[i].name;
        members[k].type = T_OBJECT;
        members[k].offset = offsetof(PyStructSequence, ob_item)
          + i * sizeof(PyObject*);
        members[k].flags = READONLY;
        members[k].doc = desc->fields[i].doc;
        k++;
    }
    members[k].name = NULL;
}


int
_PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc,
                           unsigned long tp_flags)
{
    PyMemberDef *members;
    Py_ssize_t n_members, n_unnamed_members;

#ifdef Py_TRACE_REFS
    /* if the type object was chained, unchain it first
       before overwriting its storage */
    if (type->ob_base.ob_base._ob_next) {
        _Py_ForgetReference((PyObject *)type);
    }
#endif

    /* PyTypeObject has already been initialized */
    if (Py_REFCNT(type) != 0) {
        PyErr_BadInternalCall();
        return -1;
    }

    type->tp_name = desc->name;
    type->tp_basicsize = sizeof(PyStructSequence) - sizeof(PyObject *);
    type->tp_itemsize = sizeof(PyObject *);
    type->tp_dealloc = (destructor)structseq_dealloc;
    type->tp_repr = (reprfunc)structseq_repr;
    type->tp_doc = desc->doc;
    type->tp_base = &PyTuple_Type;
    type->tp_methods = structseq_methods;
    type->tp_new = structseq_new;
    type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | tp_flags;
    type->tp_traverse = (traverseproc) structseq_traverse;

    n_members = count_members(desc, &n_unnamed_members);
    members = PyMem_NEW(PyMemberDef, n_members - n_unnamed_members + 1);
    if (members == NULL) {
        PyErr_NoMemory();
        return -1;
    }
    initialize_members(desc, members, n_members);
    type->tp_members = members;

    if (PyType_Ready(type) < 0) {
        PyMem_Free(members);
        return -1;
    }
    Py_INCREF(type);

    if (initialize_structseq_dict(
            desc, type->tp_dict, n_members, n_unnamed_members) < 0) {
        PyMem_Free(members);
        Py_DECREF(type);
        return -1;
    }

    return 0;
}

int
PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc)
{
    return _PyStructSequence_InitType(type, desc, 0);
}

void
PyStructSequence_InitType(PyTypeObject *type, PyStructSequence_Desc *desc)
{
    (void)PyStructSequence_InitType2(type, desc);
}


void
_PyStructSequence_FiniType(PyTypeObject *type)
{
    // Ensure that the type is initialized
    assert(type->tp_name != NULL);
    assert(type->tp_base == &PyTuple_Type);

    // Cannot delete a type if it still has subclasses
    if (type->tp_subclasses != NULL) {
        return;
    }

    // Undo PyStructSequence_NewType()
    type->tp_name = NULL;
    PyMem_Free(type->tp_members);

    _PyStaticType_Dealloc(type);
    assert(Py_REFCNT(type) == 1);
    // Undo Py_INCREF(type) of _PyStructSequence_InitType().
    // Don't use Py_DECREF(): static type must not be deallocated
    Py_SET_REFCNT(type, 0);
#ifdef Py_REF_DEBUG
    _Py_RefTotal--;
#endif

    // Make sure that _PyStructSequence_InitType() will initialize
    // the type again
    assert(Py_REFCNT(type) == 0);
    assert(type->tp_name == NULL);
}


PyTypeObject *
_PyStructSequence_NewType(PyStructSequence_Desc *desc, unsigned long tp_flags)
{
    PyMemberDef *members;
    PyTypeObject *type;
    PyType_Slot slots[8];
    PyType_Spec spec;
    Py_ssize_t n_members, n_unnamed_members;

    /* Initialize MemberDefs */
    n_members = count_members(desc, &n_unnamed_members);
    members = PyMem_NEW(PyMemberDef, n_members - n_unnamed_members + 1);
    if (members == NULL) {
        PyErr_NoMemory();
        return NULL;
    }
    initialize_members(desc, members, n_members);

    /* Initialize Slots */
    slots[0] = (PyType_Slot){Py_tp_dealloc, (destructor)structseq_dealloc};
    slots[1] = (PyType_Slot){Py_tp_repr, (reprfunc)structseq_repr};
    slots[2] = (PyType_Slot){Py_tp_doc, (void *)desc->doc};
    slots[3] = (PyType_Slot){Py_tp_methods, structseq_methods};
    slots[4] = (PyType_Slot){Py_tp_new, structseq_new};
    slots[5] = (PyType_Slot){Py_tp_members, members};
    slots[6] = (PyType_Slot){Py_tp_traverse, (traverseproc)structseq_traverse};
    slots[7] = (PyType_Slot){0, 0};

    /* Initialize Spec */
    /* The name in this PyType_Spec is statically allocated so it is */
    /* expected that it'll outlive the PyType_Spec */
    spec.name = desc->name;
    spec.basicsize = sizeof(PyStructSequence) - sizeof(PyObject *);
    spec.itemsize = sizeof(PyObject *);
    spec.flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | tp_flags;
    spec.slots = slots;

    type = (PyTypeObject *)PyType_FromSpecWithBases(&spec, (PyObject *)&PyTuple_Type);
    PyMem_Free(members);
    if (type == NULL) {
        return NULL;
    }

    if (initialize_structseq_dict(
            desc, type->tp_dict, n_members, n_unnamed_members) < 0) {
        Py_DECREF(type);
        return NULL;
    }

    return type;
}


PyTypeObject *
PyStructSequence_NewType(PyStructSequence_Desc *desc)
{
    return _PyStructSequence_NewType(desc, 0);
}

Coverage Report

Created: 2022-07-08 09:39

Line	Count	Source (jump to first uncovered line)
1	/* Implementation helper: a struct that looks like a tuple.
2	See timemodule and posixmodule for example uses.
3
4	The structseq helper is considered an internal CPython implementation
5	detail. Docs for modules using structseqs should call them
6	"named tuples" (be sure to include a space between the two
7	words and add a link back to the term in Docs/glossary.rst).
8	*/
9
10	#include "Python.h"
11	#include "pycore_tuple.h" // _PyTuple_FromArray()
12	#include "pycore_object.h" // _PyObject_GC_TRACK()
13	#include "structmember.h" // PyMemberDef
14	#include "pycore_structseq.h" // PyStructSequence_InitType()
15	#include "pycore_initconfig.h" // _PyStatus_OK()
16
17	static const char visible_length_key[] = "n_sequence_fields";
18	static const char real_length_key[] = "n_fields";
19	static const char unnamed_fields_key[] = "n_unnamed_fields";
20	static const char match_args_key[] = "__match_args__";
21
22	/* Fields with this name have only a field index, not a field name.
23	They are only allowed for indices < n_visible_fields. */
24	const char * const PyStructSequence_UnnamedField = "unnamed field";
25
26	static Py_ssize_t
27	get_type_attr_as_size(PyTypeObject tp, PyObject name)
28	{
29	PyObject *v = PyDict_GetItemWithError(tp->tp_dict, name);
30	if (v == NULL && !PyErr_Occurred()0 ) { Branch (30:9): [True: 0, False: 1.16M] Branch (30:22): [True: 0, False: 0]
31	PyErr_Format(PyExc_TypeError,
32	"Missed attribute '%U' of type %s",
33	name, tp->tp_name);
34	}
35	return PyLong_AsSsize_t(v);
36	}
37
38	#define VISIBLE_SIZE(op) Py_SIZE(op)
39	#define VISIBLE_SIZE_TP(tp) \
40	get_type_attr_as_size(tp, &_Py_ID(n_sequence_fields))
41	#define REAL_SIZE_TP(tp) \
42	get_type_attr_as_size(tp, &_Py_ID(n_fields))
43	#define REAL_SIZE(op) REAL_SIZE_TP(Py_TYPE(op))
44
45	#define UNNAMED_FIELDS_TP(tp) \
46	get_type_attr_as_size(tp, &_Py_ID(n_unnamed_fields))
47	#define UNNAMED_FIELDS(op) UNNAMED_FIELDS_TP(Py_TYPE(op))
48
49
50	PyObject *
51	PyStructSequence_New(PyTypeObject *type)
52	{
53	PyStructSequence *obj;
54	Py_ssize_t size = REAL_SIZE_TP(type), i;
55	if (size < 0) { Branch (55:9): [True: 0, False: 372k]
56	return NULL;
57	}
58	Py_ssize_t vsize = VISIBLE_SIZE_TP(type);
59	if (vsize < 0) { Branch (59:9): [True: 0, False: 372k]
60	return NULL;
61	}
62
63	obj = PyObject_GC_NewVar(PyStructSequence, type, size);
64	if (obj == NULL) Branch (64:9): [True: 0, False: 372k]
65	return NULL;
66	/* Hack the size of the variable object, so invisible fields don't appear
67	to Python code. */
68	Py_SET_SIZE(obj, vsize);
69	for (i = 0; i < size; i++6.51M ) Branch (69:17): [True: 6.51M, False: 372k]
70	obj->ob_item[i] = NULL;
71
72	return (PyObject*)obj;
73	}
74
75	void
76	PyStructSequence_SetItem(PyObject* op, Py_ssize_t i, PyObject* v)
77	{
78	PyStructSequence_SET_ITEM(op, i, v);
79	}
80
81	PyObject*
82	PyStructSequence_GetItem(PyObject* op, Py_ssize_t i)
83	{
84	return PyStructSequence_GET_ITEM(op, i);
85	}
86
87
88	static int
89	structseq_traverse(PyStructSequence obj, visitproc visit, void arg)
90	{
91	if (Py_TYPE(obj)->tp_flags & Py_TPFLAGS_HEAPTYPE) { Branch (91:9): [True: 4, False: 0]
92	Py_VISIT(Py_TYPE(obj));
93	}
94	Py_ssize_t i, size;
95	size = REAL_SIZE(obj);
96	for (i = 0; i < size; ++i36 ) { Branch (96:17): [True: 36, False: 4]
97	Py_VISIT(obj->ob_item[i]);
98	}
99	return 0;
100	}
101
102	static void
103	structseq_dealloc(PyStructSequence *obj)
104	{
105	Py_ssize_t i, size;
106	PyObject_GC_UnTrack(obj);
107
108	PyTypeObject *tp = Py_TYPE(obj);
109	size = REAL_SIZE(obj);
110	for (i = 0; i < size; ++i6.51M ) { Branch (110:17): [True: 6.51M, False: 372k]
111	Py_XDECREF(obj->ob_item[i]);
112	}
113	PyObject_GC_Del(obj);
114	if (_PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE)) { Branch (114:9): [True: 366k, False: 6.85k]
115	Py_DECREF(tp);
116	}
117	}
118
119	/*[clinic input]
120	class structseq "PyStructSequence *" "NULL"
121	[clinic start generated code]*/
122	/[clinic end generated code: output=da39a3ee5e6b4b0d input=9d781c6922c77752]/
123
124	#include "clinic/structseq.c.h"
125
126	/*[clinic input]
127	@classmethod
128	structseq.__new__ as structseq_new
129	sequence as arg: object
130	dict: object(c_default="NULL") = {}
131	[clinic start generated code]*/
132
133	static PyObject *
134	structseq_new_impl(PyTypeObject type, PyObject arg, PyObject *dict)
135	/[clinic end generated code: output=baa082e788b171da input=90532511101aa3fb]/
136	{
137	PyObject *ob;
138	PyStructSequence *res = NULL;
139	Py_ssize_t len, min_len, max_len, i, n_unnamed_fields;
140
141	min_len = VISIBLE_SIZE_TP(type);
142	if (min_len < 0) { Branch (142:9): [True: 0, False: 14.1k]
143	return NULL;
144	}
145	max_len = REAL_SIZE_TP(type);
146	if (max_len < 0) { Branch (146:9): [True: 0, False: 14.1k]
147	return NULL;
148	}
149	n_unnamed_fields = UNNAMED_FIELDS_TP(type);
150	if (n_unnamed_fields < 0) { Branch (150:9): [True: 0, False: 14.1k]
151	return NULL;
152	}
153
154	arg = PySequence_Fast(arg, "constructor requires a sequence");
155
156	if (!arg) { Branch (156:9): [True: 2, False: 14.1k]
157	return NULL;
158	}
159
160	if (dict && !123 PyDict_Check123 (dict)) { Branch (160:9): [True: 123, False: 14.0k] Branch (160:17): [True: 1, False: 122]
161	PyErr_Format(PyExc_TypeError,
162	"%.500s() takes a dict as second arg, if any",
163	type->tp_name);
164	Py_DECREF(arg);
165	return NULL;
166	}
167
168	len = PySequence_Fast_GET_SIZE(arg);
169	if (min_len != max_len) { Branch (169:9): [True: 6.12k, False: 8.00k]
170	if (len < min_len) { Branch (170:13): [True: 5, False: 6.12k]
171	PyErr_Format(PyExc_TypeError,
172	"%.500s() takes an at least %zd-sequence (%zd-sequence given)",
173	type->tp_name, min_len, len);
174	Py_DECREF(arg);
175	return NULL;
176	}
177
178	if (len > max_len) { Branch (178:13): [True: 1, False: 6.11k]
179	PyErr_Format(PyExc_TypeError,
180	"%.500s() takes an at most %zd-sequence (%zd-sequence given)",
181	type->tp_name, max_len, len);
182	Py_DECREF(arg);
183	return NULL;
184	}
185	}
186	else {
187	if (len != min_len) { Branch (187:13): [True: 0, False: 8.00k]
188	PyErr_Format(PyExc_TypeError,
189	"%.500s() takes a %zd-sequence (%zd-sequence given)",
190	type->tp_name, min_len, len);
191	Py_DECREF(arg);
192	return NULL;
193	}
194	}
195
196	res = (PyStructSequence*) PyStructSequence_New(type);
197	if (res == NULL) { Branch (197:9): [True: 0, False: 14.1k]
198	Py_DECREF(arg);
199	return NULL;
200	}
201	for (i = 0; 14.1k i < len; ++i73.7k ) { Branch (201:17): [True: 73.7k, False: 14.1k]
202	PyObject *v = PySequence_Fast_GET_ITEM(arg, i);
203	Py_INCREF(v);
204	res->ob_item[i] = v;
205	}
206	Py_DECREF(arg);
207	for (; i < max_len; ++i10.9k ) { Branch (207:12): [True: 10.9k, False: 14.1k]
208	if (dict == NULL) { Branch (208:13): [True: 10.4k, False: 464]
209	ob = Py_None;
210	}
211	else {
212	ob = _PyDict_GetItemStringWithError(dict,
213	type->tp_members[i-n_unnamed_fields].name);
214	if (ob == NULL) { Branch (214:17): [True: 2, False: 462]
215	if (PyErr_Occurred()) { Branch (215:21): [True: 0, False: 2]
216	Py_DECREF(res);
217	return NULL;
218	}
219	ob = Py_None;
220	}
221	}
222	Py_INCREF(ob);
223	res->ob_item[i] = ob;
224	}
225
226	_PyObject_GC_TRACK(res);
227	return (PyObject*) res;
228	}
229
230
231	static PyObject *
232	structseq_repr(PyStructSequence *obj)
233	{
234	PyTypeObject *typ = Py_TYPE(obj);
235	_PyUnicodeWriter writer;
236
237	/* Write "typename(" */
238	PyObject *type_name = PyUnicode_DecodeUTF8(typ->tp_name,
239	strlen(typ->tp_name),
240	NULL);
241	if (type_name == NULL) { Branch (241:9): [True: 0, False: 221]
242	return NULL;
243	}
244
245	_PyUnicodeWriter_Init(&writer);
246	writer.overallocate = 1;
247	/* count 5 characters per item: "x=1, " */
248	writer.min_length = (PyUnicode_GET_LENGTH(type_name) + 1
249	+ VISIBLE_SIZE(obj) * 5 + 1);
250
251	if (_PyUnicodeWriter_WriteStr(&writer, type_name) < 0) { Branch (251:9): [True: 0, False: 221]
252	Py_DECREF(type_name);
253	goto error;
254	}
255	Py_DECREF(type_name);
256
257	if (_PyUnicodeWriter_WriteChar(&writer, '(') < 0) { Branch (257:9): [True: 0, False: 221]
258	goto error;
259	}
260
261	for (Py_ssize_t i=0; 221 i < VISIBLE_SIZE(obj); i++2.20k ) { Branch (261:26): [True: 2.20k, False: 221]
262	if (i > 0) { Branch (262:13): [True: 1.98k, False: 221]
263	/* Write ", " */
264	if (_PyUnicodeWriter_WriteASCIIString(&writer, ", ", 2) < 0) { Branch (264:17): [True: 0, False: 1.98k]
265	goto error;
266	}
267	}
268
269	/* Write "name=repr" */
270	const char *name_utf8 = typ->tp_members[i].name;
271	if (name_utf8 == NULL) { Branch (271:13): [True: 0, False: 2.20k]
272	PyErr_Format(PyExc_SystemError, "In structseq_repr(), member %zd name is NULL"
273	" for type %.500s", i, typ->tp_name);
274	goto error;
275	}
276
277	PyObject *name = PyUnicode_DecodeUTF8(name_utf8, strlen(name_utf8), NULL);
278	if (name == NULL) { Branch (278:13): [True: 0, False: 2.20k]
279	goto error;
280	}
281	if (_PyUnicodeWriter_WriteStr(&writer, name) < 0) { Branch (281:13): [True: 0, False: 2.20k]
282	Py_DECREF(name);
283	goto error;
284	}
285	Py_DECREF(name);
286
287	if (_PyUnicodeWriter_WriteChar(&writer, '=') < 0) { Branch (287:13): [True: 0, False: 2.20k]
288	goto error;
289	}
290
291	PyObject *value = PyStructSequence_GET_ITEM(obj, i);
292	assert(value != NULL);
293	PyObject *repr = PyObject_Repr(value);
294	if (repr == NULL) { Branch (294:13): [True: 0, False: 2.20k]
295	goto error;
296	}
297	if (_PyUnicodeWriter_WriteStr(&writer, repr) < 0) { Branch (297:13): [True: 0, False: 2.20k]
298	Py_DECREF(repr);
299	goto error;
300	}
301	Py_DECREF(repr);
302	}
303
304	if (_PyUnicodeWriter_WriteChar(&writer, ')') < 0) { Branch (304:9): [True: 0, False: 221]
305	goto error;
306	}
307
308	return _PyUnicodeWriter_Finish(&writer);
309
310	error:
311	_PyUnicodeWriter_Dealloc(&writer);
312	return NULL;
313	}
314
315
316	static PyObject *
317	structseq_reduce(PyStructSequence* self, PyObject *Py_UNUSED(ignored))
318	{
319	PyObject* tup = NULL;
320	PyObject* dict = NULL;
321	PyObject* result;
322	Py_ssize_t n_fields, n_visible_fields, n_unnamed_fields, i;
323
324	n_fields = REAL_SIZE(self);
325	if (n_fields < 0) { Branch (325:9): [True: 0, False: 121]
326	return NULL;
327	}
328	n_visible_fields = VISIBLE_SIZE(self);
329	n_unnamed_fields = UNNAMED_FIELDS(self);
330	if (n_unnamed_fields < 0) { Branch (330:9): [True: 0, False: 121]
331	return NULL;
332	}
333	tup = _PyTuple_FromArray(self->ob_item, n_visible_fields);
334	if (!tup) Branch (334:9): [True: 0, False: 121]
335	goto error;
336
337	dict = PyDict_New();
338	if (!dict) Branch (338:9): [True: 0, False: 121]
339	goto error;
340
341	for (i = n_visible_fields; 121 i < n_fields; i++464 ) { Branch (341:32): [True: 464, False: 121]
342	const char *n = Py_TYPE(self)->tp_members[i-n_unnamed_fields].name;
343	if (PyDict_SetItemString(dict, n, self->ob_item[i]) < 0) Branch (343:13): [True: 0, False: 464]
344	goto error;
345	}
346
347	result = Py_BuildValue("(O(OO))", Py_TYPE(self), tup, dict);
348
349	Py_DECREF(tup);
350	Py_DECREF(dict);
351
352	return result;
353
354	error:
355	Py_XDECREF(tup);
356	Py_XDECREF(dict);
357	return NULL;
358	}
359
360	static PyMethodDef structseq_methods[] = {
361	{"__reduce__", (PyCFunction)structseq_reduce, METH_NOARGS, NULL},
362	{NULL, NULL}
363	};
364
365	static Py_ssize_t
366	count_members(PyStructSequence_Desc desc, Py_ssize_t n_unnamed_members) {
367	Py_ssize_t i;
368
369	*n_unnamed_members = 0;
370	for (i = 0; desc->fields[i].name != NULL; ++i24.1k ) { Branch (370:17): [True: 24.1k, False: 3.48k]
371	if (desc->fields[i].name == PyStructSequence_UnnamedField) { Branch (371:13): [True: 834, False: 23.3k]
372	(*n_unnamed_members)++;
373	}
374	}
375	return i;
376	}
377
378	static int
379	initialize_structseq_dict(PyStructSequence_Desc desc, PyObject dict,
380	Py_ssize_t n_members, Py_ssize_t n_unnamed_members) {
381	PyObject *v;
382
383	#define SET_DICT_FROM_SIZE(key, value) \
384	do { \
385	v = PyLong_FromSsize_t(value); \
386	if (v == NULL) { \
387	return -1; \
388	} \
389	if (PyDict_SetItemString(dict, key, v) < 0) { \
390	Py_DECREF(v); \
391	return -1; \
392	} \
393	Py_DECREF(v); \
394	} while (0)
395
396	SET_DICT_FROM_SIZE(visible_length_key, desc->n_in_sequence);
397	SET_DICT_FROM_SIZE(real_length_key, n_members);
398	SET_DICT_FROM_SIZE(unnamed_fields_key, n_unnamed_members);
399
400	// Prepare and set __match_args__
401	Py_ssize_t i, k;
402	PyObject* keys = PyTuple_New(desc->n_in_sequence);
403	if (keys == NULL) { Branch (403:9): [True: 0, False: 3.48k]
404	return -1;
405	}
406
407	for (i = k = 0; 3.48k i < desc->n_in_sequence; ++i20.8k ) { Branch (407:21): [True: 20.8k, False: 3.48k]
408	if (desc->fields[i].name == PyStructSequence_UnnamedField) { Branch (408:13): [True: 834, False: 19.9k]
409	continue;
410	}
411	PyObject* new_member = PyUnicode_FromString(desc->fields[i].name);
412	if (new_member == NULL) { Branch (412:13): [True: 0, False: 19.9k]
413	goto error;
414	}
415	PyTuple_SET_ITEM(keys, k, new_member);
416	k++;
417	}
418
419	if (_PyTuple_Resize(&keys, k) == -1) { Branch (419:9): [True: 0, False: 3.48k]
420	goto error;
421	}
422
423	if (PyDict_SetItemString(dict, match_args_key, keys) < 0) { Branch (423:9): [True: 0, False: 3.48k]
424	goto error;
425	}
426
427	Py_DECREF(keys);
428	return 0;
429
430	error:
431	Py_DECREF(keys);
432	return -1;
433	}
434
435	static void
436	initialize_members(PyStructSequence_Desc desc, PyMemberDef members,
437	Py_ssize_t n_members) {
438	Py_ssize_t i, k;
439
440	for (i = k = 0; i < n_members; ++i24.1k ) { Branch (440:21): [True: 24.1k, False: 3.48k]
441	if (desc->fields[i].name == PyStructSequence_UnnamedField) { Branch (441:13): [True: 834, False: 23.3k]
442	continue;
443	}
444
445	/* The names and docstrings in these MemberDefs are statically */
446	/* allocated so it is expected that they'll outlive the MemberDef */
447	members[k].name = desc->fields[i].name;
448	members[k].type = T_OBJECT;
449	members[k].offset = offsetof(PyStructSequence, ob_item)
450	+ i * sizeof(PyObject*);
451	members[k].flags = READONLY;
452	members[k].doc = desc->fields[i].doc;
453	k++;
454	}
455	members[k].name = NULL;
456	}
457
458
459	int
460	_PyStructSequence_InitType(PyTypeObject type, PyStructSequence_Desc desc,
461	unsigned long tp_flags)
462	{
463	PyMemberDef *members;
464	Py_ssize_t n_members, n_unnamed_members;
465
466	#ifdef Py_TRACE_REFS
467	/* if the type object was chained, unchain it first
468	before overwriting its storage */
469	if (type->ob_base.ob_base._ob_next) {
470	_Py_ForgetReference((PyObject *)type);
471	}
472	#endif
473
474	/* PyTypeObject has already been initialized */
475	if (Py_REFCNT(type) != 0) { Branch (475:9): [True: 0, False: 856]
476	PyErr_BadInternalCall();
477	return -1;
478	}
479
480	type->tp_name = desc->name;
481	type->tp_basicsize = sizeof(PyStructSequence) - sizeof(PyObject *);
482	type->tp_itemsize = sizeof(PyObject *);
483	type->tp_dealloc = (destructor)structseq_dealloc;
484	type->tp_repr = (reprfunc)structseq_repr;
485	type->tp_doc = desc->doc;
486	type->tp_base = &PyTuple_Type;
487	type->tp_methods = structseq_methods;
488	type->tp_new = structseq_new;
489	type->tp_flags = Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_HAVE_GC \| tp_flags;
490	type->tp_traverse = (traverseproc) structseq_traverse;
491
492	n_members = count_members(desc, &n_unnamed_members);
493	members = PyMem_NEW(PyMemberDef, n_members - n_unnamed_members + 1);
494	if (members == NULL) { Branch (494:9): [True: 0, False: 856]
495	PyErr_NoMemory();
496	return -1;
497	}
498	initialize_members(desc, members, n_members);
499	type->tp_members = members;
500
501	if (PyType_Ready(type) < 0) { Branch (501:9): [True: 0, False: 856]
502	PyMem_Free(members);
503	return -1;
504	}
505	Py_INCREF(type);
506
507	if (initialize_structseq_dict( Branch (507:9): [True: 0, False: 856]
508	desc, type->tp_dict, n_members, n_unnamed_members) < 0) {
509	PyMem_Free(members);
510	Py_DECREF(type);
511	return -1;
512	}
513
514	return 0;
515	}
516
517	int
518	PyStructSequence_InitType2(PyTypeObject type, PyStructSequence_Desc desc)
519	{
520	return _PyStructSequence_InitType(type, desc, 0);
521	}
522
523	void
524	PyStructSequence_InitType(PyTypeObject type, PyStructSequence_Desc desc)
525	{
526	(void)PyStructSequence_InitType2(type, desc);
527	}
528
529
530	void
531	_PyStructSequence_FiniType(PyTypeObject *type)
532	{
533	// Ensure that the type is initialized
534	assert(type->tp_name != NULL);
535	assert(type->tp_base == &PyTuple_Type);
536
537	// Cannot delete a type if it still has subclasses
538	if (type->tp_subclasses != NULL) { Branch (538:9): [True: 0, False: 824]
539	return;
540	}
541
542	// Undo PyStructSequence_NewType()
543	type->tp_name = NULL;
544	PyMem_Free(type->tp_members);
545
546	_PyStaticType_Dealloc(type);
547	assert(Py_REFCNT(type) == 1);
548	// Undo Py_INCREF(type) of _PyStructSequence_InitType().
549	// Don't use Py_DECREF(): static type must not be deallocated
550	Py_SET_REFCNT(type, 0);
551	#ifdef Py_REF_DEBUG
552	_Py_RefTotal--;
553	#endif
554
555	// Make sure that _PyStructSequence_InitType() will initialize
556	// the type again
557	assert(Py_REFCNT(type) == 0);
558	assert(type->tp_name == NULL);
559	}
560
561
562	PyTypeObject *
563	_PyStructSequence_NewType(PyStructSequence_Desc *desc, unsigned long tp_flags)
564	{
565	PyMemberDef *members;
566	PyTypeObject *type;
567	PyType_Slot slots[8];
568	PyType_Spec spec;
569	Py_ssize_t n_members, n_unnamed_members;
570
571	/* Initialize MemberDefs */
572	n_members = count_members(desc, &n_unnamed_members);
573	members = PyMem_NEW(PyMemberDef, n_members - n_unnamed_members + 1);
574	if (members == NULL) { Branch (574:9): [True: 0, False: 2.62k]
575	PyErr_NoMemory();
576	return NULL;
577	}
578	initialize_members(desc, members, n_members);
579
580	/* Initialize Slots */
581	slots[0] = (PyType_Slot){Py_tp_dealloc, (destructor)structseq_dealloc};
582	slots[1] = (PyType_Slot){Py_tp_repr, (reprfunc)structseq_repr};
583	slots[2] = (PyType_Slot){Py_tp_doc, (void *)desc->doc};
584	slots[3] = (PyType_Slot){Py_tp_methods, structseq_methods};
585	slots[4] = (PyType_Slot){Py_tp_new, structseq_new};
586	slots[5] = (PyType_Slot){Py_tp_members, members};
587	slots[6] = (PyType_Slot){Py_tp_traverse, (traverseproc)structseq_traverse};
588	slots[7] = (PyType_Slot){0, 0};
589
590	/* Initialize Spec */
591	/* The name in this PyType_Spec is statically allocated so it is */
592	/* expected that it'll outlive the PyType_Spec */
593	spec.name = desc->name;
594	spec.basicsize = sizeof(PyStructSequence) - sizeof(PyObject *);
595	spec.itemsize = sizeof(PyObject *);
596	spec.flags = Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_HAVE_GC \| tp_flags;
597	spec.slots = slots;
598
599	type = (PyTypeObject )PyType_FromSpecWithBases(&spec, (PyObject )&PyTuple_Type);
600	PyMem_Free(members);
601	if (type == NULL) { Branch (601:9): [True: 0, False: 2.62k]
602	return NULL;
603	}
604
605	if (initialize_structseq_dict( Branch (605:9): [True: 0, False: 2.62k]
606	desc, type->tp_dict, n_members, n_unnamed_members) < 0) {
607	Py_DECREF(type);
608	return NULL;
609	}
610
611	return type;
612	}
613
614
615	PyTypeObject *
616	PyStructSequence_NewType(PyStructSequence_Desc *desc)
617	{
618	return _PyStructSequence_NewType(desc, 0);
619	}