Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 1 | .. highlightlang:: c |
| 2 | |
| 3 | .. _common-structs: |
| 4 | |
| 5 | Common Object Structures |
| 6 | ======================== |
| 7 | |
| 8 | There are a large number of structures which are used in the definition of |
| 9 | object types for Python. This section describes these structures and how they |
| 10 | are used. |
| 11 | |
Jeroen Ruigrok van der Werven | f4a9f96 | 2009-04-26 20:21:12 +0000 | [diff] [blame] | 12 | All Python objects ultimately share a small number of fields at the beginning |
| 13 | of the object's representation in memory. These are represented by the |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 14 | :c:type:`PyObject` and :c:type:`PyVarObject` types, which are defined, in turn, |
Jeroen Ruigrok van der Werven | f4a9f96 | 2009-04-26 20:21:12 +0000 | [diff] [blame] | 15 | by the expansions of some macros also used, whether directly or indirectly, in |
| 16 | the definition of all other Python objects. |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 17 | |
| 18 | |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 19 | .. c:type:: PyObject |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 20 | |
Jeroen Ruigrok van der Werven | f4a9f96 | 2009-04-26 20:21:12 +0000 | [diff] [blame] | 21 | All object types are extensions of this type. This is a type which |
| 22 | contains the information Python needs to treat a pointer to an object as an |
| 23 | object. In a normal "release" build, it contains only the object's |
Gregory P. Smith | 1b24465 | 2015-04-14 11:12:53 -0700 | [diff] [blame] | 24 | reference count and a pointer to the corresponding type object. |
Gregory P. Smith | 0f2f3bc | 2015-04-14 11:21:05 -0700 | [diff] [blame] | 25 | Nothing is actually declared to be a :c:type:`PyObject`, but every pointer |
| 26 | to a Python object can be cast to a :c:type:`PyObject*`. Access to the |
| 27 | members must be done by using the macros :c:macro:`Py_REFCNT` and |
Gregory P. Smith | 1b24465 | 2015-04-14 11:12:53 -0700 | [diff] [blame] | 28 | :c:macro:`Py_TYPE`. |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 29 | |
| 30 | |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 31 | .. c:type:: PyVarObject |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 32 | |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 33 | This is an extension of :c:type:`PyObject` that adds the :attr:`ob_size` |
Jeroen Ruigrok van der Werven | f4a9f96 | 2009-04-26 20:21:12 +0000 | [diff] [blame] | 34 | field. This is only used for objects that have some notion of *length*. |
Gregory P. Smith | 1b24465 | 2015-04-14 11:12:53 -0700 | [diff] [blame] | 35 | This type does not often appear in the Python/C API. |
| 36 | Access to the members must be done by using the macros |
| 37 | :c:macro:`Py_REFCNT`, :c:macro:`Py_TYPE`, and :c:macro:`Py_SIZE`. |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 38 | |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 39 | |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 40 | .. c:macro:: PyObject_HEAD |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 41 | |
Gregory P. Smith | 1b24465 | 2015-04-14 11:12:53 -0700 | [diff] [blame] | 42 | This is a macro used when declaring new types which represent objects |
| 43 | without a varying length. The PyObject_HEAD macro expands to:: |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 44 | |
Gregory P. Smith | 1b24465 | 2015-04-14 11:12:53 -0700 | [diff] [blame] | 45 | PyObject ob_base; |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 46 | |
Zachary Ware | 5c676f6 | 2015-07-06 23:27:15 -0500 | [diff] [blame] | 47 | See documentation of :c:type:`PyObject` above. |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 48 | |
| 49 | |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 50 | .. c:macro:: PyObject_VAR_HEAD |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 51 | |
Gregory P. Smith | 1b24465 | 2015-04-14 11:12:53 -0700 | [diff] [blame] | 52 | This is a macro used when declaring new types which represent objects |
| 53 | with a length that varies from instance to instance. |
| 54 | The PyObject_VAR_HEAD macro expands to:: |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 55 | |
Gregory P. Smith | 1b24465 | 2015-04-14 11:12:53 -0700 | [diff] [blame] | 56 | PyVarObject ob_base; |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 57 | |
Gregory P. Smith | 1b24465 | 2015-04-14 11:12:53 -0700 | [diff] [blame] | 58 | See documentation of :c:type:`PyVarObject` above. |
| 59 | |
| 60 | |
| 61 | .. c:macro:: Py_TYPE(o) |
| 62 | |
Zachary Ware | e36402a | 2015-07-06 23:58:12 -0500 | [diff] [blame] | 63 | This macro is used to access the :attr:`ob_type` member of a Python object. |
Gregory P. Smith | 1b24465 | 2015-04-14 11:12:53 -0700 | [diff] [blame] | 64 | It expands to:: |
| 65 | |
| 66 | (((PyObject*)(o))->ob_type) |
| 67 | |
| 68 | |
| 69 | .. c:macro:: Py_REFCNT(o) |
| 70 | |
Zachary Ware | e36402a | 2015-07-06 23:58:12 -0500 | [diff] [blame] | 71 | This macro is used to access the :attr:`ob_refcnt` member of a Python |
| 72 | object. |
Gregory P. Smith | 1b24465 | 2015-04-14 11:12:53 -0700 | [diff] [blame] | 73 | It expands to:: |
| 74 | |
| 75 | (((PyObject*)(o))->ob_refcnt) |
| 76 | |
| 77 | |
| 78 | .. c:macro:: Py_SIZE(o) |
| 79 | |
Zachary Ware | e36402a | 2015-07-06 23:58:12 -0500 | [diff] [blame] | 80 | This macro is used to access the :attr:`ob_size` member of a Python object. |
Gregory P. Smith | 1b24465 | 2015-04-14 11:12:53 -0700 | [diff] [blame] | 81 | It expands to:: |
| 82 | |
| 83 | (((PyVarObject*)(o))->ob_size) |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 84 | |
Jeroen Ruigrok van der Werven | 939c178 | 2009-04-26 20:25:45 +0000 | [diff] [blame] | 85 | |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 86 | .. c:macro:: PyObject_HEAD_INIT(type) |
Jeroen Ruigrok van der Werven | 939c178 | 2009-04-26 20:25:45 +0000 | [diff] [blame] | 87 | |
| 88 | This is a macro which expands to initialization values for a new |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 89 | :c:type:`PyObject` type. This macro expands to:: |
Jeroen Ruigrok van der Werven | 939c178 | 2009-04-26 20:25:45 +0000 | [diff] [blame] | 90 | |
| 91 | _PyObject_EXTRA_INIT |
| 92 | 1, type, |
| 93 | |
| 94 | |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 95 | .. c:macro:: PyVarObject_HEAD_INIT(type, size) |
Jeroen Ruigrok van der Werven | 939c178 | 2009-04-26 20:25:45 +0000 | [diff] [blame] | 96 | |
| 97 | This is a macro which expands to initialization values for a new |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 98 | :c:type:`PyVarObject` type, including the :attr:`ob_size` field. |
Jeroen Ruigrok van der Werven | 939c178 | 2009-04-26 20:25:45 +0000 | [diff] [blame] | 99 | This macro expands to:: |
| 100 | |
| 101 | _PyObject_EXTRA_INIT |
| 102 | 1, type, size, |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 103 | |
| 104 | |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 105 | .. c:type:: PyCFunction |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 106 | |
Jeroen Ruigrok van der Werven | f4a9f96 | 2009-04-26 20:21:12 +0000 | [diff] [blame] | 107 | Type of the functions used to implement most Python callables in C. |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 108 | Functions of this type take two :c:type:`PyObject\*` parameters and return |
Jeroen Ruigrok van der Werven | f4a9f96 | 2009-04-26 20:21:12 +0000 | [diff] [blame] | 109 | one such value. If the return value is *NULL*, an exception shall have |
| 110 | been set. If not *NULL*, the return value is interpreted as the return |
| 111 | value of the function as exposed in Python. The function must return a new |
| 112 | reference. |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 113 | |
| 114 | |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 115 | .. c:type:: PyCFunctionWithKeywords |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 116 | |
| 117 | Type of the functions used to implement Python callables in C that take |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 118 | keyword arguments: they take three :c:type:`PyObject\*` parameters and return |
| 119 | one such value. See :c:type:`PyCFunction` above for the meaning of the return |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 120 | value. |
| 121 | |
| 122 | |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 123 | .. c:type:: PyMethodDef |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 124 | |
| 125 | Structure used to describe a method of an extension type. This structure has |
| 126 | four fields: |
| 127 | |
Serhiy Storchaka | 84b8e92 | 2017-03-30 10:01:03 +0300 | [diff] [blame] | 128 | +------------------+---------------+-------------------------------+ |
| 129 | | Field | C Type | Meaning | |
| 130 | +==================+===============+===============================+ |
| 131 | | :attr:`ml_name` | const char \* | name of the method | |
| 132 | +------------------+---------------+-------------------------------+ |
| 133 | | :attr:`ml_meth` | PyCFunction | pointer to the C | |
| 134 | | | | implementation | |
| 135 | +------------------+---------------+-------------------------------+ |
| 136 | | :attr:`ml_flags` | int | flag bits indicating how the | |
| 137 | | | | call should be constructed | |
| 138 | +------------------+---------------+-------------------------------+ |
| 139 | | :attr:`ml_doc` | const char \* | points to the contents of the | |
| 140 | | | | docstring | |
| 141 | +------------------+---------------+-------------------------------+ |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 142 | |
| 143 | The :attr:`ml_meth` is a C function pointer. The functions may be of different |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 144 | types, but they always return :c:type:`PyObject\*`. If the function is not of |
| 145 | the :c:type:`PyCFunction`, the compiler will require a cast in the method table. |
| 146 | Even though :c:type:`PyCFunction` defines the first parameter as |
Benjamin Peterson | 82f34ad | 2015-01-13 09:17:24 -0500 | [diff] [blame] | 147 | :c:type:`PyObject\*`, it is common that the method implementation uses the |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 148 | specific C type of the *self* object. |
| 149 | |
| 150 | The :attr:`ml_flags` field is a bitfield which can include the following flags. |
| 151 | The individual flags indicate either a calling convention or a binding |
| 152 | convention. Of the calling convention flags, only :const:`METH_VARARGS` and |
Berker Peksag | 8f95e65 | 2016-06-12 16:34:38 +0300 | [diff] [blame] | 153 | :const:`METH_KEYWORDS` can be combined. Any of the calling convention flags |
| 154 | can be combined with a binding flag. |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 155 | |
| 156 | |
| 157 | .. data:: METH_VARARGS |
| 158 | |
| 159 | This is the typical calling convention, where the methods have the type |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 160 | :c:type:`PyCFunction`. The function expects two :c:type:`PyObject\*` values. |
Georg Brandl | 21dc5ba | 2009-07-11 10:43:08 +0000 | [diff] [blame] | 161 | The first one is the *self* object for methods; for module functions, it is |
| 162 | the module object. The second parameter (often called *args*) is a tuple |
| 163 | object representing all arguments. This parameter is typically processed |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 164 | using :c:func:`PyArg_ParseTuple` or :c:func:`PyArg_UnpackTuple`. |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 165 | |
| 166 | |
| 167 | .. data:: METH_KEYWORDS |
| 168 | |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 169 | Methods with these flags must be of type :c:type:`PyCFunctionWithKeywords`. |
Jeroen Ruigrok van der Werven | f4a9f96 | 2009-04-26 20:21:12 +0000 | [diff] [blame] | 170 | The function expects three parameters: *self*, *args*, and a dictionary of |
Martin Panter | 9da31f7 | 2017-01-11 11:41:03 +0000 | [diff] [blame] | 171 | all the keyword arguments. The flag must be combined with |
Jeroen Ruigrok van der Werven | f4a9f96 | 2009-04-26 20:21:12 +0000 | [diff] [blame] | 172 | :const:`METH_VARARGS`, and the parameters are typically processed using |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 173 | :c:func:`PyArg_ParseTupleAndKeywords`. |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 174 | |
| 175 | |
| 176 | .. data:: METH_NOARGS |
| 177 | |
| 178 | Methods without parameters don't need to check whether arguments are given if |
| 179 | they are listed with the :const:`METH_NOARGS` flag. They need to be of type |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 180 | :c:type:`PyCFunction`. The first parameter is typically named *self* and will |
Georg Brandl | 21dc5ba | 2009-07-11 10:43:08 +0000 | [diff] [blame] | 181 | hold a reference to the module or object instance. In all cases the second |
| 182 | parameter will be *NULL*. |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 183 | |
| 184 | |
| 185 | .. data:: METH_O |
| 186 | |
| 187 | Methods with a single object argument can be listed with the :const:`METH_O` |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 188 | flag, instead of invoking :c:func:`PyArg_ParseTuple` with a ``"O"`` argument. |
| 189 | They have the type :c:type:`PyCFunction`, with the *self* parameter, and a |
| 190 | :c:type:`PyObject\*` parameter representing the single argument. |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 191 | |
| 192 | |
| 193 | These two constants are not used to indicate the calling convention but the |
| 194 | binding when use with methods of classes. These may not be used for functions |
| 195 | defined for modules. At most one of these flags may be set for any given |
| 196 | method. |
| 197 | |
| 198 | |
| 199 | .. data:: METH_CLASS |
| 200 | |
| 201 | .. index:: builtin: classmethod |
| 202 | |
Jeroen Ruigrok van der Werven | f4a9f96 | 2009-04-26 20:21:12 +0000 | [diff] [blame] | 203 | The method will be passed the type object as the first parameter rather |
| 204 | than an instance of the type. This is used to create *class methods*, |
| 205 | similar to what is created when using the :func:`classmethod` built-in |
| 206 | function. |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 207 | |
| 208 | |
| 209 | .. data:: METH_STATIC |
| 210 | |
| 211 | .. index:: builtin: staticmethod |
| 212 | |
Jeroen Ruigrok van der Werven | f4a9f96 | 2009-04-26 20:21:12 +0000 | [diff] [blame] | 213 | The method will be passed *NULL* as the first parameter rather than an |
| 214 | instance of the type. This is used to create *static methods*, similar to |
| 215 | what is created when using the :func:`staticmethod` built-in function. |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 216 | |
| 217 | One other constant controls whether a method is loaded in place of another |
| 218 | definition with the same method name. |
| 219 | |
| 220 | |
| 221 | .. data:: METH_COEXIST |
| 222 | |
| 223 | The method will be loaded in place of existing definitions. Without |
| 224 | *METH_COEXIST*, the default is to skip repeated definitions. Since slot |
Jeroen Ruigrok van der Werven | f4a9f96 | 2009-04-26 20:21:12 +0000 | [diff] [blame] | 225 | wrappers are loaded before the method table, the existence of a |
| 226 | *sq_contains* slot, for example, would generate a wrapped method named |
| 227 | :meth:`__contains__` and preclude the loading of a corresponding |
| 228 | PyCFunction with the same name. With the flag defined, the PyCFunction |
| 229 | will be loaded in place of the wrapper object and will co-exist with the |
| 230 | slot. This is helpful because calls to PyCFunctions are optimized more |
| 231 | than wrapper object calls. |
Georg Brandl | 54a3faa | 2008-01-20 09:30:57 +0000 | [diff] [blame] | 232 | |
Georg Brandl | 1f01deb | 2009-01-03 22:47:39 +0000 | [diff] [blame] | 233 | |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 234 | .. c:type:: PyMemberDef |
Georg Brandl | 1f01deb | 2009-01-03 22:47:39 +0000 | [diff] [blame] | 235 | |
| 236 | Structure which describes an attribute of a type which corresponds to a C |
| 237 | struct member. Its fields are: |
| 238 | |
Serhiy Storchaka | 84b8e92 | 2017-03-30 10:01:03 +0300 | [diff] [blame] | 239 | +------------------+---------------+-------------------------------+ |
| 240 | | Field | C Type | Meaning | |
| 241 | +==================+===============+===============================+ |
| 242 | | :attr:`name` | const char \* | name of the member | |
| 243 | +------------------+---------------+-------------------------------+ |
| 244 | | :attr:`!type` | int | the type of the member in the | |
| 245 | | | | C struct | |
| 246 | +------------------+---------------+-------------------------------+ |
| 247 | | :attr:`offset` | Py_ssize_t | the offset in bytes that the | |
| 248 | | | | member is located on the | |
| 249 | | | | type's object struct | |
| 250 | +------------------+---------------+-------------------------------+ |
| 251 | | :attr:`flags` | int | flag bits indicating if the | |
| 252 | | | | field should be read-only or | |
| 253 | | | | writable | |
| 254 | +------------------+---------------+-------------------------------+ |
| 255 | | :attr:`doc` | const char \* | points to the contents of the | |
| 256 | | | | docstring | |
| 257 | +------------------+---------------+-------------------------------+ |
Georg Brandl | 1f01deb | 2009-01-03 22:47:39 +0000 | [diff] [blame] | 258 | |
csabella | c3c7ef0 | 2017-03-29 20:27:50 -0400 | [diff] [blame] | 259 | :attr:`!type` can be one of many ``T_`` macros corresponding to various C |
Georg Brandl | 1f01deb | 2009-01-03 22:47:39 +0000 | [diff] [blame] | 260 | types. When the member is accessed in Python, it will be converted to the |
| 261 | equivalent Python type. |
| 262 | |
| 263 | =============== ================== |
| 264 | Macro name C type |
| 265 | =============== ================== |
| 266 | T_SHORT short |
| 267 | T_INT int |
| 268 | T_LONG long |
| 269 | T_FLOAT float |
| 270 | T_DOUBLE double |
Serhiy Storchaka | 84b8e92 | 2017-03-30 10:01:03 +0300 | [diff] [blame] | 271 | T_STRING const char \* |
Georg Brandl | 1f01deb | 2009-01-03 22:47:39 +0000 | [diff] [blame] | 272 | T_OBJECT PyObject \* |
| 273 | T_OBJECT_EX PyObject \* |
| 274 | T_CHAR char |
| 275 | T_BYTE char |
Benjamin Peterson | d23f822 | 2009-04-05 19:13:16 +0000 | [diff] [blame] | 276 | T_UBYTE unsigned char |
Georg Brandl | 1f01deb | 2009-01-03 22:47:39 +0000 | [diff] [blame] | 277 | T_UINT unsigned int |
| 278 | T_USHORT unsigned short |
| 279 | T_ULONG unsigned long |
| 280 | T_BOOL char |
| 281 | T_LONGLONG long long |
| 282 | T_ULONGLONG unsigned long long |
| 283 | T_PYSSIZET Py_ssize_t |
| 284 | =============== ================== |
| 285 | |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 286 | :c:macro:`T_OBJECT` and :c:macro:`T_OBJECT_EX` differ in that |
| 287 | :c:macro:`T_OBJECT` returns ``None`` if the member is *NULL* and |
| 288 | :c:macro:`T_OBJECT_EX` raises an :exc:`AttributeError`. Try to use |
| 289 | :c:macro:`T_OBJECT_EX` over :c:macro:`T_OBJECT` because :c:macro:`T_OBJECT_EX` |
Ezio Melotti | 479def3 | 2010-01-03 09:11:59 +0000 | [diff] [blame] | 290 | handles use of the :keyword:`del` statement on that attribute more correctly |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 291 | than :c:macro:`T_OBJECT`. |
Georg Brandl | 1f01deb | 2009-01-03 22:47:39 +0000 | [diff] [blame] | 292 | |
Serhiy Storchaka | 1ecf7d2 | 2016-10-27 21:41:19 +0300 | [diff] [blame] | 293 | :attr:`flags` can be ``0`` for write and read access or :c:macro:`READONLY` for |
Georg Brandl | 60203b4 | 2010-10-06 10:11:56 +0000 | [diff] [blame] | 294 | read-only access. Using :c:macro:`T_STRING` for :attr:`type` implies |
| 295 | :c:macro:`READONLY`. Only :c:macro:`T_OBJECT` and :c:macro:`T_OBJECT_EX` |
Georg Brandl | 1f01deb | 2009-01-03 22:47:39 +0000 | [diff] [blame] | 296 | members can be deleted. (They are set to *NULL*). |