LCOV - code coverage report
Current view: | top level - Objects - cellobject.c (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 23 | 63 | 36.5 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 5 | 11 | 45.5 %
|  |  | Branches: | 6 | 49 | 12.2 %

               Branch data     Line data    Source code
           1                 :            : /* Cell object implementation */
           2                 :            :
           3                 :            : #include "Python.h"
           4                 :            : #include "pycore_object.h"
           5                 :            :
           6                 :            : PyObject *
           7                 :      43879 : PyCell_New(PyObject *obj)
           8                 :            : {
           9                 :            :     PyCellObject *op;
          10                 :            :
          11                 :      43879 :     op = (PyCellObject *)PyObject_GC_New(PyCellObject, &PyCell_Type);
          12         [ -  + ]:      43879 :     if (op == NULL)
          13                 :          0 :         return NULL;
          14                 :      43879 :     op->ob_ref = Py_XNewRef(obj);
          15                 :            :
          16                 :      43879 :     _PyObject_GC_TRACK(op);
          17                 :      43879 :     return (PyObject *)op;
          18                 :            : }
          19                 :            :
          20                 :            : PyDoc_STRVAR(cell_new_doc,
          21                 :            : "cell([contents])\n"
          22                 :            : "--\n"
          23                 :            : "\n"
          24                 :            : "Create a new cell object.\n"
          25                 :            : "\n"
          26                 :            : "  contents\n"
          27                 :            : "    the contents of the cell. If not specified, the cell will be empty,\n"
          28                 :            : "    and \n further attempts to access its cell_contents attribute will\n"
          29                 :            : "    raise a ValueError.");
          30                 :            :
          31                 :            :
          32                 :            : static PyObject *
          33                 :          0 : cell_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
          34                 :            : {
          35                 :          0 :     PyObject *return_value = NULL;
          36                 :          0 :     PyObject *obj = NULL;
          37                 :            :
          38   [ #  #  #  # ]:          0 :     if (!_PyArg_NoKeywords("cell", kwargs)) {
          39                 :          0 :         goto exit;
          40                 :            :     }
          41                 :            :     /* min = 0: we allow the cell to be empty */
          42         [ #  # ]:          0 :     if (!PyArg_UnpackTuple(args, "cell", 0, 1, &obj)) {
          43                 :          0 :         goto exit;
          44                 :            :     }
          45                 :          0 :     return_value = PyCell_New(obj);
          46                 :            :
          47                 :          0 : exit:
          48                 :          0 :     return return_value;
          49                 :            : }
          50                 :            :
          51                 :            : PyObject *
          52                 :          0 : PyCell_Get(PyObject *op)
          53                 :            : {
          54         [ #  # ]:          0 :     if (!PyCell_Check(op)) {
          55                 :          0 :         PyErr_BadInternalCall();
          56                 :          0 :         return NULL;
          57                 :            :     }
          58                 :          0 :     PyObject *value = PyCell_GET(op);
          59                 :          0 :     return Py_XNewRef(value);
          60                 :            : }
          61                 :            :
          62                 :            : int
          63                 :        327 : PyCell_Set(PyObject *op, PyObject *value)
          64                 :            : {
          65         [ -  + ]:        327 :     if (!PyCell_Check(op)) {
          66                 :          0 :         PyErr_BadInternalCall();
          67                 :          0 :         return -1;
          68                 :            :     }
          69                 :        327 :     PyObject *old_value = PyCell_GET(op);
          70                 :        327 :     PyCell_SET(op, Py_XNewRef(value));
          71                 :        327 :     Py_XDECREF(old_value);
          72                 :        327 :     return 0;
          73                 :            : }
          74                 :            :
          75                 :            : static void
          76                 :      43836 : cell_dealloc(PyCellObject *op)
          77                 :            : {
          78                 :      43836 :     _PyObject_GC_UNTRACK(op);
          79                 :      43836 :     Py_XDECREF(op->ob_ref);
          80                 :      43836 :     PyObject_GC_Del(op);
          81                 :      43836 : }
          82                 :            :
          83                 :            : static PyObject *
          84                 :          0 : cell_richcompare(PyObject *a, PyObject *b, int op)
          85                 :            : {
          86                 :            :     /* neither argument should be NULL, unless something's gone wrong */
          87                 :            :     assert(a != NULL && b != NULL);
          88                 :            :
          89                 :            :     /* both arguments should be instances of PyCellObject */
          90   [ #  #  #  # ]:          0 :     if (!PyCell_Check(a) || !PyCell_Check(b)) {
          91                 :          0 :         Py_RETURN_NOTIMPLEMENTED;
          92                 :            :     }
          93                 :            :
          94                 :            :     /* compare cells by contents; empty cells come before anything else */
          95                 :          0 :     a = ((PyCellObject *)a)->ob_ref;
          96                 :          0 :     b = ((PyCellObject *)b)->ob_ref;
          97   [ #  #  #  # ]:          0 :     if (a != NULL && b != NULL)
          98                 :          0 :         return PyObject_RichCompare(a, b, op);
          99                 :            :
         100   [ #  #  #  #  :          0 :     Py_RETURN_RICHCOMPARE(b == NULL, a == NULL, op);
              #  #  #  #  #
              #  #  #  #  #
                 #  #  #  #
                          # ]
         101                 :            : }
         102                 :            :
         103                 :            : static PyObject *
         104                 :          0 : cell_repr(PyCellObject *op)
         105                 :            : {
         106         [ #  # ]:          0 :     if (op->ob_ref == NULL)
         107                 :          0 :         return PyUnicode_FromFormat("<cell at %p: empty>", op);
         108                 :            :
         109                 :          0 :     return PyUnicode_FromFormat("<cell at %p: %.80s object at %p>",
         110                 :          0 :                                op, Py_TYPE(op->ob_ref)->tp_name,
         111                 :            :                                op->ob_ref);
         112                 :            : }
         113                 :            :
         114                 :            : static int
         115                 :      20264 : cell_traverse(PyCellObject *op, visitproc visit, void *arg)
         116                 :            : {
         117   [ +  +  -  + ]:      20264 :     Py_VISIT(op->ob_ref);
         118                 :      20264 :     return 0;
         119                 :            : }
         120                 :            :
         121                 :            : static int
         122                 :         60 : cell_clear(PyCellObject *op)
         123                 :            : {
         124         [ +  - ]:         60 :     Py_CLEAR(op->ob_ref);
         125                 :         60 :     return 0;
         126                 :            : }
         127                 :            :
         128                 :            : static PyObject *
         129                 :          0 : cell_get_contents(PyCellObject *op, void *closure)
         130                 :            : {
         131         [ #  # ]:          0 :     if (op->ob_ref == NULL)
         132                 :            :     {
         133                 :          0 :         PyErr_SetString(PyExc_ValueError, "Cell is empty");
         134                 :          0 :         return NULL;
         135                 :            :     }
         136                 :          0 :     return Py_NewRef(op->ob_ref);
         137                 :            : }
         138                 :            :
         139                 :            : static int
         140                 :          0 : cell_set_contents(PyCellObject *op, PyObject *obj, void *Py_UNUSED(ignored))
         141                 :            : {
         142                 :          0 :     Py_XSETREF(op->ob_ref, Py_XNewRef(obj));
         143                 :          0 :     return 0;
         144                 :            : }
         145                 :            :
         146                 :            : static PyGetSetDef cell_getsetlist[] = {
         147                 :            :     {"cell_contents", (getter)cell_get_contents,
         148                 :            :                       (setter)cell_set_contents, NULL},
         149                 :            :     {NULL} /* sentinel */
         150                 :            : };
         151                 :            :
         152                 :            : PyTypeObject PyCell_Type = {
         153                 :            :     PyVarObject_HEAD_INIT(&PyType_Type, 0)
         154                 :            :     "cell",
         155                 :            :     sizeof(PyCellObject),
         156                 :            :     0,
         157                 :            :     (destructor)cell_dealloc,                   /* tp_dealloc */
         158                 :            :     0,                                          /* tp_vectorcall_offset */
         159                 :            :     0,                                          /* tp_getattr */
         160                 :            :     0,                                          /* tp_setattr */
         161                 :            :     0,                                          /* tp_as_async */
         162                 :            :     (reprfunc)cell_repr,                        /* tp_repr */
         163                 :            :     0,                                          /* tp_as_number */
         164                 :            :     0,                                          /* tp_as_sequence */
         165                 :            :     0,                                          /* tp_as_mapping */
         166                 :            :     0,                                          /* tp_hash */
         167                 :            :     0,                                          /* tp_call */
         168                 :            :     0,                                          /* tp_str */
         169                 :            :     PyObject_GenericGetAttr,                    /* tp_getattro */
         170                 :            :     0,                                          /* tp_setattro */
         171                 :            :     0,                                          /* tp_as_buffer */
         172                 :            :     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,    /* tp_flags */
         173                 :            :     cell_new_doc,                               /* tp_doc */
         174                 :            :     (traverseproc)cell_traverse,                /* tp_traverse */
         175                 :            :     (inquiry)cell_clear,                        /* tp_clear */
         176                 :            :     cell_richcompare,                           /* tp_richcompare */
         177                 :            :     0,                                          /* tp_weaklistoffset */
         178                 :            :     0,                                          /* tp_iter */
         179                 :            :     0,                                          /* tp_iternext */
         180                 :            :     0,                                          /* tp_methods */
         181                 :            :     0,                                          /* tp_members */
         182                 :            :     cell_getsetlist,                            /* tp_getset */
         183                 :            :     0,                                          /* tp_base */
         184                 :            :     0,                                          /* tp_dict */
         185                 :            :     0,                                          /* tp_descr_get */
         186                 :            :     0,                                          /* tp_descr_set */
         187                 :            :     0,                                          /* tp_dictoffset */
         188                 :            :     0,                                          /* tp_init */
         189                 :            :     0,                                          /* tp_alloc */
         190                 :            :     (newfunc)cell_new,                          /* tp_new */
         191                 :            :     0,                                          /* tp_free */
         192                 :            : };

Generated by: LCOV version 1.14