class.h revision 12391:ceeca8b41e4b
1/* 2 pybind11/detail/class.h: Python C API implementation details for py::class_ 3 4 Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch> 5 6 All rights reserved. Use of this source code is governed by a 7 BSD-style license that can be found in the LICENSE file. 8*/ 9 10#pragma once 11 12#include "../attr.h" 13 14NAMESPACE_BEGIN(PYBIND11_NAMESPACE) 15NAMESPACE_BEGIN(detail) 16 17inline PyTypeObject *type_incref(PyTypeObject *type) { 18 Py_INCREF(type); 19 return type; 20} 21 22#if !defined(PYPY_VERSION) 23 24/// `pybind11_static_property.__get__()`: Always pass the class instead of the instance. 25extern "C" inline PyObject *pybind11_static_get(PyObject *self, PyObject * /*ob*/, PyObject *cls) { 26 return PyProperty_Type.tp_descr_get(self, cls, cls); 27} 28 29/// `pybind11_static_property.__set__()`: Just like the above `__get__()`. 30extern "C" inline int pybind11_static_set(PyObject *self, PyObject *obj, PyObject *value) { 31 PyObject *cls = PyType_Check(obj) ? obj : (PyObject *) Py_TYPE(obj); 32 return PyProperty_Type.tp_descr_set(self, cls, value); 33} 34 35/** A `static_property` is the same as a `property` but the `__get__()` and `__set__()` 36 methods are modified to always use the object type instead of a concrete instance. 37 Return value: New reference. */ 38inline PyTypeObject *make_static_property_type() { 39 constexpr auto *name = "pybind11_static_property"; 40 auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name)); 41 42 /* Danger zone: from now (and until PyType_Ready), make sure to 43 issue no Python C API calls which could potentially invoke the 44 garbage collector (the GC will call type_traverse(), which will in 45 turn find the newly constructed type in an invalid state) */ 46 auto heap_type = (PyHeapTypeObject *) PyType_Type.tp_alloc(&PyType_Type, 0); 47 if (!heap_type) 48 pybind11_fail("make_static_property_type(): error allocating type!"); 49 50 heap_type->ht_name = name_obj.inc_ref().ptr(); 51#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3 52 heap_type->ht_qualname = name_obj.inc_ref().ptr(); 53#endif 54 55 auto type = &heap_type->ht_type; 56 type->tp_name = name; 57 type->tp_base = type_incref(&PyProperty_Type); 58 type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE; 59 type->tp_descr_get = pybind11_static_get; 60 type->tp_descr_set = pybind11_static_set; 61 62 if (PyType_Ready(type) < 0) 63 pybind11_fail("make_static_property_type(): failure in PyType_Ready()!"); 64 65 setattr((PyObject *) type, "__module__", str("pybind11_builtins")); 66 67 return type; 68} 69 70#else // PYPY 71 72/** PyPy has some issues with the above C API, so we evaluate Python code instead. 73 This function will only be called once so performance isn't really a concern. 74 Return value: New reference. */ 75inline PyTypeObject *make_static_property_type() { 76 auto d = dict(); 77 PyObject *result = PyRun_String(R"(\ 78 class pybind11_static_property(property): 79 def __get__(self, obj, cls): 80 return property.__get__(self, cls, cls) 81 82 def __set__(self, obj, value): 83 cls = obj if isinstance(obj, type) else type(obj) 84 property.__set__(self, cls, value) 85 )", Py_file_input, d.ptr(), d.ptr() 86 ); 87 if (result == nullptr) 88 throw error_already_set(); 89 Py_DECREF(result); 90 return (PyTypeObject *) d["pybind11_static_property"].cast<object>().release().ptr(); 91} 92 93#endif // PYPY 94 95/** Types with static properties need to handle `Type.static_prop = x` in a specific way. 96 By default, Python replaces the `static_property` itself, but for wrapped C++ types 97 we need to call `static_property.__set__()` in order to propagate the new value to 98 the underlying C++ data structure. */ 99extern "C" inline int pybind11_meta_setattro(PyObject* obj, PyObject* name, PyObject* value) { 100 // Use `_PyType_Lookup()` instead of `PyObject_GetAttr()` in order to get the raw 101 // descriptor (`property`) instead of calling `tp_descr_get` (`property.__get__()`). 102 PyObject *descr = _PyType_Lookup((PyTypeObject *) obj, name); 103 104 // The following assignment combinations are possible: 105 // 1. `Type.static_prop = value` --> descr_set: `Type.static_prop.__set__(value)` 106 // 2. `Type.static_prop = other_static_prop` --> setattro: replace existing `static_prop` 107 // 3. `Type.regular_attribute = value` --> setattro: regular attribute assignment 108 const auto static_prop = (PyObject *) get_internals().static_property_type; 109 const auto call_descr_set = descr && PyObject_IsInstance(descr, static_prop) 110 && !PyObject_IsInstance(value, static_prop); 111 if (call_descr_set) { 112 // Call `static_property.__set__()` instead of replacing the `static_property`. 113#if !defined(PYPY_VERSION) 114 return Py_TYPE(descr)->tp_descr_set(descr, obj, value); 115#else 116 if (PyObject *result = PyObject_CallMethod(descr, "__set__", "OO", obj, value)) { 117 Py_DECREF(result); 118 return 0; 119 } else { 120 return -1; 121 } 122#endif 123 } else { 124 // Replace existing attribute. 125 return PyType_Type.tp_setattro(obj, name, value); 126 } 127} 128 129#if PY_MAJOR_VERSION >= 3 130/** 131 * Python 3's PyInstanceMethod_Type hides itself via its tp_descr_get, which prevents aliasing 132 * methods via cls.attr("m2") = cls.attr("m1"): instead the tp_descr_get returns a plain function, 133 * when called on a class, or a PyMethod, when called on an instance. Override that behaviour here 134 * to do a special case bypass for PyInstanceMethod_Types. 135 */ 136extern "C" inline PyObject *pybind11_meta_getattro(PyObject *obj, PyObject *name) { 137 PyObject *descr = _PyType_Lookup((PyTypeObject *) obj, name); 138 if (descr && PyInstanceMethod_Check(descr)) { 139 Py_INCREF(descr); 140 return descr; 141 } 142 else { 143 return PyType_Type.tp_getattro(obj, name); 144 } 145} 146#endif 147 148/** This metaclass is assigned by default to all pybind11 types and is required in order 149 for static properties to function correctly. Users may override this using `py::metaclass`. 150 Return value: New reference. */ 151inline PyTypeObject* make_default_metaclass() { 152 constexpr auto *name = "pybind11_type"; 153 auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name)); 154 155 /* Danger zone: from now (and until PyType_Ready), make sure to 156 issue no Python C API calls which could potentially invoke the 157 garbage collector (the GC will call type_traverse(), which will in 158 turn find the newly constructed type in an invalid state) */ 159 auto heap_type = (PyHeapTypeObject *) PyType_Type.tp_alloc(&PyType_Type, 0); 160 if (!heap_type) 161 pybind11_fail("make_default_metaclass(): error allocating metaclass!"); 162 163 heap_type->ht_name = name_obj.inc_ref().ptr(); 164#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3 165 heap_type->ht_qualname = name_obj.inc_ref().ptr(); 166#endif 167 168 auto type = &heap_type->ht_type; 169 type->tp_name = name; 170 type->tp_base = type_incref(&PyType_Type); 171 type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE; 172 173 type->tp_setattro = pybind11_meta_setattro; 174#if PY_MAJOR_VERSION >= 3 175 type->tp_getattro = pybind11_meta_getattro; 176#endif 177 178 if (PyType_Ready(type) < 0) 179 pybind11_fail("make_default_metaclass(): failure in PyType_Ready()!"); 180 181 setattr((PyObject *) type, "__module__", str("pybind11_builtins")); 182 183 return type; 184} 185 186/// For multiple inheritance types we need to recursively register/deregister base pointers for any 187/// base classes with pointers that are difference from the instance value pointer so that we can 188/// correctly recognize an offset base class pointer. This calls a function with any offset base ptrs. 189inline void traverse_offset_bases(void *valueptr, const detail::type_info *tinfo, instance *self, 190 bool (*f)(void * /*parentptr*/, instance * /*self*/)) { 191 for (handle h : reinterpret_borrow<tuple>(tinfo->type->tp_bases)) { 192 if (auto parent_tinfo = get_type_info((PyTypeObject *) h.ptr())) { 193 for (auto &c : parent_tinfo->implicit_casts) { 194 if (c.first == tinfo->cpptype) { 195 auto *parentptr = c.second(valueptr); 196 if (parentptr != valueptr) 197 f(parentptr, self); 198 traverse_offset_bases(parentptr, parent_tinfo, self, f); 199 break; 200 } 201 } 202 } 203 } 204} 205 206inline bool register_instance_impl(void *ptr, instance *self) { 207 get_internals().registered_instances.emplace(ptr, self); 208 return true; // unused, but gives the same signature as the deregister func 209} 210inline bool deregister_instance_impl(void *ptr, instance *self) { 211 auto ®istered_instances = get_internals().registered_instances; 212 auto range = registered_instances.equal_range(ptr); 213 for (auto it = range.first; it != range.second; ++it) { 214 if (Py_TYPE(self) == Py_TYPE(it->second)) { 215 registered_instances.erase(it); 216 return true; 217 } 218 } 219 return false; 220} 221 222inline void register_instance(instance *self, void *valptr, const type_info *tinfo) { 223 register_instance_impl(valptr, self); 224 if (!tinfo->simple_ancestors) 225 traverse_offset_bases(valptr, tinfo, self, register_instance_impl); 226} 227 228inline bool deregister_instance(instance *self, void *valptr, const type_info *tinfo) { 229 bool ret = deregister_instance_impl(valptr, self); 230 if (!tinfo->simple_ancestors) 231 traverse_offset_bases(valptr, tinfo, self, deregister_instance_impl); 232 return ret; 233} 234 235/// Instance creation function for all pybind11 types. It allocates the internal instance layout for 236/// holding C++ objects and holders. Allocation is done lazily (the first time the instance is cast 237/// to a reference or pointer), and initialization is done by an `__init__` function. 238inline PyObject *make_new_instance(PyTypeObject *type) { 239#if defined(PYPY_VERSION) 240 // PyPy gets tp_basicsize wrong (issue 2482) under multiple inheritance when the first inherited 241 // object is a a plain Python type (i.e. not derived from an extension type). Fix it. 242 ssize_t instance_size = static_cast<ssize_t>(sizeof(instance)); 243 if (type->tp_basicsize < instance_size) { 244 type->tp_basicsize = instance_size; 245 } 246#endif 247 PyObject *self = type->tp_alloc(type, 0); 248 auto inst = reinterpret_cast<instance *>(self); 249 // Allocate the value/holder internals: 250 inst->allocate_layout(); 251 252 inst->owned = true; 253 254 return self; 255} 256 257/// Instance creation function for all pybind11 types. It only allocates space for the 258/// C++ object, but doesn't call the constructor -- an `__init__` function must do that. 259extern "C" inline PyObject *pybind11_object_new(PyTypeObject *type, PyObject *, PyObject *) { 260 return make_new_instance(type); 261} 262 263/// An `__init__` function constructs the C++ object. Users should provide at least one 264/// of these using `py::init` or directly with `.def(__init__, ...)`. Otherwise, the 265/// following default function will be used which simply throws an exception. 266extern "C" inline int pybind11_object_init(PyObject *self, PyObject *, PyObject *) { 267 PyTypeObject *type = Py_TYPE(self); 268 std::string msg; 269#if defined(PYPY_VERSION) 270 msg += handle((PyObject *) type).attr("__module__").cast<std::string>() + "."; 271#endif 272 msg += type->tp_name; 273 msg += ": No constructor defined!"; 274 PyErr_SetString(PyExc_TypeError, msg.c_str()); 275 return -1; 276} 277 278inline void add_patient(PyObject *nurse, PyObject *patient) { 279 auto &internals = get_internals(); 280 auto instance = reinterpret_cast<detail::instance *>(nurse); 281 instance->has_patients = true; 282 Py_INCREF(patient); 283 internals.patients[nurse].push_back(patient); 284} 285 286inline void clear_patients(PyObject *self) { 287 auto instance = reinterpret_cast<detail::instance *>(self); 288 auto &internals = get_internals(); 289 auto pos = internals.patients.find(self); 290 assert(pos != internals.patients.end()); 291 // Clearing the patients can cause more Python code to run, which 292 // can invalidate the iterator. Extract the vector of patients 293 // from the unordered_map first. 294 auto patients = std::move(pos->second); 295 internals.patients.erase(pos); 296 instance->has_patients = false; 297 for (PyObject *&patient : patients) 298 Py_CLEAR(patient); 299} 300 301/// Clears all internal data from the instance and removes it from registered instances in 302/// preparation for deallocation. 303inline void clear_instance(PyObject *self) { 304 auto instance = reinterpret_cast<detail::instance *>(self); 305 306 // Deallocate any values/holders, if present: 307 for (auto &v_h : values_and_holders(instance)) { 308 if (v_h) { 309 310 // We have to deregister before we call dealloc because, for virtual MI types, we still 311 // need to be able to get the parent pointers. 312 if (v_h.instance_registered() && !deregister_instance(instance, v_h.value_ptr(), v_h.type)) 313 pybind11_fail("pybind11_object_dealloc(): Tried to deallocate unregistered instance!"); 314 315 if (instance->owned || v_h.holder_constructed()) 316 v_h.type->dealloc(v_h); 317 } 318 } 319 // Deallocate the value/holder layout internals: 320 instance->deallocate_layout(); 321 322 if (instance->weakrefs) 323 PyObject_ClearWeakRefs(self); 324 325 PyObject **dict_ptr = _PyObject_GetDictPtr(self); 326 if (dict_ptr) 327 Py_CLEAR(*dict_ptr); 328 329 if (instance->has_patients) 330 clear_patients(self); 331} 332 333/// Instance destructor function for all pybind11 types. It calls `type_info.dealloc` 334/// to destroy the C++ object itself, while the rest is Python bookkeeping. 335extern "C" inline void pybind11_object_dealloc(PyObject *self) { 336 clear_instance(self); 337 338 auto type = Py_TYPE(self); 339 type->tp_free(self); 340 341 // `type->tp_dealloc != pybind11_object_dealloc` means that we're being called 342 // as part of a derived type's dealloc, in which case we're not allowed to decref 343 // the type here. For cross-module compatibility, we shouldn't compare directly 344 // with `pybind11_object_dealloc`, but with the common one stashed in internals. 345 auto pybind11_object_type = (PyTypeObject *) get_internals().instance_base; 346 if (type->tp_dealloc == pybind11_object_type->tp_dealloc) 347 Py_DECREF(type); 348} 349 350/** Create the type which can be used as a common base for all classes. This is 351 needed in order to satisfy Python's requirements for multiple inheritance. 352 Return value: New reference. */ 353inline PyObject *make_object_base_type(PyTypeObject *metaclass) { 354 constexpr auto *name = "pybind11_object"; 355 auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name)); 356 357 /* Danger zone: from now (and until PyType_Ready), make sure to 358 issue no Python C API calls which could potentially invoke the 359 garbage collector (the GC will call type_traverse(), which will in 360 turn find the newly constructed type in an invalid state) */ 361 auto heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0); 362 if (!heap_type) 363 pybind11_fail("make_object_base_type(): error allocating type!"); 364 365 heap_type->ht_name = name_obj.inc_ref().ptr(); 366#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3 367 heap_type->ht_qualname = name_obj.inc_ref().ptr(); 368#endif 369 370 auto type = &heap_type->ht_type; 371 type->tp_name = name; 372 type->tp_base = type_incref(&PyBaseObject_Type); 373 type->tp_basicsize = static_cast<ssize_t>(sizeof(instance)); 374 type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE; 375 376 type->tp_new = pybind11_object_new; 377 type->tp_init = pybind11_object_init; 378 type->tp_dealloc = pybind11_object_dealloc; 379 380 /* Support weak references (needed for the keep_alive feature) */ 381 type->tp_weaklistoffset = offsetof(instance, weakrefs); 382 383 if (PyType_Ready(type) < 0) 384 pybind11_fail("PyType_Ready failed in make_object_base_type():" + error_string()); 385 386 setattr((PyObject *) type, "__module__", str("pybind11_builtins")); 387 388 assert(!PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC)); 389 return (PyObject *) heap_type; 390} 391 392/// dynamic_attr: Support for `d = instance.__dict__`. 393extern "C" inline PyObject *pybind11_get_dict(PyObject *self, void *) { 394 PyObject *&dict = *_PyObject_GetDictPtr(self); 395 if (!dict) 396 dict = PyDict_New(); 397 Py_XINCREF(dict); 398 return dict; 399} 400 401/// dynamic_attr: Support for `instance.__dict__ = dict()`. 402extern "C" inline int pybind11_set_dict(PyObject *self, PyObject *new_dict, void *) { 403 if (!PyDict_Check(new_dict)) { 404 PyErr_Format(PyExc_TypeError, "__dict__ must be set to a dictionary, not a '%.200s'", 405 Py_TYPE(new_dict)->tp_name); 406 return -1; 407 } 408 PyObject *&dict = *_PyObject_GetDictPtr(self); 409 Py_INCREF(new_dict); 410 Py_CLEAR(dict); 411 dict = new_dict; 412 return 0; 413} 414 415/// dynamic_attr: Allow the garbage collector to traverse the internal instance `__dict__`. 416extern "C" inline int pybind11_traverse(PyObject *self, visitproc visit, void *arg) { 417 PyObject *&dict = *_PyObject_GetDictPtr(self); 418 Py_VISIT(dict); 419 return 0; 420} 421 422/// dynamic_attr: Allow the GC to clear the dictionary. 423extern "C" inline int pybind11_clear(PyObject *self) { 424 PyObject *&dict = *_PyObject_GetDictPtr(self); 425 Py_CLEAR(dict); 426 return 0; 427} 428 429/// Give instances of this type a `__dict__` and opt into garbage collection. 430inline void enable_dynamic_attributes(PyHeapTypeObject *heap_type) { 431 auto type = &heap_type->ht_type; 432#if defined(PYPY_VERSION) 433 pybind11_fail(std::string(type->tp_name) + ": dynamic attributes are " 434 "currently not supported in " 435 "conjunction with PyPy!"); 436#endif 437 type->tp_flags |= Py_TPFLAGS_HAVE_GC; 438 type->tp_dictoffset = type->tp_basicsize; // place dict at the end 439 type->tp_basicsize += (ssize_t)sizeof(PyObject *); // and allocate enough space for it 440 type->tp_traverse = pybind11_traverse; 441 type->tp_clear = pybind11_clear; 442 443 static PyGetSetDef getset[] = { 444 {const_cast<char*>("__dict__"), pybind11_get_dict, pybind11_set_dict, nullptr, nullptr}, 445 {nullptr, nullptr, nullptr, nullptr, nullptr} 446 }; 447 type->tp_getset = getset; 448} 449 450/// buffer_protocol: Fill in the view as specified by flags. 451extern "C" inline int pybind11_getbuffer(PyObject *obj, Py_buffer *view, int flags) { 452 // Look for a `get_buffer` implementation in this type's info or any bases (following MRO). 453 type_info *tinfo = nullptr; 454 for (auto type : reinterpret_borrow<tuple>(Py_TYPE(obj)->tp_mro)) { 455 tinfo = get_type_info((PyTypeObject *) type.ptr()); 456 if (tinfo && tinfo->get_buffer) 457 break; 458 } 459 if (view == nullptr || obj == nullptr || !tinfo || !tinfo->get_buffer) { 460 if (view) 461 view->obj = nullptr; 462 PyErr_SetString(PyExc_BufferError, "pybind11_getbuffer(): Internal error"); 463 return -1; 464 } 465 std::memset(view, 0, sizeof(Py_buffer)); 466 buffer_info *info = tinfo->get_buffer(obj, tinfo->get_buffer_data); 467 view->obj = obj; 468 view->ndim = 1; 469 view->internal = info; 470 view->buf = info->ptr; 471 view->itemsize = info->itemsize; 472 view->len = view->itemsize; 473 for (auto s : info->shape) 474 view->len *= s; 475 if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) 476 view->format = const_cast<char *>(info->format.c_str()); 477 if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) { 478 view->ndim = (int) info->ndim; 479 view->strides = &info->strides[0]; 480 view->shape = &info->shape[0]; 481 } 482 Py_INCREF(view->obj); 483 return 0; 484} 485 486/// buffer_protocol: Release the resources of the buffer. 487extern "C" inline void pybind11_releasebuffer(PyObject *, Py_buffer *view) { 488 delete (buffer_info *) view->internal; 489} 490 491/// Give this type a buffer interface. 492inline void enable_buffer_protocol(PyHeapTypeObject *heap_type) { 493 heap_type->ht_type.tp_as_buffer = &heap_type->as_buffer; 494#if PY_MAJOR_VERSION < 3 495 heap_type->ht_type.tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER; 496#endif 497 498 heap_type->as_buffer.bf_getbuffer = pybind11_getbuffer; 499 heap_type->as_buffer.bf_releasebuffer = pybind11_releasebuffer; 500} 501 502/** Create a brand new Python type according to the `type_record` specification. 503 Return value: New reference. */ 504inline PyObject* make_new_python_type(const type_record &rec) { 505 auto name = reinterpret_steal<object>(PYBIND11_FROM_STRING(rec.name)); 506 507#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3 508 auto ht_qualname = name; 509 if (rec.scope && hasattr(rec.scope, "__qualname__")) { 510 ht_qualname = reinterpret_steal<object>( 511 PyUnicode_FromFormat("%U.%U", rec.scope.attr("__qualname__").ptr(), name.ptr())); 512 } 513#endif 514 515 object module; 516 if (rec.scope) { 517 if (hasattr(rec.scope, "__module__")) 518 module = rec.scope.attr("__module__"); 519 else if (hasattr(rec.scope, "__name__")) 520 module = rec.scope.attr("__name__"); 521 } 522 523 auto full_name = c_str( 524#if !defined(PYPY_VERSION) 525 module ? str(module).cast<std::string>() + "." + rec.name : 526#endif 527 rec.name); 528 529 char *tp_doc = nullptr; 530 if (rec.doc && options::show_user_defined_docstrings()) { 531 /* Allocate memory for docstring (using PyObject_MALLOC, since 532 Python will free this later on) */ 533 size_t size = strlen(rec.doc) + 1; 534 tp_doc = (char *) PyObject_MALLOC(size); 535 memcpy((void *) tp_doc, rec.doc, size); 536 } 537 538 auto &internals = get_internals(); 539 auto bases = tuple(rec.bases); 540 auto base = (bases.size() == 0) ? internals.instance_base 541 : bases[0].ptr(); 542 543 /* Danger zone: from now (and until PyType_Ready), make sure to 544 issue no Python C API calls which could potentially invoke the 545 garbage collector (the GC will call type_traverse(), which will in 546 turn find the newly constructed type in an invalid state) */ 547 auto metaclass = rec.metaclass.ptr() ? (PyTypeObject *) rec.metaclass.ptr() 548 : internals.default_metaclass; 549 550 auto heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0); 551 if (!heap_type) 552 pybind11_fail(std::string(rec.name) + ": Unable to create type object!"); 553 554 heap_type->ht_name = name.release().ptr(); 555#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3 556 heap_type->ht_qualname = ht_qualname.release().ptr(); 557#endif 558 559 auto type = &heap_type->ht_type; 560 type->tp_name = full_name; 561 type->tp_doc = tp_doc; 562 type->tp_base = type_incref((PyTypeObject *)base); 563 type->tp_basicsize = static_cast<ssize_t>(sizeof(instance)); 564 if (bases.size() > 0) 565 type->tp_bases = bases.release().ptr(); 566 567 /* Don't inherit base __init__ */ 568 type->tp_init = pybind11_object_init; 569 570 /* Supported protocols */ 571 type->tp_as_number = &heap_type->as_number; 572 type->tp_as_sequence = &heap_type->as_sequence; 573 type->tp_as_mapping = &heap_type->as_mapping; 574 575 /* Flags */ 576 type->tp_flags |= Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE; 577#if PY_MAJOR_VERSION < 3 578 type->tp_flags |= Py_TPFLAGS_CHECKTYPES; 579#endif 580 581 if (rec.dynamic_attr) 582 enable_dynamic_attributes(heap_type); 583 584 if (rec.buffer_protocol) 585 enable_buffer_protocol(heap_type); 586 587 if (PyType_Ready(type) < 0) 588 pybind11_fail(std::string(rec.name) + ": PyType_Ready failed (" + error_string() + ")!"); 589 590 assert(rec.dynamic_attr ? PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC) 591 : !PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC)); 592 593 /* Register type with the parent scope */ 594 if (rec.scope) 595 setattr(rec.scope, rec.name, (PyObject *) type); 596 else 597 Py_INCREF(type); // Keep it alive forever (reference leak) 598 599 if (module) // Needed by pydoc 600 setattr((PyObject *) type, "__module__", module); 601 602 return (PyObject *) type; 603} 604 605NAMESPACE_END(detail) 606NAMESPACE_END(PYBIND11_NAMESPACE) 607