LCOV - code coverage report
Current view: top level - Include/internal - pycore_typeobject.h (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 6 6 100.0 %
Date: 2023-03-20 08:15:36 Functions: 2 2 100.0 %
Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : #ifndef Py_INTERNAL_TYPEOBJECT_H
       2                 :            : #define Py_INTERNAL_TYPEOBJECT_H
       3                 :            : #ifdef __cplusplus
       4                 :            : extern "C" {
       5                 :            : #endif
       6                 :            : 
       7                 :            : #include "pycore_moduleobject.h"
       8                 :            : 
       9                 :            : #ifndef Py_BUILD_CORE
      10                 :            : #  error "this header requires Py_BUILD_CORE define"
      11                 :            : #endif
      12                 :            : 
      13                 :            : 
      14                 :            : /* runtime lifecycle */
      15                 :            : 
      16                 :            : extern PyStatus _PyTypes_InitTypes(PyInterpreterState *);
      17                 :            : extern void _PyTypes_FiniTypes(PyInterpreterState *);
      18                 :            : extern void _PyTypes_Fini(PyInterpreterState *);
      19                 :            : 
      20                 :            : 
      21                 :            : /* other API */
      22                 :            : 
      23                 :            : /* Length of array of slotdef pointers used to store slots with the
      24                 :            :    same __name__.  There should be at most MAX_EQUIV-1 slotdef entries with
      25                 :            :    the same __name__, for any __name__. Since that's a static property, it is
      26                 :            :    appropriate to declare fixed-size arrays for this. */
      27                 :            : #define MAX_EQUIV 10
      28                 :            : 
      29                 :            : typedef struct wrapperbase pytype_slotdef;
      30                 :            : 
      31                 :            : 
      32                 :            : // Type attribute lookup cache: speed up attribute and method lookups,
      33                 :            : // see _PyType_Lookup().
      34                 :            : struct type_cache_entry {
      35                 :            :     unsigned int version;  // initialized from type->tp_version_tag
      36                 :            :     PyObject *name;        // reference to exactly a str or None
      37                 :            :     PyObject *value;       // borrowed reference or NULL
      38                 :            : };
      39                 :            : 
      40                 :            : #define MCACHE_SIZE_EXP 12
      41                 :            : 
      42                 :            : struct type_cache {
      43                 :            :     struct type_cache_entry hashtable[1 << MCACHE_SIZE_EXP];
      44                 :            : };
      45                 :            : 
      46                 :            : /* For now we hard-code this to a value for which we are confident
      47                 :            :    all the static builtin types will fit (for all builds). */
      48                 :            : #define _Py_MAX_STATIC_BUILTIN_TYPES 200
      49                 :            : 
      50                 :            : typedef struct {
      51                 :            :     PyTypeObject *type;
      52                 :            :     PyObject *tp_subclasses;
      53                 :            :     /* We never clean up weakrefs for static builtin types since
      54                 :            :        they will effectively never get triggered.  However, there
      55                 :            :        are also some diagnostic uses for the list of weakrefs,
      56                 :            :        so we still keep it. */
      57                 :            :     PyObject *tp_weaklist;
      58                 :            : } static_builtin_state;
      59                 :            : 
      60                 :            : static inline PyObject **
      61                 :      97444 : _PyStaticType_GET_WEAKREFS_LISTPTR(static_builtin_state *state)
      62                 :            : {
      63                 :            :     assert(state != NULL);
      64                 :      97444 :     return &state->tp_weaklist;
      65                 :            : }
      66                 :            : 
      67                 :            : /* Like PyType_GetModuleState, but skips verification
      68                 :            :  * that type is a heap type with an associated module */
      69                 :            : static inline void *
      70                 :        964 : _PyType_GetModuleState(PyTypeObject *type)
      71                 :            : {
      72                 :            :     assert(PyType_Check(type));
      73                 :            :     assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE);
      74                 :        964 :     PyHeapTypeObject *et = (PyHeapTypeObject *)type;
      75                 :            :     assert(et->ht_module);
      76                 :        964 :     PyModuleObject *mod = (PyModuleObject *)(et->ht_module);
      77                 :            :     assert(mod != NULL);
      78                 :        964 :     return mod->md_state;
      79                 :            : }
      80                 :            : 
      81                 :            : struct types_state {
      82                 :            :     struct type_cache type_cache;
      83                 :            :     size_t num_builtins_initialized;
      84                 :            :     static_builtin_state builtins[_Py_MAX_STATIC_BUILTIN_TYPES];
      85                 :            : };
      86                 :            : 
      87                 :            : 
      88                 :            : extern int _PyStaticType_InitBuiltin(PyTypeObject *type);
      89                 :            : extern static_builtin_state * _PyStaticType_GetState(PyTypeObject *);
      90                 :            : extern void _PyStaticType_ClearWeakRefs(PyTypeObject *type);
      91                 :            : extern void _PyStaticType_Dealloc(PyTypeObject *type);
      92                 :            : 
      93                 :            : PyObject *
      94                 :            : _Py_type_getattro_impl(PyTypeObject *type, PyObject *name, int *suppress_missing_attribute);
      95                 :            : PyObject *
      96                 :            : _Py_type_getattro(PyTypeObject *type, PyObject *name);
      97                 :            : 
      98                 :            : PyObject *_Py_slot_tp_getattro(PyObject *self, PyObject *name);
      99                 :            : PyObject *_Py_slot_tp_getattr_hook(PyObject *self, PyObject *name);
     100                 :            : 
     101                 :            : #ifdef __cplusplus
     102                 :            : }
     103                 :            : #endif
     104                 :            : #endif /* !Py_INTERNAL_TYPEOBJECT_H */

Generated by: LCOV version 1.14