pybind11.h revision 12391
111986Sandreas.sandberg@arm.com/* 211986Sandreas.sandberg@arm.com pybind11/pybind11.h: Main header file of the C++11 python 311986Sandreas.sandberg@arm.com binding generator library 411986Sandreas.sandberg@arm.com 511986Sandreas.sandberg@arm.com Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch> 611986Sandreas.sandberg@arm.com 711986Sandreas.sandberg@arm.com All rights reserved. Use of this source code is governed by a 811986Sandreas.sandberg@arm.com BSD-style license that can be found in the LICENSE file. 911986Sandreas.sandberg@arm.com*/ 1011986Sandreas.sandberg@arm.com 1111986Sandreas.sandberg@arm.com#pragma once 1211986Sandreas.sandberg@arm.com 1311986Sandreas.sandberg@arm.com#if defined(_MSC_VER) 1411986Sandreas.sandberg@arm.com# pragma warning(push) 1511986Sandreas.sandberg@arm.com# pragma warning(disable: 4100) // warning C4100: Unreferenced formal parameter 1611986Sandreas.sandberg@arm.com# pragma warning(disable: 4127) // warning C4127: Conditional expression is constant 1711986Sandreas.sandberg@arm.com# pragma warning(disable: 4512) // warning C4512: Assignment operator was implicitly defined as deleted 1811986Sandreas.sandberg@arm.com# pragma warning(disable: 4800) // warning C4800: 'int': forcing value to bool 'true' or 'false' (performance warning) 1911986Sandreas.sandberg@arm.com# pragma warning(disable: 4996) // warning C4996: The POSIX name for this item is deprecated. Instead, use the ISO C and C++ conformant name 2011986Sandreas.sandberg@arm.com# pragma warning(disable: 4702) // warning C4702: unreachable code 2111986Sandreas.sandberg@arm.com# pragma warning(disable: 4522) // warning C4522: multiple assignment operators specified 2211986Sandreas.sandberg@arm.com#elif defined(__INTEL_COMPILER) 2311986Sandreas.sandberg@arm.com# pragma warning(push) 2412391Sjason@lowepower.com# pragma warning(disable: 68) // integer conversion resulted in a change of sign 2511986Sandreas.sandberg@arm.com# pragma warning(disable: 186) // pointless comparison of unsigned integer with zero 2612391Sjason@lowepower.com# pragma warning(disable: 878) // incompatible exception specifications 2711986Sandreas.sandberg@arm.com# pragma warning(disable: 1334) // the "template" keyword used for syntactic disambiguation may only be used within a template 2812391Sjason@lowepower.com# pragma warning(disable: 1682) // implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem) 2912391Sjason@lowepower.com# pragma warning(disable: 1875) // offsetof applied to non-POD (Plain Old Data) types is nonstandard 3011986Sandreas.sandberg@arm.com# pragma warning(disable: 2196) // warning #2196: routine is both "inline" and "noinline" 3111986Sandreas.sandberg@arm.com#elif defined(__GNUG__) && !defined(__clang__) 3211986Sandreas.sandberg@arm.com# pragma GCC diagnostic push 3311986Sandreas.sandberg@arm.com# pragma GCC diagnostic ignored "-Wunused-but-set-parameter" 3411986Sandreas.sandberg@arm.com# pragma GCC diagnostic ignored "-Wunused-but-set-variable" 3511986Sandreas.sandberg@arm.com# pragma GCC diagnostic ignored "-Wmissing-field-initializers" 3611986Sandreas.sandberg@arm.com# pragma GCC diagnostic ignored "-Wstrict-aliasing" 3711986Sandreas.sandberg@arm.com# pragma GCC diagnostic ignored "-Wattributes" 3812391Sjason@lowepower.com# if __GNUC__ >= 7 3912391Sjason@lowepower.com# pragma GCC diagnostic ignored "-Wnoexcept-type" 4012391Sjason@lowepower.com# endif 4111986Sandreas.sandberg@arm.com#endif 4211986Sandreas.sandberg@arm.com 4311986Sandreas.sandberg@arm.com#include "attr.h" 4411986Sandreas.sandberg@arm.com#include "options.h" 4512391Sjason@lowepower.com#include "detail/class.h" 4612391Sjason@lowepower.com#include "detail/init.h" 4711986Sandreas.sandberg@arm.com 4812391Sjason@lowepower.comNAMESPACE_BEGIN(PYBIND11_NAMESPACE) 4911986Sandreas.sandberg@arm.com 5011986Sandreas.sandberg@arm.com/// Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object 5111986Sandreas.sandberg@arm.comclass cpp_function : public function { 5211986Sandreas.sandberg@arm.compublic: 5311986Sandreas.sandberg@arm.com cpp_function() { } 5411986Sandreas.sandberg@arm.com 5511986Sandreas.sandberg@arm.com /// Construct a cpp_function from a vanilla function pointer 5611986Sandreas.sandberg@arm.com template <typename Return, typename... Args, typename... Extra> 5711986Sandreas.sandberg@arm.com cpp_function(Return (*f)(Args...), const Extra&... extra) { 5811986Sandreas.sandberg@arm.com initialize(f, f, extra...); 5911986Sandreas.sandberg@arm.com } 6011986Sandreas.sandberg@arm.com 6111986Sandreas.sandberg@arm.com /// Construct a cpp_function from a lambda function (possibly with internal state) 6212391Sjason@lowepower.com template <typename Func, typename... Extra, 6312391Sjason@lowepower.com typename = detail::enable_if_t<detail::is_lambda<Func>::value>> 6412037Sandreas.sandberg@arm.com cpp_function(Func &&f, const Extra&... extra) { 6511986Sandreas.sandberg@arm.com initialize(std::forward<Func>(f), 6612391Sjason@lowepower.com (detail::function_signature_t<Func> *) nullptr, extra...); 6711986Sandreas.sandberg@arm.com } 6811986Sandreas.sandberg@arm.com 6911986Sandreas.sandberg@arm.com /// Construct a cpp_function from a class method (non-const) 7011986Sandreas.sandberg@arm.com template <typename Return, typename Class, typename... Arg, typename... Extra> 7111986Sandreas.sandberg@arm.com cpp_function(Return (Class::*f)(Arg...), const Extra&... extra) { 7211986Sandreas.sandberg@arm.com initialize([f](Class *c, Arg... args) -> Return { return (c->*f)(args...); }, 7311986Sandreas.sandberg@arm.com (Return (*) (Class *, Arg...)) nullptr, extra...); 7411986Sandreas.sandberg@arm.com } 7511986Sandreas.sandberg@arm.com 7611986Sandreas.sandberg@arm.com /// Construct a cpp_function from a class method (const) 7711986Sandreas.sandberg@arm.com template <typename Return, typename Class, typename... Arg, typename... Extra> 7811986Sandreas.sandberg@arm.com cpp_function(Return (Class::*f)(Arg...) const, const Extra&... extra) { 7911986Sandreas.sandberg@arm.com initialize([f](const Class *c, Arg... args) -> Return { return (c->*f)(args...); }, 8011986Sandreas.sandberg@arm.com (Return (*)(const Class *, Arg ...)) nullptr, extra...); 8111986Sandreas.sandberg@arm.com } 8211986Sandreas.sandberg@arm.com 8311986Sandreas.sandberg@arm.com /// Return the function name 8411986Sandreas.sandberg@arm.com object name() const { return attr("__name__"); } 8511986Sandreas.sandberg@arm.com 8611986Sandreas.sandberg@arm.comprotected: 8711986Sandreas.sandberg@arm.com /// Space optimization: don't inline this frequently instantiated fragment 8811986Sandreas.sandberg@arm.com PYBIND11_NOINLINE detail::function_record *make_function_record() { 8911986Sandreas.sandberg@arm.com return new detail::function_record(); 9011986Sandreas.sandberg@arm.com } 9111986Sandreas.sandberg@arm.com 9211986Sandreas.sandberg@arm.com /// Special internal constructor for functors, lambda functions, etc. 9311986Sandreas.sandberg@arm.com template <typename Func, typename Return, typename... Args, typename... Extra> 9411986Sandreas.sandberg@arm.com void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) { 9511986Sandreas.sandberg@arm.com 9612391Sjason@lowepower.com struct capture { detail::remove_reference_t<Func> f; }; 9711986Sandreas.sandberg@arm.com 9811986Sandreas.sandberg@arm.com /* Store the function including any extra state it might have (e.g. a lambda capture object) */ 9911986Sandreas.sandberg@arm.com auto rec = make_function_record(); 10011986Sandreas.sandberg@arm.com 10111986Sandreas.sandberg@arm.com /* Store the capture object directly in the function record if there is enough space */ 10211986Sandreas.sandberg@arm.com if (sizeof(capture) <= sizeof(rec->data)) { 10311986Sandreas.sandberg@arm.com /* Without these pragmas, GCC warns that there might not be 10411986Sandreas.sandberg@arm.com enough space to use the placement new operator. However, the 10511986Sandreas.sandberg@arm.com 'if' statement above ensures that this is the case. */ 10611986Sandreas.sandberg@arm.com#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6 10711986Sandreas.sandberg@arm.com# pragma GCC diagnostic push 10811986Sandreas.sandberg@arm.com# pragma GCC diagnostic ignored "-Wplacement-new" 10911986Sandreas.sandberg@arm.com#endif 11011986Sandreas.sandberg@arm.com new ((capture *) &rec->data) capture { std::forward<Func>(f) }; 11111986Sandreas.sandberg@arm.com#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6 11211986Sandreas.sandberg@arm.com# pragma GCC diagnostic pop 11311986Sandreas.sandberg@arm.com#endif 11411986Sandreas.sandberg@arm.com if (!std::is_trivially_destructible<Func>::value) 11511986Sandreas.sandberg@arm.com rec->free_data = [](detail::function_record *r) { ((capture *) &r->data)->~capture(); }; 11611986Sandreas.sandberg@arm.com } else { 11711986Sandreas.sandberg@arm.com rec->data[0] = new capture { std::forward<Func>(f) }; 11811986Sandreas.sandberg@arm.com rec->free_data = [](detail::function_record *r) { delete ((capture *) r->data[0]); }; 11911986Sandreas.sandberg@arm.com } 12011986Sandreas.sandberg@arm.com 12111986Sandreas.sandberg@arm.com /* Type casters for the function arguments and return value */ 12211986Sandreas.sandberg@arm.com using cast_in = detail::argument_loader<Args...>; 12311986Sandreas.sandberg@arm.com using cast_out = detail::make_caster< 12411986Sandreas.sandberg@arm.com detail::conditional_t<std::is_void<Return>::value, detail::void_type, Return> 12511986Sandreas.sandberg@arm.com >; 12611986Sandreas.sandberg@arm.com 12712037Sandreas.sandberg@arm.com static_assert(detail::expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs), 12812037Sandreas.sandberg@arm.com "The number of argument annotations does not match the number of function arguments"); 12912037Sandreas.sandberg@arm.com 13011986Sandreas.sandberg@arm.com /* Dispatch code which converts function arguments and performs the actual function call */ 13112037Sandreas.sandberg@arm.com rec->impl = [](detail::function_call &call) -> handle { 13211986Sandreas.sandberg@arm.com cast_in args_converter; 13311986Sandreas.sandberg@arm.com 13411986Sandreas.sandberg@arm.com /* Try to cast the function arguments into the C++ domain */ 13512037Sandreas.sandberg@arm.com if (!args_converter.load_args(call)) 13611986Sandreas.sandberg@arm.com return PYBIND11_TRY_NEXT_OVERLOAD; 13711986Sandreas.sandberg@arm.com 13811986Sandreas.sandberg@arm.com /* Invoke call policy pre-call hook */ 13912037Sandreas.sandberg@arm.com detail::process_attributes<Extra...>::precall(call); 14011986Sandreas.sandberg@arm.com 14111986Sandreas.sandberg@arm.com /* Get a pointer to the capture object */ 14212037Sandreas.sandberg@arm.com auto data = (sizeof(capture) <= sizeof(call.func.data) 14312037Sandreas.sandberg@arm.com ? &call.func.data : call.func.data[0]); 14412037Sandreas.sandberg@arm.com capture *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data)); 14511986Sandreas.sandberg@arm.com 14612037Sandreas.sandberg@arm.com /* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */ 14712037Sandreas.sandberg@arm.com const auto policy = detail::return_value_policy_override<Return>::policy(call.func.policy); 14811986Sandreas.sandberg@arm.com 14912391Sjason@lowepower.com /* Function scope guard -- defaults to the compile-to-nothing `void_type` */ 15012391Sjason@lowepower.com using Guard = detail::extract_guard_t<Extra...>; 15112391Sjason@lowepower.com 15211986Sandreas.sandberg@arm.com /* Perform the function call */ 15312391Sjason@lowepower.com handle result = cast_out::cast( 15412391Sjason@lowepower.com std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent); 15511986Sandreas.sandberg@arm.com 15611986Sandreas.sandberg@arm.com /* Invoke call policy post-call hook */ 15712037Sandreas.sandberg@arm.com detail::process_attributes<Extra...>::postcall(call, result); 15811986Sandreas.sandberg@arm.com 15911986Sandreas.sandberg@arm.com return result; 16011986Sandreas.sandberg@arm.com }; 16111986Sandreas.sandberg@arm.com 16211986Sandreas.sandberg@arm.com /* Process any user-provided function attributes */ 16311986Sandreas.sandberg@arm.com detail::process_attributes<Extra...>::init(extra..., rec); 16411986Sandreas.sandberg@arm.com 16511986Sandreas.sandberg@arm.com /* Generate a readable signature describing the function's arguments and return value types */ 16611986Sandreas.sandberg@arm.com using detail::descr; using detail::_; 16711986Sandreas.sandberg@arm.com PYBIND11_DESCR signature = _("(") + cast_in::arg_names() + _(") -> ") + cast_out::name(); 16811986Sandreas.sandberg@arm.com 16911986Sandreas.sandberg@arm.com /* Register the function with Python from generic (non-templated) code */ 17011986Sandreas.sandberg@arm.com initialize_generic(rec, signature.text(), signature.types(), sizeof...(Args)); 17111986Sandreas.sandberg@arm.com 17211986Sandreas.sandberg@arm.com if (cast_in::has_args) rec->has_args = true; 17311986Sandreas.sandberg@arm.com if (cast_in::has_kwargs) rec->has_kwargs = true; 17411986Sandreas.sandberg@arm.com 17511986Sandreas.sandberg@arm.com /* Stash some additional information used by an important optimization in 'functional.h' */ 17611986Sandreas.sandberg@arm.com using FunctionType = Return (*)(Args...); 17711986Sandreas.sandberg@arm.com constexpr bool is_function_ptr = 17811986Sandreas.sandberg@arm.com std::is_convertible<Func, FunctionType>::value && 17911986Sandreas.sandberg@arm.com sizeof(capture) == sizeof(void *); 18011986Sandreas.sandberg@arm.com if (is_function_ptr) { 18111986Sandreas.sandberg@arm.com rec->is_stateless = true; 18212037Sandreas.sandberg@arm.com rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType))); 18311986Sandreas.sandberg@arm.com } 18411986Sandreas.sandberg@arm.com } 18511986Sandreas.sandberg@arm.com 18611986Sandreas.sandberg@arm.com /// Register a function call with Python (generic non-templated code goes here) 18711986Sandreas.sandberg@arm.com void initialize_generic(detail::function_record *rec, const char *text, 18811986Sandreas.sandberg@arm.com const std::type_info *const *types, size_t args) { 18911986Sandreas.sandberg@arm.com 19011986Sandreas.sandberg@arm.com /* Create copies of all referenced C-style strings */ 19111986Sandreas.sandberg@arm.com rec->name = strdup(rec->name ? rec->name : ""); 19211986Sandreas.sandberg@arm.com if (rec->doc) rec->doc = strdup(rec->doc); 19311986Sandreas.sandberg@arm.com for (auto &a: rec->args) { 19411986Sandreas.sandberg@arm.com if (a.name) 19511986Sandreas.sandberg@arm.com a.name = strdup(a.name); 19611986Sandreas.sandberg@arm.com if (a.descr) 19711986Sandreas.sandberg@arm.com a.descr = strdup(a.descr); 19811986Sandreas.sandberg@arm.com else if (a.value) 19911986Sandreas.sandberg@arm.com a.descr = strdup(a.value.attr("__repr__")().cast<std::string>().c_str()); 20011986Sandreas.sandberg@arm.com } 20111986Sandreas.sandberg@arm.com 20212391Sjason@lowepower.com rec->is_constructor = !strcmp(rec->name, "__init__") || !strcmp(rec->name, "__setstate__"); 20312391Sjason@lowepower.com 20412391Sjason@lowepower.com#if !defined(NDEBUG) && !defined(PYBIND11_DISABLE_NEW_STYLE_INIT_WARNING) 20512391Sjason@lowepower.com if (rec->is_constructor && !rec->is_new_style_constructor) { 20612391Sjason@lowepower.com const auto class_name = std::string(((PyTypeObject *) rec->scope.ptr())->tp_name); 20712391Sjason@lowepower.com const auto func_name = std::string(rec->name); 20812391Sjason@lowepower.com PyErr_WarnEx( 20912391Sjason@lowepower.com PyExc_FutureWarning, 21012391Sjason@lowepower.com ("pybind11-bound class '" + class_name + "' is using an old-style " 21112391Sjason@lowepower.com "placement-new '" + func_name + "' which has been deprecated. See " 21212391Sjason@lowepower.com "the upgrade guide in pybind11's docs. This message is only visible " 21312391Sjason@lowepower.com "when compiled in debug mode.").c_str(), 0 21412391Sjason@lowepower.com ); 21512391Sjason@lowepower.com } 21612391Sjason@lowepower.com#endif 21712391Sjason@lowepower.com 21811986Sandreas.sandberg@arm.com /* Generate a proper function signature */ 21911986Sandreas.sandberg@arm.com std::string signature; 22011986Sandreas.sandberg@arm.com size_t type_depth = 0, char_index = 0, type_index = 0, arg_index = 0; 22111986Sandreas.sandberg@arm.com while (true) { 22211986Sandreas.sandberg@arm.com char c = text[char_index++]; 22311986Sandreas.sandberg@arm.com if (c == '\0') 22411986Sandreas.sandberg@arm.com break; 22511986Sandreas.sandberg@arm.com 22611986Sandreas.sandberg@arm.com if (c == '{') { 22711986Sandreas.sandberg@arm.com // Write arg name for everything except *args, **kwargs and return type. 22811986Sandreas.sandberg@arm.com if (type_depth == 0 && text[char_index] != '*' && arg_index < args) { 22912037Sandreas.sandberg@arm.com if (!rec->args.empty() && rec->args[arg_index].name) { 23011986Sandreas.sandberg@arm.com signature += rec->args[arg_index].name; 23111986Sandreas.sandberg@arm.com } else if (arg_index == 0 && rec->is_method) { 23211986Sandreas.sandberg@arm.com signature += "self"; 23311986Sandreas.sandberg@arm.com } else { 23411986Sandreas.sandberg@arm.com signature += "arg" + std::to_string(arg_index - (rec->is_method ? 1 : 0)); 23511986Sandreas.sandberg@arm.com } 23611986Sandreas.sandberg@arm.com signature += ": "; 23711986Sandreas.sandberg@arm.com } 23811986Sandreas.sandberg@arm.com ++type_depth; 23911986Sandreas.sandberg@arm.com } else if (c == '}') { 24011986Sandreas.sandberg@arm.com --type_depth; 24111986Sandreas.sandberg@arm.com if (type_depth == 0) { 24211986Sandreas.sandberg@arm.com if (arg_index < rec->args.size() && rec->args[arg_index].descr) { 24311986Sandreas.sandberg@arm.com signature += "="; 24411986Sandreas.sandberg@arm.com signature += rec->args[arg_index].descr; 24511986Sandreas.sandberg@arm.com } 24611986Sandreas.sandberg@arm.com arg_index++; 24711986Sandreas.sandberg@arm.com } 24811986Sandreas.sandberg@arm.com } else if (c == '%') { 24911986Sandreas.sandberg@arm.com const std::type_info *t = types[type_index++]; 25011986Sandreas.sandberg@arm.com if (!t) 25111986Sandreas.sandberg@arm.com pybind11_fail("Internal error while parsing type signature (1)"); 25211986Sandreas.sandberg@arm.com if (auto tinfo = detail::get_type_info(*t)) { 25312037Sandreas.sandberg@arm.com#if defined(PYPY_VERSION) 25412037Sandreas.sandberg@arm.com signature += handle((PyObject *) tinfo->type) 25512037Sandreas.sandberg@arm.com .attr("__module__") 25612037Sandreas.sandberg@arm.com .cast<std::string>() + "."; 25712037Sandreas.sandberg@arm.com#endif 25811986Sandreas.sandberg@arm.com signature += tinfo->type->tp_name; 25912391Sjason@lowepower.com } else if (rec->is_new_style_constructor && arg_index == 0) { 26012391Sjason@lowepower.com // A new-style `__init__` takes `self` as `value_and_holder`. 26112391Sjason@lowepower.com // Rewrite it to the proper class type. 26212391Sjason@lowepower.com#if defined(PYPY_VERSION) 26312391Sjason@lowepower.com signature += rec->scope.attr("__module__").cast<std::string>() + "."; 26412391Sjason@lowepower.com#endif 26512391Sjason@lowepower.com signature += ((PyTypeObject *) rec->scope.ptr())->tp_name; 26611986Sandreas.sandberg@arm.com } else { 26711986Sandreas.sandberg@arm.com std::string tname(t->name()); 26811986Sandreas.sandberg@arm.com detail::clean_type_id(tname); 26911986Sandreas.sandberg@arm.com signature += tname; 27011986Sandreas.sandberg@arm.com } 27111986Sandreas.sandberg@arm.com } else { 27211986Sandreas.sandberg@arm.com signature += c; 27311986Sandreas.sandberg@arm.com } 27411986Sandreas.sandberg@arm.com } 27511986Sandreas.sandberg@arm.com if (type_depth != 0 || types[type_index] != nullptr) 27611986Sandreas.sandberg@arm.com pybind11_fail("Internal error while parsing type signature (2)"); 27711986Sandreas.sandberg@arm.com 27812391Sjason@lowepower.com #if !defined(PYBIND11_CONSTEXPR_DESCR) 27911986Sandreas.sandberg@arm.com delete[] types; 28011986Sandreas.sandberg@arm.com delete[] text; 28111986Sandreas.sandberg@arm.com #endif 28211986Sandreas.sandberg@arm.com 28311986Sandreas.sandberg@arm.com#if PY_MAJOR_VERSION < 3 28411986Sandreas.sandberg@arm.com if (strcmp(rec->name, "__next__") == 0) { 28511986Sandreas.sandberg@arm.com std::free(rec->name); 28611986Sandreas.sandberg@arm.com rec->name = strdup("next"); 28711986Sandreas.sandberg@arm.com } else if (strcmp(rec->name, "__bool__") == 0) { 28811986Sandreas.sandberg@arm.com std::free(rec->name); 28911986Sandreas.sandberg@arm.com rec->name = strdup("__nonzero__"); 29011986Sandreas.sandberg@arm.com } 29111986Sandreas.sandberg@arm.com#endif 29211986Sandreas.sandberg@arm.com rec->signature = strdup(signature.c_str()); 29311986Sandreas.sandberg@arm.com rec->args.shrink_to_fit(); 29412037Sandreas.sandberg@arm.com rec->nargs = (std::uint16_t) args; 29511986Sandreas.sandberg@arm.com 29612391Sjason@lowepower.com if (rec->sibling && PYBIND11_INSTANCE_METHOD_CHECK(rec->sibling.ptr())) 29712391Sjason@lowepower.com rec->sibling = PYBIND11_INSTANCE_METHOD_GET_FUNCTION(rec->sibling.ptr()); 29811986Sandreas.sandberg@arm.com 29911986Sandreas.sandberg@arm.com detail::function_record *chain = nullptr, *chain_start = rec; 30011986Sandreas.sandberg@arm.com if (rec->sibling) { 30111986Sandreas.sandberg@arm.com if (PyCFunction_Check(rec->sibling.ptr())) { 30212037Sandreas.sandberg@arm.com auto rec_capsule = reinterpret_borrow<capsule>(PyCFunction_GET_SELF(rec->sibling.ptr())); 30311986Sandreas.sandberg@arm.com chain = (detail::function_record *) rec_capsule; 30411986Sandreas.sandberg@arm.com /* Never append a method to an overload chain of a parent class; 30511986Sandreas.sandberg@arm.com instead, hide the parent's overloads in this case */ 30612391Sjason@lowepower.com if (!chain->scope.is(rec->scope)) 30711986Sandreas.sandberg@arm.com chain = nullptr; 30811986Sandreas.sandberg@arm.com } 30911986Sandreas.sandberg@arm.com // Don't trigger for things like the default __init__, which are wrapper_descriptors that we are intentionally replacing 31011986Sandreas.sandberg@arm.com else if (!rec->sibling.is_none() && rec->name[0] != '_') 31111986Sandreas.sandberg@arm.com pybind11_fail("Cannot overload existing non-function object \"" + std::string(rec->name) + 31211986Sandreas.sandberg@arm.com "\" with a function of the same name"); 31311986Sandreas.sandberg@arm.com } 31411986Sandreas.sandberg@arm.com 31511986Sandreas.sandberg@arm.com if (!chain) { 31611986Sandreas.sandberg@arm.com /* No existing overload was found, create a new function object */ 31711986Sandreas.sandberg@arm.com rec->def = new PyMethodDef(); 31812391Sjason@lowepower.com std::memset(rec->def, 0, sizeof(PyMethodDef)); 31911986Sandreas.sandberg@arm.com rec->def->ml_name = rec->name; 32011986Sandreas.sandberg@arm.com rec->def->ml_meth = reinterpret_cast<PyCFunction>(*dispatcher); 32111986Sandreas.sandberg@arm.com rec->def->ml_flags = METH_VARARGS | METH_KEYWORDS; 32211986Sandreas.sandberg@arm.com 32312037Sandreas.sandberg@arm.com capsule rec_capsule(rec, [](void *ptr) { 32412037Sandreas.sandberg@arm.com destruct((detail::function_record *) ptr); 32511986Sandreas.sandberg@arm.com }); 32611986Sandreas.sandberg@arm.com 32711986Sandreas.sandberg@arm.com object scope_module; 32811986Sandreas.sandberg@arm.com if (rec->scope) { 32911986Sandreas.sandberg@arm.com if (hasattr(rec->scope, "__module__")) { 33011986Sandreas.sandberg@arm.com scope_module = rec->scope.attr("__module__"); 33111986Sandreas.sandberg@arm.com } else if (hasattr(rec->scope, "__name__")) { 33211986Sandreas.sandberg@arm.com scope_module = rec->scope.attr("__name__"); 33311986Sandreas.sandberg@arm.com } 33411986Sandreas.sandberg@arm.com } 33511986Sandreas.sandberg@arm.com 33611986Sandreas.sandberg@arm.com m_ptr = PyCFunction_NewEx(rec->def, rec_capsule.ptr(), scope_module.ptr()); 33711986Sandreas.sandberg@arm.com if (!m_ptr) 33811986Sandreas.sandberg@arm.com pybind11_fail("cpp_function::cpp_function(): Could not allocate function object"); 33911986Sandreas.sandberg@arm.com } else { 34011986Sandreas.sandberg@arm.com /* Append at the end of the overload chain */ 34111986Sandreas.sandberg@arm.com m_ptr = rec->sibling.ptr(); 34211986Sandreas.sandberg@arm.com inc_ref(); 34311986Sandreas.sandberg@arm.com chain_start = chain; 34412391Sjason@lowepower.com if (chain->is_method != rec->is_method) 34512391Sjason@lowepower.com pybind11_fail("overloading a method with both static and instance methods is not supported; " 34612391Sjason@lowepower.com #if defined(NDEBUG) 34712391Sjason@lowepower.com "compile in debug mode for more details" 34812391Sjason@lowepower.com #else 34912391Sjason@lowepower.com "error while attempting to bind " + std::string(rec->is_method ? "instance" : "static") + " method " + 35012391Sjason@lowepower.com std::string(pybind11::str(rec->scope.attr("__name__"))) + "." + std::string(rec->name) + signature 35112391Sjason@lowepower.com #endif 35212391Sjason@lowepower.com ); 35311986Sandreas.sandberg@arm.com while (chain->next) 35411986Sandreas.sandberg@arm.com chain = chain->next; 35511986Sandreas.sandberg@arm.com chain->next = rec; 35611986Sandreas.sandberg@arm.com } 35711986Sandreas.sandberg@arm.com 35811986Sandreas.sandberg@arm.com std::string signatures; 35911986Sandreas.sandberg@arm.com int index = 0; 36011986Sandreas.sandberg@arm.com /* Create a nice pydoc rec including all signatures and 36111986Sandreas.sandberg@arm.com docstrings of the functions in the overload chain */ 36211986Sandreas.sandberg@arm.com if (chain && options::show_function_signatures()) { 36311986Sandreas.sandberg@arm.com // First a generic signature 36411986Sandreas.sandberg@arm.com signatures += rec->name; 36511986Sandreas.sandberg@arm.com signatures += "(*args, **kwargs)\n"; 36611986Sandreas.sandberg@arm.com signatures += "Overloaded function.\n\n"; 36711986Sandreas.sandberg@arm.com } 36811986Sandreas.sandberg@arm.com // Then specific overload signatures 36912037Sandreas.sandberg@arm.com bool first_user_def = true; 37011986Sandreas.sandberg@arm.com for (auto it = chain_start; it != nullptr; it = it->next) { 37111986Sandreas.sandberg@arm.com if (options::show_function_signatures()) { 37212037Sandreas.sandberg@arm.com if (index > 0) signatures += "\n"; 37311986Sandreas.sandberg@arm.com if (chain) 37411986Sandreas.sandberg@arm.com signatures += std::to_string(++index) + ". "; 37511986Sandreas.sandberg@arm.com signatures += rec->name; 37611986Sandreas.sandberg@arm.com signatures += it->signature; 37711986Sandreas.sandberg@arm.com signatures += "\n"; 37811986Sandreas.sandberg@arm.com } 37911986Sandreas.sandberg@arm.com if (it->doc && strlen(it->doc) > 0 && options::show_user_defined_docstrings()) { 38012037Sandreas.sandberg@arm.com // If we're appending another docstring, and aren't printing function signatures, we 38112037Sandreas.sandberg@arm.com // need to append a newline first: 38212037Sandreas.sandberg@arm.com if (!options::show_function_signatures()) { 38312037Sandreas.sandberg@arm.com if (first_user_def) first_user_def = false; 38412037Sandreas.sandberg@arm.com else signatures += "\n"; 38512037Sandreas.sandberg@arm.com } 38611986Sandreas.sandberg@arm.com if (options::show_function_signatures()) signatures += "\n"; 38711986Sandreas.sandberg@arm.com signatures += it->doc; 38811986Sandreas.sandberg@arm.com if (options::show_function_signatures()) signatures += "\n"; 38911986Sandreas.sandberg@arm.com } 39011986Sandreas.sandberg@arm.com } 39111986Sandreas.sandberg@arm.com 39211986Sandreas.sandberg@arm.com /* Install docstring */ 39311986Sandreas.sandberg@arm.com PyCFunctionObject *func = (PyCFunctionObject *) m_ptr; 39411986Sandreas.sandberg@arm.com if (func->m_ml->ml_doc) 39512037Sandreas.sandberg@arm.com std::free(const_cast<char *>(func->m_ml->ml_doc)); 39611986Sandreas.sandberg@arm.com func->m_ml->ml_doc = strdup(signatures.c_str()); 39711986Sandreas.sandberg@arm.com 39811986Sandreas.sandberg@arm.com if (rec->is_method) { 39911986Sandreas.sandberg@arm.com m_ptr = PYBIND11_INSTANCE_METHOD_NEW(m_ptr, rec->scope.ptr()); 40011986Sandreas.sandberg@arm.com if (!m_ptr) 40111986Sandreas.sandberg@arm.com pybind11_fail("cpp_function::cpp_function(): Could not allocate instance method object"); 40211986Sandreas.sandberg@arm.com Py_DECREF(func); 40311986Sandreas.sandberg@arm.com } 40411986Sandreas.sandberg@arm.com } 40511986Sandreas.sandberg@arm.com 40611986Sandreas.sandberg@arm.com /// When a cpp_function is GCed, release any memory allocated by pybind11 40711986Sandreas.sandberg@arm.com static void destruct(detail::function_record *rec) { 40811986Sandreas.sandberg@arm.com while (rec) { 40911986Sandreas.sandberg@arm.com detail::function_record *next = rec->next; 41011986Sandreas.sandberg@arm.com if (rec->free_data) 41111986Sandreas.sandberg@arm.com rec->free_data(rec); 41211986Sandreas.sandberg@arm.com std::free((char *) rec->name); 41311986Sandreas.sandberg@arm.com std::free((char *) rec->doc); 41411986Sandreas.sandberg@arm.com std::free((char *) rec->signature); 41511986Sandreas.sandberg@arm.com for (auto &arg: rec->args) { 41612037Sandreas.sandberg@arm.com std::free(const_cast<char *>(arg.name)); 41712037Sandreas.sandberg@arm.com std::free(const_cast<char *>(arg.descr)); 41811986Sandreas.sandberg@arm.com arg.value.dec_ref(); 41911986Sandreas.sandberg@arm.com } 42011986Sandreas.sandberg@arm.com if (rec->def) { 42112037Sandreas.sandberg@arm.com std::free(const_cast<char *>(rec->def->ml_doc)); 42211986Sandreas.sandberg@arm.com delete rec->def; 42311986Sandreas.sandberg@arm.com } 42411986Sandreas.sandberg@arm.com delete rec; 42511986Sandreas.sandberg@arm.com rec = next; 42611986Sandreas.sandberg@arm.com } 42711986Sandreas.sandberg@arm.com } 42811986Sandreas.sandberg@arm.com 42911986Sandreas.sandberg@arm.com /// Main dispatch logic for calls to functions bound using pybind11 43012037Sandreas.sandberg@arm.com static PyObject *dispatcher(PyObject *self, PyObject *args_in, PyObject *kwargs_in) { 43112037Sandreas.sandberg@arm.com using namespace detail; 43212037Sandreas.sandberg@arm.com 43311986Sandreas.sandberg@arm.com /* Iterator over the list of potentially admissible overloads */ 43412037Sandreas.sandberg@arm.com function_record *overloads = (function_record *) PyCapsule_GetPointer(self, nullptr), 43512037Sandreas.sandberg@arm.com *it = overloads; 43611986Sandreas.sandberg@arm.com 43711986Sandreas.sandberg@arm.com /* Need to know how many arguments + keyword arguments there are to pick the right overload */ 43812037Sandreas.sandberg@arm.com const size_t n_args_in = (size_t) PyTuple_GET_SIZE(args_in); 43911986Sandreas.sandberg@arm.com 44012037Sandreas.sandberg@arm.com handle parent = n_args_in > 0 ? PyTuple_GET_ITEM(args_in, 0) : nullptr, 44111986Sandreas.sandberg@arm.com result = PYBIND11_TRY_NEXT_OVERLOAD; 44212037Sandreas.sandberg@arm.com 44312391Sjason@lowepower.com auto self_value_and_holder = value_and_holder(); 44412391Sjason@lowepower.com if (overloads->is_constructor) { 44512391Sjason@lowepower.com const auto tinfo = get_type_info((PyTypeObject *) overloads->scope.ptr()); 44612391Sjason@lowepower.com const auto pi = reinterpret_cast<instance *>(parent.ptr()); 44712391Sjason@lowepower.com self_value_and_holder = pi->get_value_and_holder(tinfo, false); 44812391Sjason@lowepower.com 44912391Sjason@lowepower.com if (!self_value_and_holder.type || !self_value_and_holder.inst) { 45012391Sjason@lowepower.com PyErr_SetString(PyExc_TypeError, "__init__(self, ...) called with invalid `self` argument"); 45112391Sjason@lowepower.com return nullptr; 45212391Sjason@lowepower.com } 45312391Sjason@lowepower.com 45412391Sjason@lowepower.com // If this value is already registered it must mean __init__ is invoked multiple times; 45512391Sjason@lowepower.com // we really can't support that in C++, so just ignore the second __init__. 45612391Sjason@lowepower.com if (self_value_and_holder.instance_registered()) 45712391Sjason@lowepower.com return none().release().ptr(); 45812391Sjason@lowepower.com } 45912391Sjason@lowepower.com 46011986Sandreas.sandberg@arm.com try { 46112037Sandreas.sandberg@arm.com // We do this in two passes: in the first pass, we load arguments with `convert=false`; 46212037Sandreas.sandberg@arm.com // in the second, we allow conversion (except for arguments with an explicit 46312037Sandreas.sandberg@arm.com // py::arg().noconvert()). This lets us prefer calls without conversion, with 46412037Sandreas.sandberg@arm.com // conversion as a fallback. 46512037Sandreas.sandberg@arm.com std::vector<function_call> second_pass; 46612037Sandreas.sandberg@arm.com 46712037Sandreas.sandberg@arm.com // However, if there are no overloads, we can just skip the no-convert pass entirely 46812037Sandreas.sandberg@arm.com const bool overloaded = it != nullptr && it->next != nullptr; 46912037Sandreas.sandberg@arm.com 47011986Sandreas.sandberg@arm.com for (; it != nullptr; it = it->next) { 47111986Sandreas.sandberg@arm.com 47211986Sandreas.sandberg@arm.com /* For each overload: 47312037Sandreas.sandberg@arm.com 1. Copy all positional arguments we were given, also checking to make sure that 47412037Sandreas.sandberg@arm.com named positional arguments weren't *also* specified via kwarg. 47512037Sandreas.sandberg@arm.com 2. If we weren't given enough, try to make up the omitted ones by checking 47612037Sandreas.sandberg@arm.com whether they were provided by a kwarg matching the `py::arg("name")` name. If 47712037Sandreas.sandberg@arm.com so, use it (and remove it from kwargs; if not, see if the function binding 47812037Sandreas.sandberg@arm.com provided a default that we can use. 47912037Sandreas.sandberg@arm.com 3. Ensure that either all keyword arguments were "consumed", or that the function 48012037Sandreas.sandberg@arm.com takes a kwargs argument to accept unconsumed kwargs. 48112037Sandreas.sandberg@arm.com 4. Any positional arguments still left get put into a tuple (for args), and any 48212037Sandreas.sandberg@arm.com leftover kwargs get put into a dict. 48312037Sandreas.sandberg@arm.com 5. Pack everything into a vector; if we have py::args or py::kwargs, they are an 48412037Sandreas.sandberg@arm.com extra tuple or dict at the end of the positional arguments. 48512037Sandreas.sandberg@arm.com 6. Call the function call dispatcher (function_record::impl) 48612037Sandreas.sandberg@arm.com 48712037Sandreas.sandberg@arm.com If one of these fail, move on to the next overload and keep trying until we get a 48812037Sandreas.sandberg@arm.com result other than PYBIND11_TRY_NEXT_OVERLOAD. 48911986Sandreas.sandberg@arm.com */ 49012037Sandreas.sandberg@arm.com 49112037Sandreas.sandberg@arm.com function_record &func = *it; 49212037Sandreas.sandberg@arm.com size_t pos_args = func.nargs; // Number of positional arguments that we need 49312037Sandreas.sandberg@arm.com if (func.has_args) --pos_args; // (but don't count py::args 49412037Sandreas.sandberg@arm.com if (func.has_kwargs) --pos_args; // or py::kwargs) 49512037Sandreas.sandberg@arm.com 49612037Sandreas.sandberg@arm.com if (!func.has_args && n_args_in > pos_args) 49712037Sandreas.sandberg@arm.com continue; // Too many arguments for this overload 49812037Sandreas.sandberg@arm.com 49912037Sandreas.sandberg@arm.com if (n_args_in < pos_args && func.args.size() < pos_args) 50012037Sandreas.sandberg@arm.com continue; // Not enough arguments given, and not enough defaults to fill in the blanks 50112037Sandreas.sandberg@arm.com 50212037Sandreas.sandberg@arm.com function_call call(func, parent); 50312037Sandreas.sandberg@arm.com 50412037Sandreas.sandberg@arm.com size_t args_to_copy = std::min(pos_args, n_args_in); 50512037Sandreas.sandberg@arm.com size_t args_copied = 0; 50612037Sandreas.sandberg@arm.com 50712391Sjason@lowepower.com // 0. Inject new-style `self` argument 50812391Sjason@lowepower.com if (func.is_new_style_constructor) { 50912391Sjason@lowepower.com // The `value` may have been preallocated by an old-style `__init__` 51012391Sjason@lowepower.com // if it was a preceding candidate for overload resolution. 51112391Sjason@lowepower.com if (self_value_and_holder) 51212391Sjason@lowepower.com self_value_and_holder.type->dealloc(self_value_and_holder); 51312391Sjason@lowepower.com 51412391Sjason@lowepower.com call.init_self = PyTuple_GET_ITEM(args_in, 0); 51512391Sjason@lowepower.com call.args.push_back(reinterpret_cast<PyObject *>(&self_value_and_holder)); 51612391Sjason@lowepower.com call.args_convert.push_back(false); 51712391Sjason@lowepower.com ++args_copied; 51812391Sjason@lowepower.com } 51912391Sjason@lowepower.com 52012037Sandreas.sandberg@arm.com // 1. Copy any position arguments given. 52112391Sjason@lowepower.com bool bad_arg = false; 52212037Sandreas.sandberg@arm.com for (; args_copied < args_to_copy; ++args_copied) { 52312391Sjason@lowepower.com argument_record *arg_rec = args_copied < func.args.size() ? &func.args[args_copied] : nullptr; 52412391Sjason@lowepower.com if (kwargs_in && arg_rec && arg_rec->name && PyDict_GetItemString(kwargs_in, arg_rec->name)) { 52512391Sjason@lowepower.com bad_arg = true; 52612037Sandreas.sandberg@arm.com break; 52711986Sandreas.sandberg@arm.com } 52811986Sandreas.sandberg@arm.com 52912391Sjason@lowepower.com handle arg(PyTuple_GET_ITEM(args_in, args_copied)); 53012391Sjason@lowepower.com if (arg_rec && !arg_rec->none && arg.is_none()) { 53112391Sjason@lowepower.com bad_arg = true; 53212391Sjason@lowepower.com break; 53312391Sjason@lowepower.com } 53412391Sjason@lowepower.com call.args.push_back(arg); 53512391Sjason@lowepower.com call.args_convert.push_back(arg_rec ? arg_rec->convert : true); 53612037Sandreas.sandberg@arm.com } 53712391Sjason@lowepower.com if (bad_arg) 53812037Sandreas.sandberg@arm.com continue; // Maybe it was meant for another overload (issue #688) 53912037Sandreas.sandberg@arm.com 54012037Sandreas.sandberg@arm.com // We'll need to copy this if we steal some kwargs for defaults 54112037Sandreas.sandberg@arm.com dict kwargs = reinterpret_borrow<dict>(kwargs_in); 54212037Sandreas.sandberg@arm.com 54312037Sandreas.sandberg@arm.com // 2. Check kwargs and, failing that, defaults that may help complete the list 54412037Sandreas.sandberg@arm.com if (args_copied < pos_args) { 54512037Sandreas.sandberg@arm.com bool copied_kwargs = false; 54612037Sandreas.sandberg@arm.com 54712037Sandreas.sandberg@arm.com for (; args_copied < pos_args; ++args_copied) { 54812037Sandreas.sandberg@arm.com const auto &arg = func.args[args_copied]; 54911986Sandreas.sandberg@arm.com 55011986Sandreas.sandberg@arm.com handle value; 55112037Sandreas.sandberg@arm.com if (kwargs_in && arg.name) 55212037Sandreas.sandberg@arm.com value = PyDict_GetItemString(kwargs.ptr(), arg.name); 55311986Sandreas.sandberg@arm.com 55411986Sandreas.sandberg@arm.com if (value) { 55512037Sandreas.sandberg@arm.com // Consume a kwargs value 55612037Sandreas.sandberg@arm.com if (!copied_kwargs) { 55712037Sandreas.sandberg@arm.com kwargs = reinterpret_steal<dict>(PyDict_Copy(kwargs.ptr())); 55812037Sandreas.sandberg@arm.com copied_kwargs = true; 55912037Sandreas.sandberg@arm.com } 56012037Sandreas.sandberg@arm.com PyDict_DelItemString(kwargs.ptr(), arg.name); 56112037Sandreas.sandberg@arm.com } else if (arg.value) { 56212037Sandreas.sandberg@arm.com value = arg.value; 56312037Sandreas.sandberg@arm.com } 56412037Sandreas.sandberg@arm.com 56512037Sandreas.sandberg@arm.com if (value) { 56612037Sandreas.sandberg@arm.com call.args.push_back(value); 56712037Sandreas.sandberg@arm.com call.args_convert.push_back(arg.convert); 56812037Sandreas.sandberg@arm.com } 56912037Sandreas.sandberg@arm.com else 57011986Sandreas.sandberg@arm.com break; 57112037Sandreas.sandberg@arm.com } 57212037Sandreas.sandberg@arm.com 57312037Sandreas.sandberg@arm.com if (args_copied < pos_args) 57412037Sandreas.sandberg@arm.com continue; // Not enough arguments, defaults, or kwargs to fill the positional arguments 57512037Sandreas.sandberg@arm.com } 57612037Sandreas.sandberg@arm.com 57712037Sandreas.sandberg@arm.com // 3. Check everything was consumed (unless we have a kwargs arg) 57812037Sandreas.sandberg@arm.com if (kwargs && kwargs.size() > 0 && !func.has_kwargs) 57912037Sandreas.sandberg@arm.com continue; // Unconsumed kwargs, but no py::kwargs argument to accept them 58012037Sandreas.sandberg@arm.com 58112037Sandreas.sandberg@arm.com // 4a. If we have a py::args argument, create a new tuple with leftovers 58212037Sandreas.sandberg@arm.com tuple extra_args; 58312037Sandreas.sandberg@arm.com if (func.has_args) { 58412037Sandreas.sandberg@arm.com if (args_to_copy == 0) { 58512037Sandreas.sandberg@arm.com // We didn't copy out any position arguments from the args_in tuple, so we 58612037Sandreas.sandberg@arm.com // can reuse it directly without copying: 58712037Sandreas.sandberg@arm.com extra_args = reinterpret_borrow<tuple>(args_in); 58812037Sandreas.sandberg@arm.com } else if (args_copied >= n_args_in) { 58912037Sandreas.sandberg@arm.com extra_args = tuple(0); 59012037Sandreas.sandberg@arm.com } else { 59112037Sandreas.sandberg@arm.com size_t args_size = n_args_in - args_copied; 59212037Sandreas.sandberg@arm.com extra_args = tuple(args_size); 59312037Sandreas.sandberg@arm.com for (size_t i = 0; i < args_size; ++i) { 59412037Sandreas.sandberg@arm.com handle item = PyTuple_GET_ITEM(args_in, args_copied + i); 59512037Sandreas.sandberg@arm.com extra_args[i] = item.inc_ref().ptr(); 59611986Sandreas.sandberg@arm.com } 59711986Sandreas.sandberg@arm.com } 59812037Sandreas.sandberg@arm.com call.args.push_back(extra_args); 59912037Sandreas.sandberg@arm.com call.args_convert.push_back(false); 60011986Sandreas.sandberg@arm.com } 60111986Sandreas.sandberg@arm.com 60212037Sandreas.sandberg@arm.com // 4b. If we have a py::kwargs, pass on any remaining kwargs 60312037Sandreas.sandberg@arm.com if (func.has_kwargs) { 60412037Sandreas.sandberg@arm.com if (!kwargs.ptr()) 60512037Sandreas.sandberg@arm.com kwargs = dict(); // If we didn't get one, send an empty one 60612037Sandreas.sandberg@arm.com call.args.push_back(kwargs); 60712037Sandreas.sandberg@arm.com call.args_convert.push_back(false); 60812037Sandreas.sandberg@arm.com } 60912037Sandreas.sandberg@arm.com 61012037Sandreas.sandberg@arm.com // 5. Put everything in a vector. Not technically step 5, we've been building it 61112037Sandreas.sandberg@arm.com // in `call.args` all along. 61212037Sandreas.sandberg@arm.com #if !defined(NDEBUG) 61312037Sandreas.sandberg@arm.com if (call.args.size() != func.nargs || call.args_convert.size() != func.nargs) 61412037Sandreas.sandberg@arm.com pybind11_fail("Internal error: function call dispatcher inserted wrong number of arguments!"); 61512037Sandreas.sandberg@arm.com #endif 61612037Sandreas.sandberg@arm.com 61712037Sandreas.sandberg@arm.com std::vector<bool> second_pass_convert; 61812037Sandreas.sandberg@arm.com if (overloaded) { 61912037Sandreas.sandberg@arm.com // We're in the first no-convert pass, so swap out the conversion flags for a 62012037Sandreas.sandberg@arm.com // set of all-false flags. If the call fails, we'll swap the flags back in for 62112037Sandreas.sandberg@arm.com // the conversion-allowed call below. 62212037Sandreas.sandberg@arm.com second_pass_convert.resize(func.nargs, false); 62312037Sandreas.sandberg@arm.com call.args_convert.swap(second_pass_convert); 62412037Sandreas.sandberg@arm.com } 62512037Sandreas.sandberg@arm.com 62612037Sandreas.sandberg@arm.com // 6. Call the function. 62711986Sandreas.sandberg@arm.com try { 62812391Sjason@lowepower.com loader_life_support guard{}; 62912037Sandreas.sandberg@arm.com result = func.impl(call); 63011986Sandreas.sandberg@arm.com } catch (reference_cast_error &) { 63111986Sandreas.sandberg@arm.com result = PYBIND11_TRY_NEXT_OVERLOAD; 63211986Sandreas.sandberg@arm.com } 63311986Sandreas.sandberg@arm.com 63411986Sandreas.sandberg@arm.com if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD) 63511986Sandreas.sandberg@arm.com break; 63612037Sandreas.sandberg@arm.com 63712037Sandreas.sandberg@arm.com if (overloaded) { 63812037Sandreas.sandberg@arm.com // The (overloaded) call failed; if the call has at least one argument that 63912037Sandreas.sandberg@arm.com // permits conversion (i.e. it hasn't been explicitly specified `.noconvert()`) 64012037Sandreas.sandberg@arm.com // then add this call to the list of second pass overloads to try. 64112037Sandreas.sandberg@arm.com for (size_t i = func.is_method ? 1 : 0; i < pos_args; i++) { 64212037Sandreas.sandberg@arm.com if (second_pass_convert[i]) { 64312037Sandreas.sandberg@arm.com // Found one: swap the converting flags back in and store the call for 64412037Sandreas.sandberg@arm.com // the second pass. 64512037Sandreas.sandberg@arm.com call.args_convert.swap(second_pass_convert); 64612037Sandreas.sandberg@arm.com second_pass.push_back(std::move(call)); 64712037Sandreas.sandberg@arm.com break; 64812037Sandreas.sandberg@arm.com } 64912037Sandreas.sandberg@arm.com } 65012037Sandreas.sandberg@arm.com } 65112037Sandreas.sandberg@arm.com } 65212037Sandreas.sandberg@arm.com 65312037Sandreas.sandberg@arm.com if (overloaded && !second_pass.empty() && result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) { 65412037Sandreas.sandberg@arm.com // The no-conversion pass finished without success, try again with conversion allowed 65512037Sandreas.sandberg@arm.com for (auto &call : second_pass) { 65612037Sandreas.sandberg@arm.com try { 65712391Sjason@lowepower.com loader_life_support guard{}; 65812037Sandreas.sandberg@arm.com result = call.func.impl(call); 65912037Sandreas.sandberg@arm.com } catch (reference_cast_error &) { 66012037Sandreas.sandberg@arm.com result = PYBIND11_TRY_NEXT_OVERLOAD; 66112037Sandreas.sandberg@arm.com } 66212037Sandreas.sandberg@arm.com 66312037Sandreas.sandberg@arm.com if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD) 66412037Sandreas.sandberg@arm.com break; 66512037Sandreas.sandberg@arm.com } 66611986Sandreas.sandberg@arm.com } 66711986Sandreas.sandberg@arm.com } catch (error_already_set &e) { 66811986Sandreas.sandberg@arm.com e.restore(); 66911986Sandreas.sandberg@arm.com return nullptr; 67011986Sandreas.sandberg@arm.com } catch (...) { 67111986Sandreas.sandberg@arm.com /* When an exception is caught, give each registered exception 67211986Sandreas.sandberg@arm.com translator a chance to translate it to a Python exception 67311986Sandreas.sandberg@arm.com in reverse order of registration. 67411986Sandreas.sandberg@arm.com 67511986Sandreas.sandberg@arm.com A translator may choose to do one of the following: 67611986Sandreas.sandberg@arm.com 67711986Sandreas.sandberg@arm.com - catch the exception and call PyErr_SetString or PyErr_SetObject 67811986Sandreas.sandberg@arm.com to set a standard (or custom) Python exception, or 67911986Sandreas.sandberg@arm.com - do nothing and let the exception fall through to the next translator, or 68011986Sandreas.sandberg@arm.com - delegate translation to the next translator by throwing a new type of exception. */ 68111986Sandreas.sandberg@arm.com 68211986Sandreas.sandberg@arm.com auto last_exception = std::current_exception(); 68312037Sandreas.sandberg@arm.com auto ®istered_exception_translators = get_internals().registered_exception_translators; 68411986Sandreas.sandberg@arm.com for (auto& translator : registered_exception_translators) { 68511986Sandreas.sandberg@arm.com try { 68611986Sandreas.sandberg@arm.com translator(last_exception); 68711986Sandreas.sandberg@arm.com } catch (...) { 68811986Sandreas.sandberg@arm.com last_exception = std::current_exception(); 68911986Sandreas.sandberg@arm.com continue; 69011986Sandreas.sandberg@arm.com } 69111986Sandreas.sandberg@arm.com return nullptr; 69211986Sandreas.sandberg@arm.com } 69311986Sandreas.sandberg@arm.com PyErr_SetString(PyExc_SystemError, "Exception escaped from default exception translator!"); 69411986Sandreas.sandberg@arm.com return nullptr; 69511986Sandreas.sandberg@arm.com } 69611986Sandreas.sandberg@arm.com 69712391Sjason@lowepower.com auto append_note_if_missing_header_is_suspected = [](std::string &msg) { 69812391Sjason@lowepower.com if (msg.find("std::") != std::string::npos) { 69912391Sjason@lowepower.com msg += "\n\n" 70012391Sjason@lowepower.com "Did you forget to `#include <pybind11/stl.h>`? Or <pybind11/complex.h>,\n" 70112391Sjason@lowepower.com "<pybind11/functional.h>, <pybind11/chrono.h>, etc. Some automatic\n" 70212391Sjason@lowepower.com "conversions are optional and require extra headers to be included\n" 70312391Sjason@lowepower.com "when compiling your pybind11 module."; 70412391Sjason@lowepower.com } 70512391Sjason@lowepower.com }; 70612391Sjason@lowepower.com 70711986Sandreas.sandberg@arm.com if (result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) { 70811986Sandreas.sandberg@arm.com if (overloads->is_operator) 70911986Sandreas.sandberg@arm.com return handle(Py_NotImplemented).inc_ref().ptr(); 71011986Sandreas.sandberg@arm.com 71111986Sandreas.sandberg@arm.com std::string msg = std::string(overloads->name) + "(): incompatible " + 71211986Sandreas.sandberg@arm.com std::string(overloads->is_constructor ? "constructor" : "function") + 71311986Sandreas.sandberg@arm.com " arguments. The following argument types are supported:\n"; 71411986Sandreas.sandberg@arm.com 71511986Sandreas.sandberg@arm.com int ctr = 0; 71612037Sandreas.sandberg@arm.com for (function_record *it2 = overloads; it2 != nullptr; it2 = it2->next) { 71711986Sandreas.sandberg@arm.com msg += " "+ std::to_string(++ctr) + ". "; 71811986Sandreas.sandberg@arm.com 71911986Sandreas.sandberg@arm.com bool wrote_sig = false; 72011986Sandreas.sandberg@arm.com if (overloads->is_constructor) { 72111986Sandreas.sandberg@arm.com // For a constructor, rewrite `(self: Object, arg0, ...) -> NoneType` as `Object(arg0, ...)` 72211986Sandreas.sandberg@arm.com std::string sig = it2->signature; 72311986Sandreas.sandberg@arm.com size_t start = sig.find('(') + 7; // skip "(self: " 72411986Sandreas.sandberg@arm.com if (start < sig.size()) { 72511986Sandreas.sandberg@arm.com // End at the , for the next argument 72611986Sandreas.sandberg@arm.com size_t end = sig.find(", "), next = end + 2; 72711986Sandreas.sandberg@arm.com size_t ret = sig.rfind(" -> "); 72811986Sandreas.sandberg@arm.com // Or the ), if there is no comma: 72911986Sandreas.sandberg@arm.com if (end >= sig.size()) next = end = sig.find(')'); 73011986Sandreas.sandberg@arm.com if (start < end && next < sig.size()) { 73111986Sandreas.sandberg@arm.com msg.append(sig, start, end - start); 73211986Sandreas.sandberg@arm.com msg += '('; 73311986Sandreas.sandberg@arm.com msg.append(sig, next, ret - next); 73411986Sandreas.sandberg@arm.com wrote_sig = true; 73511986Sandreas.sandberg@arm.com } 73611986Sandreas.sandberg@arm.com } 73711986Sandreas.sandberg@arm.com } 73811986Sandreas.sandberg@arm.com if (!wrote_sig) msg += it2->signature; 73911986Sandreas.sandberg@arm.com 74011986Sandreas.sandberg@arm.com msg += "\n"; 74111986Sandreas.sandberg@arm.com } 74211986Sandreas.sandberg@arm.com msg += "\nInvoked with: "; 74312037Sandreas.sandberg@arm.com auto args_ = reinterpret_borrow<tuple>(args_in); 74412037Sandreas.sandberg@arm.com bool some_args = false; 74511986Sandreas.sandberg@arm.com for (size_t ti = overloads->is_constructor ? 1 : 0; ti < args_.size(); ++ti) { 74612037Sandreas.sandberg@arm.com if (!some_args) some_args = true; 74712037Sandreas.sandberg@arm.com else msg += ", "; 74811986Sandreas.sandberg@arm.com msg += pybind11::repr(args_[ti]); 74911986Sandreas.sandberg@arm.com } 75012037Sandreas.sandberg@arm.com if (kwargs_in) { 75112037Sandreas.sandberg@arm.com auto kwargs = reinterpret_borrow<dict>(kwargs_in); 75212037Sandreas.sandberg@arm.com if (kwargs.size() > 0) { 75312037Sandreas.sandberg@arm.com if (some_args) msg += "; "; 75412037Sandreas.sandberg@arm.com msg += "kwargs: "; 75512037Sandreas.sandberg@arm.com bool first = true; 75612037Sandreas.sandberg@arm.com for (auto kwarg : kwargs) { 75712037Sandreas.sandberg@arm.com if (first) first = false; 75812037Sandreas.sandberg@arm.com else msg += ", "; 75912037Sandreas.sandberg@arm.com msg += pybind11::str("{}={!r}").format(kwarg.first, kwarg.second); 76012037Sandreas.sandberg@arm.com } 76112037Sandreas.sandberg@arm.com } 76212037Sandreas.sandberg@arm.com } 76312037Sandreas.sandberg@arm.com 76412391Sjason@lowepower.com append_note_if_missing_header_is_suspected(msg); 76511986Sandreas.sandberg@arm.com PyErr_SetString(PyExc_TypeError, msg.c_str()); 76611986Sandreas.sandberg@arm.com return nullptr; 76711986Sandreas.sandberg@arm.com } else if (!result) { 76811986Sandreas.sandberg@arm.com std::string msg = "Unable to convert function return value to a " 76911986Sandreas.sandberg@arm.com "Python type! The signature was\n\t"; 77011986Sandreas.sandberg@arm.com msg += it->signature; 77112391Sjason@lowepower.com append_note_if_missing_header_is_suspected(msg); 77211986Sandreas.sandberg@arm.com PyErr_SetString(PyExc_TypeError, msg.c_str()); 77311986Sandreas.sandberg@arm.com return nullptr; 77411986Sandreas.sandberg@arm.com } else { 77512391Sjason@lowepower.com if (overloads->is_constructor && !self_value_and_holder.holder_constructed()) { 77612391Sjason@lowepower.com auto *pi = reinterpret_cast<instance *>(parent.ptr()); 77712391Sjason@lowepower.com self_value_and_holder.type->init_instance(pi, nullptr); 77811986Sandreas.sandberg@arm.com } 77911986Sandreas.sandberg@arm.com return result.ptr(); 78011986Sandreas.sandberg@arm.com } 78111986Sandreas.sandberg@arm.com } 78211986Sandreas.sandberg@arm.com}; 78311986Sandreas.sandberg@arm.com 78411986Sandreas.sandberg@arm.com/// Wrapper for Python extension modules 78511986Sandreas.sandberg@arm.comclass module : public object { 78611986Sandreas.sandberg@arm.compublic: 78711986Sandreas.sandberg@arm.com PYBIND11_OBJECT_DEFAULT(module, object, PyModule_Check) 78811986Sandreas.sandberg@arm.com 78912037Sandreas.sandberg@arm.com /// Create a new top-level Python module with the given name and docstring 79011986Sandreas.sandberg@arm.com explicit module(const char *name, const char *doc = nullptr) { 79111986Sandreas.sandberg@arm.com if (!options::show_user_defined_docstrings()) doc = nullptr; 79211986Sandreas.sandberg@arm.com#if PY_MAJOR_VERSION >= 3 79311986Sandreas.sandberg@arm.com PyModuleDef *def = new PyModuleDef(); 79412391Sjason@lowepower.com std::memset(def, 0, sizeof(PyModuleDef)); 79511986Sandreas.sandberg@arm.com def->m_name = name; 79611986Sandreas.sandberg@arm.com def->m_doc = doc; 79711986Sandreas.sandberg@arm.com def->m_size = -1; 79811986Sandreas.sandberg@arm.com Py_INCREF(def); 79911986Sandreas.sandberg@arm.com m_ptr = PyModule_Create(def); 80011986Sandreas.sandberg@arm.com#else 80111986Sandreas.sandberg@arm.com m_ptr = Py_InitModule3(name, nullptr, doc); 80211986Sandreas.sandberg@arm.com#endif 80311986Sandreas.sandberg@arm.com if (m_ptr == nullptr) 80411986Sandreas.sandberg@arm.com pybind11_fail("Internal error in module::module()"); 80511986Sandreas.sandberg@arm.com inc_ref(); 80611986Sandreas.sandberg@arm.com } 80711986Sandreas.sandberg@arm.com 80812037Sandreas.sandberg@arm.com /** \rst 80912037Sandreas.sandberg@arm.com Create Python binding for a new function within the module scope. ``Func`` 81012037Sandreas.sandberg@arm.com can be a plain C++ function, a function pointer, or a lambda function. For 81112037Sandreas.sandberg@arm.com details on the ``Extra&& ... extra`` argument, see section :ref:`extras`. 81212037Sandreas.sandberg@arm.com \endrst */ 81311986Sandreas.sandberg@arm.com template <typename Func, typename... Extra> 81411986Sandreas.sandberg@arm.com module &def(const char *name_, Func &&f, const Extra& ... extra) { 81511986Sandreas.sandberg@arm.com cpp_function func(std::forward<Func>(f), name(name_), scope(*this), 81611986Sandreas.sandberg@arm.com sibling(getattr(*this, name_, none())), extra...); 81711986Sandreas.sandberg@arm.com // NB: allow overwriting here because cpp_function sets up a chain with the intention of 81811986Sandreas.sandberg@arm.com // overwriting (and has already checked internally that it isn't overwriting non-functions). 81911986Sandreas.sandberg@arm.com add_object(name_, func, true /* overwrite */); 82011986Sandreas.sandberg@arm.com return *this; 82111986Sandreas.sandberg@arm.com } 82211986Sandreas.sandberg@arm.com 82312037Sandreas.sandberg@arm.com /** \rst 82412037Sandreas.sandberg@arm.com Create and return a new Python submodule with the given name and docstring. 82512037Sandreas.sandberg@arm.com This also works recursively, i.e. 82612037Sandreas.sandberg@arm.com 82712037Sandreas.sandberg@arm.com .. code-block:: cpp 82812037Sandreas.sandberg@arm.com 82912037Sandreas.sandberg@arm.com py::module m("example", "pybind11 example plugin"); 83012037Sandreas.sandberg@arm.com py::module m2 = m.def_submodule("sub", "A submodule of 'example'"); 83112037Sandreas.sandberg@arm.com py::module m3 = m2.def_submodule("subsub", "A submodule of 'example.sub'"); 83212037Sandreas.sandberg@arm.com \endrst */ 83311986Sandreas.sandberg@arm.com module def_submodule(const char *name, const char *doc = nullptr) { 83411986Sandreas.sandberg@arm.com std::string full_name = std::string(PyModule_GetName(m_ptr)) 83511986Sandreas.sandberg@arm.com + std::string(".") + std::string(name); 83611986Sandreas.sandberg@arm.com auto result = reinterpret_borrow<module>(PyImport_AddModule(full_name.c_str())); 83711986Sandreas.sandberg@arm.com if (doc && options::show_user_defined_docstrings()) 83811986Sandreas.sandberg@arm.com result.attr("__doc__") = pybind11::str(doc); 83911986Sandreas.sandberg@arm.com attr(name) = result; 84011986Sandreas.sandberg@arm.com return result; 84111986Sandreas.sandberg@arm.com } 84211986Sandreas.sandberg@arm.com 84312037Sandreas.sandberg@arm.com /// Import and return a module or throws `error_already_set`. 84411986Sandreas.sandberg@arm.com static module import(const char *name) { 84511986Sandreas.sandberg@arm.com PyObject *obj = PyImport_ImportModule(name); 84611986Sandreas.sandberg@arm.com if (!obj) 84711986Sandreas.sandberg@arm.com throw error_already_set(); 84811986Sandreas.sandberg@arm.com return reinterpret_steal<module>(obj); 84911986Sandreas.sandberg@arm.com } 85011986Sandreas.sandberg@arm.com 85112391Sjason@lowepower.com /// Reload the module or throws `error_already_set`. 85212391Sjason@lowepower.com void reload() { 85312391Sjason@lowepower.com PyObject *obj = PyImport_ReloadModule(ptr()); 85412391Sjason@lowepower.com if (!obj) 85512391Sjason@lowepower.com throw error_already_set(); 85612391Sjason@lowepower.com *this = reinterpret_steal<module>(obj); 85712391Sjason@lowepower.com } 85812391Sjason@lowepower.com 85911986Sandreas.sandberg@arm.com // Adds an object to the module using the given name. Throws if an object with the given name 86011986Sandreas.sandberg@arm.com // already exists. 86111986Sandreas.sandberg@arm.com // 86211986Sandreas.sandberg@arm.com // overwrite should almost always be false: attempting to overwrite objects that pybind11 has 86311986Sandreas.sandberg@arm.com // established will, in most cases, break things. 86412391Sjason@lowepower.com PYBIND11_NOINLINE void add_object(const char *name, handle obj, bool overwrite = false) { 86511986Sandreas.sandberg@arm.com if (!overwrite && hasattr(*this, name)) 86611986Sandreas.sandberg@arm.com pybind11_fail("Error during initialization: multiple incompatible definitions with name \"" + 86711986Sandreas.sandberg@arm.com std::string(name) + "\""); 86811986Sandreas.sandberg@arm.com 86912391Sjason@lowepower.com PyModule_AddObject(ptr(), name, obj.inc_ref().ptr() /* steals a reference */); 87011986Sandreas.sandberg@arm.com } 87111986Sandreas.sandberg@arm.com}; 87211986Sandreas.sandberg@arm.com 87312391Sjason@lowepower.com/// \ingroup python_builtins 87412391Sjason@lowepower.com/// Return a dictionary representing the global variables in the current execution frame, 87512391Sjason@lowepower.com/// or ``__main__.__dict__`` if there is no frame (usually when the interpreter is embedded). 87612391Sjason@lowepower.cominline dict globals() { 87712391Sjason@lowepower.com PyObject *p = PyEval_GetGlobals(); 87812391Sjason@lowepower.com return reinterpret_borrow<dict>(p ? p : module::import("__main__").attr("__dict__").ptr()); 87912391Sjason@lowepower.com} 88012391Sjason@lowepower.com 88111986Sandreas.sandberg@arm.comNAMESPACE_BEGIN(detail) 88211986Sandreas.sandberg@arm.com/// Generic support for creating new Python heap types 88311986Sandreas.sandberg@arm.comclass generic_type : public object { 88411986Sandreas.sandberg@arm.com template <typename...> friend class class_; 88511986Sandreas.sandberg@arm.compublic: 88611986Sandreas.sandberg@arm.com PYBIND11_OBJECT_DEFAULT(generic_type, object, PyType_Check) 88711986Sandreas.sandberg@arm.comprotected: 88812037Sandreas.sandberg@arm.com void initialize(const type_record &rec) { 88912037Sandreas.sandberg@arm.com if (rec.scope && hasattr(rec.scope, rec.name)) 89012037Sandreas.sandberg@arm.com pybind11_fail("generic_type: cannot initialize type \"" + std::string(rec.name) + 89112037Sandreas.sandberg@arm.com "\": an object with that name is already defined"); 89211986Sandreas.sandberg@arm.com 89312391Sjason@lowepower.com if (rec.module_local ? get_local_type_info(*rec.type) : get_global_type_info(*rec.type)) 89412037Sandreas.sandberg@arm.com pybind11_fail("generic_type: type \"" + std::string(rec.name) + 89511986Sandreas.sandberg@arm.com "\" is already registered!"); 89611986Sandreas.sandberg@arm.com 89712037Sandreas.sandberg@arm.com m_ptr = make_new_python_type(rec); 89811986Sandreas.sandberg@arm.com 89911986Sandreas.sandberg@arm.com /* Register supplemental type information in C++ dict */ 90012037Sandreas.sandberg@arm.com auto *tinfo = new detail::type_info(); 90112037Sandreas.sandberg@arm.com tinfo->type = (PyTypeObject *) m_ptr; 90212391Sjason@lowepower.com tinfo->cpptype = rec.type; 90312037Sandreas.sandberg@arm.com tinfo->type_size = rec.type_size; 90412037Sandreas.sandberg@arm.com tinfo->operator_new = rec.operator_new; 90512391Sjason@lowepower.com tinfo->holder_size_in_ptrs = size_in_ptrs(rec.holder_size); 90612391Sjason@lowepower.com tinfo->init_instance = rec.init_instance; 90712037Sandreas.sandberg@arm.com tinfo->dealloc = rec.dealloc; 90812391Sjason@lowepower.com tinfo->simple_type = true; 90912391Sjason@lowepower.com tinfo->simple_ancestors = true; 91012391Sjason@lowepower.com tinfo->default_holder = rec.default_holder; 91112391Sjason@lowepower.com tinfo->module_local = rec.module_local; 91212037Sandreas.sandberg@arm.com 91312037Sandreas.sandberg@arm.com auto &internals = get_internals(); 91412037Sandreas.sandberg@arm.com auto tindex = std::type_index(*rec.type); 91511986Sandreas.sandberg@arm.com tinfo->direct_conversions = &internals.direct_conversions[tindex]; 91612391Sjason@lowepower.com if (rec.module_local) 91712391Sjason@lowepower.com registered_local_types_cpp()[tindex] = tinfo; 91812391Sjason@lowepower.com else 91912391Sjason@lowepower.com internals.registered_types_cpp[tindex] = tinfo; 92012391Sjason@lowepower.com internals.registered_types_py[(PyTypeObject *) m_ptr] = { tinfo }; 92111986Sandreas.sandberg@arm.com 92212391Sjason@lowepower.com if (rec.bases.size() > 1 || rec.multiple_inheritance) { 92312037Sandreas.sandberg@arm.com mark_parents_nonsimple(tinfo->type); 92412391Sjason@lowepower.com tinfo->simple_ancestors = false; 92512391Sjason@lowepower.com } 92612391Sjason@lowepower.com else if (rec.bases.size() == 1) { 92712391Sjason@lowepower.com auto parent_tinfo = get_type_info((PyTypeObject *) rec.bases[0].ptr()); 92812391Sjason@lowepower.com tinfo->simple_ancestors = parent_tinfo->simple_ancestors; 92912391Sjason@lowepower.com } 93012391Sjason@lowepower.com 93112391Sjason@lowepower.com if (rec.module_local) { 93212391Sjason@lowepower.com // Stash the local typeinfo and loader so that external modules can access it. 93312391Sjason@lowepower.com tinfo->module_local_load = &type_caster_generic::local_load; 93412391Sjason@lowepower.com setattr(m_ptr, PYBIND11_MODULE_LOCAL_ID, capsule(tinfo)); 93512391Sjason@lowepower.com } 93611986Sandreas.sandberg@arm.com } 93711986Sandreas.sandberg@arm.com 93811986Sandreas.sandberg@arm.com /// Helper function which tags all parents of a type using mult. inheritance 93911986Sandreas.sandberg@arm.com void mark_parents_nonsimple(PyTypeObject *value) { 94011986Sandreas.sandberg@arm.com auto t = reinterpret_borrow<tuple>(value->tp_bases); 94111986Sandreas.sandberg@arm.com for (handle h : t) { 94211986Sandreas.sandberg@arm.com auto tinfo2 = get_type_info((PyTypeObject *) h.ptr()); 94311986Sandreas.sandberg@arm.com if (tinfo2) 94411986Sandreas.sandberg@arm.com tinfo2->simple_type = false; 94511986Sandreas.sandberg@arm.com mark_parents_nonsimple((PyTypeObject *) h.ptr()); 94611986Sandreas.sandberg@arm.com } 94711986Sandreas.sandberg@arm.com } 94811986Sandreas.sandberg@arm.com 94911986Sandreas.sandberg@arm.com void install_buffer_funcs( 95011986Sandreas.sandberg@arm.com buffer_info *(*get_buffer)(PyObject *, void *), 95111986Sandreas.sandberg@arm.com void *get_buffer_data) { 95211986Sandreas.sandberg@arm.com PyHeapTypeObject *type = (PyHeapTypeObject*) m_ptr; 95311986Sandreas.sandberg@arm.com auto tinfo = detail::get_type_info(&type->ht_type); 95412037Sandreas.sandberg@arm.com 95512037Sandreas.sandberg@arm.com if (!type->ht_type.tp_as_buffer) 95612037Sandreas.sandberg@arm.com pybind11_fail( 95712037Sandreas.sandberg@arm.com "To be able to register buffer protocol support for the type '" + 95812037Sandreas.sandberg@arm.com std::string(tinfo->type->tp_name) + 95912037Sandreas.sandberg@arm.com "' the associated class<>(..) invocation must " 96012037Sandreas.sandberg@arm.com "include the pybind11::buffer_protocol() annotation!"); 96112037Sandreas.sandberg@arm.com 96211986Sandreas.sandberg@arm.com tinfo->get_buffer = get_buffer; 96311986Sandreas.sandberg@arm.com tinfo->get_buffer_data = get_buffer_data; 96411986Sandreas.sandberg@arm.com } 96511986Sandreas.sandberg@arm.com 96612037Sandreas.sandberg@arm.com void def_property_static_impl(const char *name, 96712037Sandreas.sandberg@arm.com handle fget, handle fset, 96812037Sandreas.sandberg@arm.com detail::function_record *rec_fget) { 96912037Sandreas.sandberg@arm.com const auto is_static = !(rec_fget->is_method && rec_fget->scope); 97012037Sandreas.sandberg@arm.com const auto has_doc = rec_fget->doc && pybind11::options::show_user_defined_docstrings(); 97112037Sandreas.sandberg@arm.com 97212037Sandreas.sandberg@arm.com auto property = handle((PyObject *) (is_static ? get_internals().static_property_type 97312037Sandreas.sandberg@arm.com : &PyProperty_Type)); 97412037Sandreas.sandberg@arm.com attr(name) = property(fget.ptr() ? fget : none(), 97512037Sandreas.sandberg@arm.com fset.ptr() ? fset : none(), 97612037Sandreas.sandberg@arm.com /*deleter*/none(), 97712037Sandreas.sandberg@arm.com pybind11::str(has_doc ? rec_fget->doc : "")); 97811986Sandreas.sandberg@arm.com } 97912037Sandreas.sandberg@arm.com}; 98011986Sandreas.sandberg@arm.com 98112037Sandreas.sandberg@arm.com/// Set the pointer to operator new if it exists. The cast is needed because it can be overloaded. 98212037Sandreas.sandberg@arm.comtemplate <typename T, typename = void_t<decltype(static_cast<void *(*)(size_t)>(T::operator new))>> 98312037Sandreas.sandberg@arm.comvoid set_operator_new(type_record *r) { r->operator_new = &T::operator new; } 98412037Sandreas.sandberg@arm.com 98512037Sandreas.sandberg@arm.comtemplate <typename> void set_operator_new(...) { } 98612037Sandreas.sandberg@arm.com 98712391Sjason@lowepower.comtemplate <typename T, typename SFINAE = void> struct has_operator_delete : std::false_type { }; 98812391Sjason@lowepower.comtemplate <typename T> struct has_operator_delete<T, void_t<decltype(static_cast<void (*)(void *)>(T::operator delete))>> 98912391Sjason@lowepower.com : std::true_type { }; 99012391Sjason@lowepower.comtemplate <typename T, typename SFINAE = void> struct has_operator_delete_size : std::false_type { }; 99112391Sjason@lowepower.comtemplate <typename T> struct has_operator_delete_size<T, void_t<decltype(static_cast<void (*)(void *, size_t)>(T::operator delete))>> 99212391Sjason@lowepower.com : std::true_type { }; 99312037Sandreas.sandberg@arm.com/// Call class-specific delete if it exists or global otherwise. Can also be an overload set. 99412391Sjason@lowepower.comtemplate <typename T, enable_if_t<has_operator_delete<T>::value, int> = 0> 99512391Sjason@lowepower.comvoid call_operator_delete(T *p, size_t) { T::operator delete(p); } 99612391Sjason@lowepower.comtemplate <typename T, enable_if_t<!has_operator_delete<T>::value && has_operator_delete_size<T>::value, int> = 0> 99712391Sjason@lowepower.comvoid call_operator_delete(T *p, size_t s) { T::operator delete(p, s); } 99812037Sandreas.sandberg@arm.com 99912391Sjason@lowepower.cominline void call_operator_delete(void *p, size_t) { ::operator delete(p); } 100011986Sandreas.sandberg@arm.com 100111986Sandreas.sandberg@arm.comNAMESPACE_END(detail) 100211986Sandreas.sandberg@arm.com 100312391Sjason@lowepower.com/// Given a pointer to a member function, cast it to its `Derived` version. 100412391Sjason@lowepower.com/// Forward everything else unchanged. 100512391Sjason@lowepower.comtemplate <typename /*Derived*/, typename F> 100612391Sjason@lowepower.comauto method_adaptor(F &&f) -> decltype(std::forward<F>(f)) { return std::forward<F>(f); } 100712391Sjason@lowepower.com 100812391Sjason@lowepower.comtemplate <typename Derived, typename Return, typename Class, typename... Args> 100912391Sjason@lowepower.comauto method_adaptor(Return (Class::*pmf)(Args...)) -> Return (Derived::*)(Args...) { return pmf; } 101012391Sjason@lowepower.com 101112391Sjason@lowepower.comtemplate <typename Derived, typename Return, typename Class, typename... Args> 101212391Sjason@lowepower.comauto method_adaptor(Return (Class::*pmf)(Args...) const) -> Return (Derived::*)(Args...) const { return pmf; } 101312391Sjason@lowepower.com 101411986Sandreas.sandberg@arm.comtemplate <typename type_, typename... options> 101511986Sandreas.sandberg@arm.comclass class_ : public detail::generic_type { 101611986Sandreas.sandberg@arm.com template <typename T> using is_holder = detail::is_holder_type<type_, T>; 101712391Sjason@lowepower.com template <typename T> using is_subtype = detail::is_strict_base_of<type_, T>; 101812391Sjason@lowepower.com template <typename T> using is_base = detail::is_strict_base_of<T, type_>; 101912037Sandreas.sandberg@arm.com // struct instead of using here to help MSVC: 102012037Sandreas.sandberg@arm.com template <typename T> struct is_valid_class_option : 102112037Sandreas.sandberg@arm.com detail::any_of<is_holder<T>, is_subtype<T>, is_base<T>> {}; 102211986Sandreas.sandberg@arm.com 102311986Sandreas.sandberg@arm.compublic: 102411986Sandreas.sandberg@arm.com using type = type_; 102512391Sjason@lowepower.com using type_alias = detail::exactly_one_t<is_subtype, void, options...>; 102611986Sandreas.sandberg@arm.com constexpr static bool has_alias = !std::is_void<type_alias>::value; 102712391Sjason@lowepower.com using holder_type = detail::exactly_one_t<is_holder, std::unique_ptr<type>, options...>; 102811986Sandreas.sandberg@arm.com 102912037Sandreas.sandberg@arm.com static_assert(detail::all_of<is_valid_class_option<options>...>::value, 103011986Sandreas.sandberg@arm.com "Unknown/invalid class_ template parameters provided"); 103111986Sandreas.sandberg@arm.com 103212391Sjason@lowepower.com static_assert(!has_alias || std::is_polymorphic<type>::value, 103312391Sjason@lowepower.com "Cannot use an alias class with a non-polymorphic type"); 103412391Sjason@lowepower.com 103511986Sandreas.sandberg@arm.com PYBIND11_OBJECT(class_, generic_type, PyType_Check) 103611986Sandreas.sandberg@arm.com 103711986Sandreas.sandberg@arm.com template <typename... Extra> 103811986Sandreas.sandberg@arm.com class_(handle scope, const char *name, const Extra &... extra) { 103912037Sandreas.sandberg@arm.com using namespace detail; 104012037Sandreas.sandberg@arm.com 104112037Sandreas.sandberg@arm.com // MI can only be specified via class_ template options, not constructor parameters 104212037Sandreas.sandberg@arm.com static_assert( 104312037Sandreas.sandberg@arm.com none_of<is_pyobject<Extra>...>::value || // no base class arguments, or: 104412037Sandreas.sandberg@arm.com ( constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base 104512037Sandreas.sandberg@arm.com constexpr_sum(is_base<options>::value...) == 0 && // no template option bases 104612037Sandreas.sandberg@arm.com none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr 104712037Sandreas.sandberg@arm.com "Error: multiple inheritance bases must be specified via class_ template options"); 104812037Sandreas.sandberg@arm.com 104912037Sandreas.sandberg@arm.com type_record record; 105011986Sandreas.sandberg@arm.com record.scope = scope; 105111986Sandreas.sandberg@arm.com record.name = name; 105211986Sandreas.sandberg@arm.com record.type = &typeid(type); 105312037Sandreas.sandberg@arm.com record.type_size = sizeof(conditional_t<has_alias, type_alias, type>); 105412391Sjason@lowepower.com record.holder_size = sizeof(holder_type); 105512391Sjason@lowepower.com record.init_instance = init_instance; 105611986Sandreas.sandberg@arm.com record.dealloc = dealloc; 105712037Sandreas.sandberg@arm.com record.default_holder = std::is_same<holder_type, std::unique_ptr<type>>::value; 105812037Sandreas.sandberg@arm.com 105912037Sandreas.sandberg@arm.com set_operator_new<type>(&record); 106011986Sandreas.sandberg@arm.com 106111986Sandreas.sandberg@arm.com /* Register base classes specified via template arguments to class_, if any */ 106212391Sjason@lowepower.com PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record)); 106311986Sandreas.sandberg@arm.com 106411986Sandreas.sandberg@arm.com /* Process optional arguments, if any */ 106512037Sandreas.sandberg@arm.com process_attributes<Extra...>::init(extra..., &record); 106611986Sandreas.sandberg@arm.com 106712037Sandreas.sandberg@arm.com generic_type::initialize(record); 106811986Sandreas.sandberg@arm.com 106911986Sandreas.sandberg@arm.com if (has_alias) { 107012391Sjason@lowepower.com auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp; 107111986Sandreas.sandberg@arm.com instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))]; 107211986Sandreas.sandberg@arm.com } 107311986Sandreas.sandberg@arm.com } 107411986Sandreas.sandberg@arm.com 107511986Sandreas.sandberg@arm.com template <typename Base, detail::enable_if_t<is_base<Base>::value, int> = 0> 107611986Sandreas.sandberg@arm.com static void add_base(detail::type_record &rec) { 107712391Sjason@lowepower.com rec.add_base(typeid(Base), [](void *src) -> void * { 107811986Sandreas.sandberg@arm.com return static_cast<Base *>(reinterpret_cast<type *>(src)); 107911986Sandreas.sandberg@arm.com }); 108011986Sandreas.sandberg@arm.com } 108111986Sandreas.sandberg@arm.com 108211986Sandreas.sandberg@arm.com template <typename Base, detail::enable_if_t<!is_base<Base>::value, int> = 0> 108311986Sandreas.sandberg@arm.com static void add_base(detail::type_record &) { } 108411986Sandreas.sandberg@arm.com 108511986Sandreas.sandberg@arm.com template <typename Func, typename... Extra> 108611986Sandreas.sandberg@arm.com class_ &def(const char *name_, Func&& f, const Extra&... extra) { 108712391Sjason@lowepower.com cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this), 108811986Sandreas.sandberg@arm.com sibling(getattr(*this, name_, none())), extra...); 108911986Sandreas.sandberg@arm.com attr(cf.name()) = cf; 109011986Sandreas.sandberg@arm.com return *this; 109111986Sandreas.sandberg@arm.com } 109211986Sandreas.sandberg@arm.com 109311986Sandreas.sandberg@arm.com template <typename Func, typename... Extra> class_ & 109412037Sandreas.sandberg@arm.com def_static(const char *name_, Func &&f, const Extra&... extra) { 109512037Sandreas.sandberg@arm.com static_assert(!std::is_member_function_pointer<Func>::value, 109612037Sandreas.sandberg@arm.com "def_static(...) called with a non-static member function pointer"); 109711986Sandreas.sandberg@arm.com cpp_function cf(std::forward<Func>(f), name(name_), scope(*this), 109811986Sandreas.sandberg@arm.com sibling(getattr(*this, name_, none())), extra...); 109911986Sandreas.sandberg@arm.com attr(cf.name()) = cf; 110011986Sandreas.sandberg@arm.com return *this; 110111986Sandreas.sandberg@arm.com } 110211986Sandreas.sandberg@arm.com 110311986Sandreas.sandberg@arm.com template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra> 110411986Sandreas.sandberg@arm.com class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) { 110511986Sandreas.sandberg@arm.com op.execute(*this, extra...); 110611986Sandreas.sandberg@arm.com return *this; 110711986Sandreas.sandberg@arm.com } 110811986Sandreas.sandberg@arm.com 110911986Sandreas.sandberg@arm.com template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra> 111011986Sandreas.sandberg@arm.com class_ & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) { 111111986Sandreas.sandberg@arm.com op.execute_cast(*this, extra...); 111211986Sandreas.sandberg@arm.com return *this; 111311986Sandreas.sandberg@arm.com } 111411986Sandreas.sandberg@arm.com 111511986Sandreas.sandberg@arm.com template <typename... Args, typename... Extra> 111612391Sjason@lowepower.com class_ &def(const detail::initimpl::constructor<Args...> &init, const Extra&... extra) { 111711986Sandreas.sandberg@arm.com init.execute(*this, extra...); 111811986Sandreas.sandberg@arm.com return *this; 111911986Sandreas.sandberg@arm.com } 112011986Sandreas.sandberg@arm.com 112111986Sandreas.sandberg@arm.com template <typename... Args, typename... Extra> 112212391Sjason@lowepower.com class_ &def(const detail::initimpl::alias_constructor<Args...> &init, const Extra&... extra) { 112311986Sandreas.sandberg@arm.com init.execute(*this, extra...); 112411986Sandreas.sandberg@arm.com return *this; 112511986Sandreas.sandberg@arm.com } 112611986Sandreas.sandberg@arm.com 112712391Sjason@lowepower.com template <typename... Args, typename... Extra> 112812391Sjason@lowepower.com class_ &def(detail::initimpl::factory<Args...> &&init, const Extra&... extra) { 112912391Sjason@lowepower.com std::move(init).execute(*this, extra...); 113012391Sjason@lowepower.com return *this; 113112391Sjason@lowepower.com } 113212391Sjason@lowepower.com 113312391Sjason@lowepower.com template <typename... Args, typename... Extra> 113412391Sjason@lowepower.com class_ &def(detail::initimpl::pickle_factory<Args...> &&pf, const Extra &...extra) { 113512391Sjason@lowepower.com std::move(pf).execute(*this, extra...); 113612391Sjason@lowepower.com return *this; 113712391Sjason@lowepower.com } 113812391Sjason@lowepower.com 113911986Sandreas.sandberg@arm.com template <typename Func> class_& def_buffer(Func &&func) { 114011986Sandreas.sandberg@arm.com struct capture { Func func; }; 114111986Sandreas.sandberg@arm.com capture *ptr = new capture { std::forward<Func>(func) }; 114211986Sandreas.sandberg@arm.com install_buffer_funcs([](PyObject *obj, void *ptr) -> buffer_info* { 114312037Sandreas.sandberg@arm.com detail::make_caster<type> caster; 114411986Sandreas.sandberg@arm.com if (!caster.load(obj, false)) 114511986Sandreas.sandberg@arm.com return nullptr; 114611986Sandreas.sandberg@arm.com return new buffer_info(((capture *) ptr)->func(caster)); 114711986Sandreas.sandberg@arm.com }, ptr); 114811986Sandreas.sandberg@arm.com return *this; 114911986Sandreas.sandberg@arm.com } 115011986Sandreas.sandberg@arm.com 115112391Sjason@lowepower.com template <typename Return, typename Class, typename... Args> 115212391Sjason@lowepower.com class_ &def_buffer(Return (Class::*func)(Args...)) { 115312391Sjason@lowepower.com return def_buffer([func] (type &obj) { return (obj.*func)(); }); 115412391Sjason@lowepower.com } 115512391Sjason@lowepower.com 115612391Sjason@lowepower.com template <typename Return, typename Class, typename... Args> 115712391Sjason@lowepower.com class_ &def_buffer(Return (Class::*func)(Args...) const) { 115812391Sjason@lowepower.com return def_buffer([func] (const type &obj) { return (obj.*func)(); }); 115912391Sjason@lowepower.com } 116012391Sjason@lowepower.com 116111986Sandreas.sandberg@arm.com template <typename C, typename D, typename... Extra> 116211986Sandreas.sandberg@arm.com class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) { 116312391Sjason@lowepower.com static_assert(std::is_base_of<C, type>::value, "def_readwrite() requires a class member (or base class member)"); 116412391Sjason@lowepower.com cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this)), 116512391Sjason@lowepower.com fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this)); 116611986Sandreas.sandberg@arm.com def_property(name, fget, fset, return_value_policy::reference_internal, extra...); 116711986Sandreas.sandberg@arm.com return *this; 116811986Sandreas.sandberg@arm.com } 116911986Sandreas.sandberg@arm.com 117011986Sandreas.sandberg@arm.com template <typename C, typename D, typename... Extra> 117111986Sandreas.sandberg@arm.com class_ &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) { 117212391Sjason@lowepower.com static_assert(std::is_base_of<C, type>::value, "def_readonly() requires a class member (or base class member)"); 117312391Sjason@lowepower.com cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this)); 117411986Sandreas.sandberg@arm.com def_property_readonly(name, fget, return_value_policy::reference_internal, extra...); 117511986Sandreas.sandberg@arm.com return *this; 117611986Sandreas.sandberg@arm.com } 117711986Sandreas.sandberg@arm.com 117811986Sandreas.sandberg@arm.com template <typename D, typename... Extra> 117911986Sandreas.sandberg@arm.com class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) { 118011986Sandreas.sandberg@arm.com cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this)), 118111986Sandreas.sandberg@arm.com fset([pm](object, const D &value) { *pm = value; }, scope(*this)); 118211986Sandreas.sandberg@arm.com def_property_static(name, fget, fset, return_value_policy::reference, extra...); 118311986Sandreas.sandberg@arm.com return *this; 118411986Sandreas.sandberg@arm.com } 118511986Sandreas.sandberg@arm.com 118611986Sandreas.sandberg@arm.com template <typename D, typename... Extra> 118711986Sandreas.sandberg@arm.com class_ &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) { 118811986Sandreas.sandberg@arm.com cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this)); 118911986Sandreas.sandberg@arm.com def_property_readonly_static(name, fget, return_value_policy::reference, extra...); 119011986Sandreas.sandberg@arm.com return *this; 119111986Sandreas.sandberg@arm.com } 119211986Sandreas.sandberg@arm.com 119311986Sandreas.sandberg@arm.com /// Uses return_value_policy::reference_internal by default 119411986Sandreas.sandberg@arm.com template <typename Getter, typename... Extra> 119511986Sandreas.sandberg@arm.com class_ &def_property_readonly(const char *name, const Getter &fget, const Extra& ...extra) { 119612391Sjason@lowepower.com return def_property_readonly(name, cpp_function(method_adaptor<type>(fget)), 119712391Sjason@lowepower.com return_value_policy::reference_internal, extra...); 119811986Sandreas.sandberg@arm.com } 119911986Sandreas.sandberg@arm.com 120011986Sandreas.sandberg@arm.com /// Uses cpp_function's return_value_policy by default 120111986Sandreas.sandberg@arm.com template <typename... Extra> 120211986Sandreas.sandberg@arm.com class_ &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) { 120311986Sandreas.sandberg@arm.com return def_property(name, fget, cpp_function(), extra...); 120411986Sandreas.sandberg@arm.com } 120511986Sandreas.sandberg@arm.com 120611986Sandreas.sandberg@arm.com /// Uses return_value_policy::reference by default 120711986Sandreas.sandberg@arm.com template <typename Getter, typename... Extra> 120811986Sandreas.sandberg@arm.com class_ &def_property_readonly_static(const char *name, const Getter &fget, const Extra& ...extra) { 120911986Sandreas.sandberg@arm.com return def_property_readonly_static(name, cpp_function(fget), return_value_policy::reference, extra...); 121011986Sandreas.sandberg@arm.com } 121111986Sandreas.sandberg@arm.com 121211986Sandreas.sandberg@arm.com /// Uses cpp_function's return_value_policy by default 121311986Sandreas.sandberg@arm.com template <typename... Extra> 121411986Sandreas.sandberg@arm.com class_ &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) { 121511986Sandreas.sandberg@arm.com return def_property_static(name, fget, cpp_function(), extra...); 121611986Sandreas.sandberg@arm.com } 121711986Sandreas.sandberg@arm.com 121811986Sandreas.sandberg@arm.com /// Uses return_value_policy::reference_internal by default 121912391Sjason@lowepower.com template <typename Getter, typename Setter, typename... Extra> 122012391Sjason@lowepower.com class_ &def_property(const char *name, const Getter &fget, const Setter &fset, const Extra& ...extra) { 122112391Sjason@lowepower.com return def_property(name, fget, cpp_function(method_adaptor<type>(fset)), extra...); 122212391Sjason@lowepower.com } 122311986Sandreas.sandberg@arm.com template <typename Getter, typename... Extra> 122411986Sandreas.sandberg@arm.com class_ &def_property(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) { 122512391Sjason@lowepower.com return def_property(name, cpp_function(method_adaptor<type>(fget)), fset, 122612391Sjason@lowepower.com return_value_policy::reference_internal, extra...); 122711986Sandreas.sandberg@arm.com } 122811986Sandreas.sandberg@arm.com 122911986Sandreas.sandberg@arm.com /// Uses cpp_function's return_value_policy by default 123011986Sandreas.sandberg@arm.com template <typename... Extra> 123111986Sandreas.sandberg@arm.com class_ &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) { 123211986Sandreas.sandberg@arm.com return def_property_static(name, fget, fset, is_method(*this), extra...); 123311986Sandreas.sandberg@arm.com } 123411986Sandreas.sandberg@arm.com 123511986Sandreas.sandberg@arm.com /// Uses return_value_policy::reference by default 123611986Sandreas.sandberg@arm.com template <typename Getter, typename... Extra> 123711986Sandreas.sandberg@arm.com class_ &def_property_static(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) { 123811986Sandreas.sandberg@arm.com return def_property_static(name, cpp_function(fget), fset, return_value_policy::reference, extra...); 123911986Sandreas.sandberg@arm.com } 124011986Sandreas.sandberg@arm.com 124111986Sandreas.sandberg@arm.com /// Uses cpp_function's return_value_policy by default 124211986Sandreas.sandberg@arm.com template <typename... Extra> 124311986Sandreas.sandberg@arm.com class_ &def_property_static(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) { 124411986Sandreas.sandberg@arm.com auto rec_fget = get_function_record(fget), rec_fset = get_function_record(fset); 124511986Sandreas.sandberg@arm.com char *doc_prev = rec_fget->doc; /* 'extra' field may include a property-specific documentation string */ 124611986Sandreas.sandberg@arm.com detail::process_attributes<Extra...>::init(extra..., rec_fget); 124711986Sandreas.sandberg@arm.com if (rec_fget->doc && rec_fget->doc != doc_prev) { 124811986Sandreas.sandberg@arm.com free(doc_prev); 124911986Sandreas.sandberg@arm.com rec_fget->doc = strdup(rec_fget->doc); 125011986Sandreas.sandberg@arm.com } 125111986Sandreas.sandberg@arm.com if (rec_fset) { 125211986Sandreas.sandberg@arm.com doc_prev = rec_fset->doc; 125311986Sandreas.sandberg@arm.com detail::process_attributes<Extra...>::init(extra..., rec_fset); 125411986Sandreas.sandberg@arm.com if (rec_fset->doc && rec_fset->doc != doc_prev) { 125511986Sandreas.sandberg@arm.com free(doc_prev); 125611986Sandreas.sandberg@arm.com rec_fset->doc = strdup(rec_fset->doc); 125711986Sandreas.sandberg@arm.com } 125811986Sandreas.sandberg@arm.com } 125912037Sandreas.sandberg@arm.com def_property_static_impl(name, fget, fset, rec_fget); 126011986Sandreas.sandberg@arm.com return *this; 126111986Sandreas.sandberg@arm.com } 126211986Sandreas.sandberg@arm.com 126311986Sandreas.sandberg@arm.comprivate: 126411986Sandreas.sandberg@arm.com /// Initialize holder object, variant 1: object derives from enable_shared_from_this 126511986Sandreas.sandberg@arm.com template <typename T> 126612391Sjason@lowepower.com static void init_holder(detail::instance *inst, detail::value_and_holder &v_h, 126712391Sjason@lowepower.com const holder_type * /* unused */, const std::enable_shared_from_this<T> * /* dummy */) { 126811986Sandreas.sandberg@arm.com try { 126912391Sjason@lowepower.com auto sh = std::dynamic_pointer_cast<typename holder_type::element_type>( 127012391Sjason@lowepower.com v_h.value_ptr<type>()->shared_from_this()); 127112391Sjason@lowepower.com if (sh) { 127212391Sjason@lowepower.com new (&v_h.holder<holder_type>()) holder_type(std::move(sh)); 127312391Sjason@lowepower.com v_h.set_holder_constructed(); 127411986Sandreas.sandberg@arm.com } 127512391Sjason@lowepower.com } catch (const std::bad_weak_ptr &) {} 127612391Sjason@lowepower.com 127712391Sjason@lowepower.com if (!v_h.holder_constructed() && inst->owned) { 127812391Sjason@lowepower.com new (&v_h.holder<holder_type>()) holder_type(v_h.value_ptr<type>()); 127912391Sjason@lowepower.com v_h.set_holder_constructed(); 128011986Sandreas.sandberg@arm.com } 128111986Sandreas.sandberg@arm.com } 128211986Sandreas.sandberg@arm.com 128312391Sjason@lowepower.com static void init_holder_from_existing(const detail::value_and_holder &v_h, 128412391Sjason@lowepower.com const holder_type *holder_ptr, std::true_type /*is_copy_constructible*/) { 128512391Sjason@lowepower.com new (&v_h.holder<holder_type>()) holder_type(*reinterpret_cast<const holder_type *>(holder_ptr)); 128612037Sandreas.sandberg@arm.com } 128712037Sandreas.sandberg@arm.com 128812391Sjason@lowepower.com static void init_holder_from_existing(const detail::value_and_holder &v_h, 128912391Sjason@lowepower.com const holder_type *holder_ptr, std::false_type /*is_copy_constructible*/) { 129012391Sjason@lowepower.com new (&v_h.holder<holder_type>()) holder_type(std::move(*const_cast<holder_type *>(holder_ptr))); 129112037Sandreas.sandberg@arm.com } 129212037Sandreas.sandberg@arm.com 129311986Sandreas.sandberg@arm.com /// Initialize holder object, variant 2: try to construct from existing holder object, if possible 129412391Sjason@lowepower.com static void init_holder(detail::instance *inst, detail::value_and_holder &v_h, 129512391Sjason@lowepower.com const holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) { 129611986Sandreas.sandberg@arm.com if (holder_ptr) { 129712391Sjason@lowepower.com init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible<holder_type>()); 129812391Sjason@lowepower.com v_h.set_holder_constructed(); 129912037Sandreas.sandberg@arm.com } else if (inst->owned || detail::always_construct_holder<holder_type>::value) { 130012391Sjason@lowepower.com new (&v_h.holder<holder_type>()) holder_type(v_h.value_ptr<type>()); 130112391Sjason@lowepower.com v_h.set_holder_constructed(); 130211986Sandreas.sandberg@arm.com } 130311986Sandreas.sandberg@arm.com } 130411986Sandreas.sandberg@arm.com 130512391Sjason@lowepower.com /// Performs instance initialization including constructing a holder and registering the known 130612391Sjason@lowepower.com /// instance. Should be called as soon as the `type` value_ptr is set for an instance. Takes an 130712391Sjason@lowepower.com /// optional pointer to an existing holder to use; if not specified and the instance is 130812391Sjason@lowepower.com /// `.owned`, a new holder will be constructed to manage the value pointer. 130912391Sjason@lowepower.com static void init_instance(detail::instance *inst, const void *holder_ptr) { 131012391Sjason@lowepower.com auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type))); 131112391Sjason@lowepower.com if (!v_h.instance_registered()) { 131212391Sjason@lowepower.com register_instance(inst, v_h.value_ptr(), v_h.type); 131312391Sjason@lowepower.com v_h.set_instance_registered(); 131412391Sjason@lowepower.com } 131512391Sjason@lowepower.com init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>()); 131611986Sandreas.sandberg@arm.com } 131711986Sandreas.sandberg@arm.com 131812391Sjason@lowepower.com /// Deallocates an instance; via holder, if constructed; otherwise via operator delete. 131912391Sjason@lowepower.com static void dealloc(detail::value_and_holder &v_h) { 132012391Sjason@lowepower.com if (v_h.holder_constructed()) { 132112391Sjason@lowepower.com v_h.holder<holder_type>().~holder_type(); 132212391Sjason@lowepower.com v_h.set_holder_constructed(false); 132312391Sjason@lowepower.com } 132412391Sjason@lowepower.com else { 132512391Sjason@lowepower.com detail::call_operator_delete(v_h.value_ptr<type>(), v_h.type->type_size); 132612391Sjason@lowepower.com } 132712391Sjason@lowepower.com v_h.value_ptr() = nullptr; 132811986Sandreas.sandberg@arm.com } 132911986Sandreas.sandberg@arm.com 133011986Sandreas.sandberg@arm.com static detail::function_record *get_function_record(handle h) { 133111986Sandreas.sandberg@arm.com h = detail::get_function(h); 133212037Sandreas.sandberg@arm.com return h ? (detail::function_record *) reinterpret_borrow<capsule>(PyCFunction_GET_SELF(h.ptr())) 133311986Sandreas.sandberg@arm.com : nullptr; 133411986Sandreas.sandberg@arm.com } 133511986Sandreas.sandberg@arm.com}; 133611986Sandreas.sandberg@arm.com 133712391Sjason@lowepower.com/// Binds an existing constructor taking arguments Args... 133812391Sjason@lowepower.comtemplate <typename... Args> detail::initimpl::constructor<Args...> init() { return {}; } 133912391Sjason@lowepower.com/// Like `init<Args...>()`, but the instance is always constructed through the alias class (even 134012391Sjason@lowepower.com/// when not inheriting on the Python side). 134112391Sjason@lowepower.comtemplate <typename... Args> detail::initimpl::alias_constructor<Args...> init_alias() { return {}; } 134212391Sjason@lowepower.com 134312391Sjason@lowepower.com/// Binds a factory function as a constructor 134412391Sjason@lowepower.comtemplate <typename Func, typename Ret = detail::initimpl::factory<Func>> 134512391Sjason@lowepower.comRet init(Func &&f) { return {std::forward<Func>(f)}; } 134612391Sjason@lowepower.com 134712391Sjason@lowepower.com/// Dual-argument factory function: the first function is called when no alias is needed, the second 134812391Sjason@lowepower.com/// when an alias is needed (i.e. due to python-side inheritance). Arguments must be identical. 134912391Sjason@lowepower.comtemplate <typename CFunc, typename AFunc, typename Ret = detail::initimpl::factory<CFunc, AFunc>> 135012391Sjason@lowepower.comRet init(CFunc &&c, AFunc &&a) { 135112391Sjason@lowepower.com return {std::forward<CFunc>(c), std::forward<AFunc>(a)}; 135212391Sjason@lowepower.com} 135312391Sjason@lowepower.com 135412391Sjason@lowepower.com/// Binds pickling functions `__getstate__` and `__setstate__` and ensures that the type 135512391Sjason@lowepower.com/// returned by `__getstate__` is the same as the argument accepted by `__setstate__`. 135612391Sjason@lowepower.comtemplate <typename GetState, typename SetState> 135712391Sjason@lowepower.comdetail::initimpl::pickle_factory<GetState, SetState> pickle(GetState &&g, SetState &&s) { 135812391Sjason@lowepower.com return {std::forward<GetState>(g), std::forward<SetState>(s)}; 135912391Sjason@lowepower.com} 136012391Sjason@lowepower.com 136111986Sandreas.sandberg@arm.com/// Binds C++ enumerations and enumeration classes to Python 136211986Sandreas.sandberg@arm.comtemplate <typename Type> class enum_ : public class_<Type> { 136311986Sandreas.sandberg@arm.compublic: 136411986Sandreas.sandberg@arm.com using class_<Type>::def; 136512037Sandreas.sandberg@arm.com using class_<Type>::def_property_readonly_static; 136611986Sandreas.sandberg@arm.com using Scalar = typename std::underlying_type<Type>::type; 136711986Sandreas.sandberg@arm.com 136811986Sandreas.sandberg@arm.com template <typename... Extra> 136911986Sandreas.sandberg@arm.com enum_(const handle &scope, const char *name, const Extra&... extra) 137012037Sandreas.sandberg@arm.com : class_<Type>(scope, name, extra...), m_entries(), m_parent(scope) { 137111986Sandreas.sandberg@arm.com 137212391Sjason@lowepower.com constexpr bool is_arithmetic = detail::any_of<std::is_same<arithmetic, Extra>...>::value; 137311986Sandreas.sandberg@arm.com 137412037Sandreas.sandberg@arm.com auto m_entries_ptr = m_entries.inc_ref().ptr(); 137512037Sandreas.sandberg@arm.com def("__repr__", [name, m_entries_ptr](Type value) -> pybind11::str { 137612037Sandreas.sandberg@arm.com for (const auto &kv : reinterpret_borrow<dict>(m_entries_ptr)) { 137712037Sandreas.sandberg@arm.com if (pybind11::cast<Type>(kv.second) == value) 137812037Sandreas.sandberg@arm.com return pybind11::str("{}.{}").format(name, kv.first); 137912037Sandreas.sandberg@arm.com } 138012037Sandreas.sandberg@arm.com return pybind11::str("{}.???").format(name); 138111986Sandreas.sandberg@arm.com }); 138212037Sandreas.sandberg@arm.com def_property_readonly_static("__members__", [m_entries_ptr](object /* self */) { 138312037Sandreas.sandberg@arm.com dict m; 138412037Sandreas.sandberg@arm.com for (const auto &kv : reinterpret_borrow<dict>(m_entries_ptr)) 138512037Sandreas.sandberg@arm.com m[kv.first] = kv.second; 138612037Sandreas.sandberg@arm.com return m; 138712037Sandreas.sandberg@arm.com }, return_value_policy::copy); 138812391Sjason@lowepower.com def(init([](Scalar i) { return static_cast<Type>(i); })); 138911986Sandreas.sandberg@arm.com def("__int__", [](Type value) { return (Scalar) value; }); 139012391Sjason@lowepower.com #if PY_MAJOR_VERSION < 3 139112391Sjason@lowepower.com def("__long__", [](Type value) { return (Scalar) value; }); 139212391Sjason@lowepower.com #endif 139311986Sandreas.sandberg@arm.com def("__eq__", [](const Type &value, Type *value2) { return value2 && value == *value2; }); 139411986Sandreas.sandberg@arm.com def("__ne__", [](const Type &value, Type *value2) { return !value2 || value != *value2; }); 139511986Sandreas.sandberg@arm.com if (is_arithmetic) { 139611986Sandreas.sandberg@arm.com def("__lt__", [](const Type &value, Type *value2) { return value2 && value < *value2; }); 139711986Sandreas.sandberg@arm.com def("__gt__", [](const Type &value, Type *value2) { return value2 && value > *value2; }); 139811986Sandreas.sandberg@arm.com def("__le__", [](const Type &value, Type *value2) { return value2 && value <= *value2; }); 139911986Sandreas.sandberg@arm.com def("__ge__", [](const Type &value, Type *value2) { return value2 && value >= *value2; }); 140011986Sandreas.sandberg@arm.com } 140111986Sandreas.sandberg@arm.com if (std::is_convertible<Type, Scalar>::value) { 140211986Sandreas.sandberg@arm.com // Don't provide comparison with the underlying type if the enum isn't convertible, 140311986Sandreas.sandberg@arm.com // i.e. if Type is a scoped enum, mirroring the C++ behaviour. (NB: we explicitly 140411986Sandreas.sandberg@arm.com // convert Type to Scalar below anyway because this needs to compile). 140511986Sandreas.sandberg@arm.com def("__eq__", [](const Type &value, Scalar value2) { return (Scalar) value == value2; }); 140611986Sandreas.sandberg@arm.com def("__ne__", [](const Type &value, Scalar value2) { return (Scalar) value != value2; }); 140711986Sandreas.sandberg@arm.com if (is_arithmetic) { 140811986Sandreas.sandberg@arm.com def("__lt__", [](const Type &value, Scalar value2) { return (Scalar) value < value2; }); 140911986Sandreas.sandberg@arm.com def("__gt__", [](const Type &value, Scalar value2) { return (Scalar) value > value2; }); 141011986Sandreas.sandberg@arm.com def("__le__", [](const Type &value, Scalar value2) { return (Scalar) value <= value2; }); 141111986Sandreas.sandberg@arm.com def("__ge__", [](const Type &value, Scalar value2) { return (Scalar) value >= value2; }); 141211986Sandreas.sandberg@arm.com def("__invert__", [](const Type &value) { return ~((Scalar) value); }); 141311986Sandreas.sandberg@arm.com def("__and__", [](const Type &value, Scalar value2) { return (Scalar) value & value2; }); 141411986Sandreas.sandberg@arm.com def("__or__", [](const Type &value, Scalar value2) { return (Scalar) value | value2; }); 141511986Sandreas.sandberg@arm.com def("__xor__", [](const Type &value, Scalar value2) { return (Scalar) value ^ value2; }); 141611986Sandreas.sandberg@arm.com def("__rand__", [](const Type &value, Scalar value2) { return (Scalar) value & value2; }); 141711986Sandreas.sandberg@arm.com def("__ror__", [](const Type &value, Scalar value2) { return (Scalar) value | value2; }); 141811986Sandreas.sandberg@arm.com def("__rxor__", [](const Type &value, Scalar value2) { return (Scalar) value ^ value2; }); 141911986Sandreas.sandberg@arm.com def("__and__", [](const Type &value, const Type &value2) { return (Scalar) value & (Scalar) value2; }); 142011986Sandreas.sandberg@arm.com def("__or__", [](const Type &value, const Type &value2) { return (Scalar) value | (Scalar) value2; }); 142111986Sandreas.sandberg@arm.com def("__xor__", [](const Type &value, const Type &value2) { return (Scalar) value ^ (Scalar) value2; }); 142211986Sandreas.sandberg@arm.com } 142311986Sandreas.sandberg@arm.com } 142411986Sandreas.sandberg@arm.com def("__hash__", [](const Type &value) { return (Scalar) value; }); 142511986Sandreas.sandberg@arm.com // Pickling and unpickling -- needed for use with the 'multiprocessing' module 142612391Sjason@lowepower.com def(pickle([](const Type &value) { return pybind11::make_tuple((Scalar) value); }, 142712391Sjason@lowepower.com [](tuple t) { return static_cast<Type>(t[0].cast<Scalar>()); })); 142811986Sandreas.sandberg@arm.com } 142911986Sandreas.sandberg@arm.com 143011986Sandreas.sandberg@arm.com /// Export enumeration entries into the parent scope 143112037Sandreas.sandberg@arm.com enum_& export_values() { 143212037Sandreas.sandberg@arm.com for (const auto &kv : m_entries) 143312037Sandreas.sandberg@arm.com m_parent.attr(kv.first) = kv.second; 143411986Sandreas.sandberg@arm.com return *this; 143511986Sandreas.sandberg@arm.com } 143611986Sandreas.sandberg@arm.com 143711986Sandreas.sandberg@arm.com /// Add an enumeration entry 143811986Sandreas.sandberg@arm.com enum_& value(char const* name, Type value) { 143912037Sandreas.sandberg@arm.com auto v = pybind11::cast(value, return_value_policy::copy); 144012037Sandreas.sandberg@arm.com this->attr(name) = v; 144112037Sandreas.sandberg@arm.com m_entries[pybind11::str(name)] = v; 144211986Sandreas.sandberg@arm.com return *this; 144311986Sandreas.sandberg@arm.com } 144412037Sandreas.sandberg@arm.com 144511986Sandreas.sandberg@arm.comprivate: 144612037Sandreas.sandberg@arm.com dict m_entries; 144711986Sandreas.sandberg@arm.com handle m_parent; 144811986Sandreas.sandberg@arm.com}; 144911986Sandreas.sandberg@arm.com 145011986Sandreas.sandberg@arm.comNAMESPACE_BEGIN(detail) 145111986Sandreas.sandberg@arm.com 145211986Sandreas.sandberg@arm.com 145311986Sandreas.sandberg@arm.cominline void keep_alive_impl(handle nurse, handle patient) { 145411986Sandreas.sandberg@arm.com if (!nurse || !patient) 145511986Sandreas.sandberg@arm.com pybind11_fail("Could not activate keep_alive!"); 145611986Sandreas.sandberg@arm.com 145711986Sandreas.sandberg@arm.com if (patient.is_none() || nurse.is_none()) 145811986Sandreas.sandberg@arm.com return; /* Nothing to keep alive or nothing to be kept alive by */ 145911986Sandreas.sandberg@arm.com 146012391Sjason@lowepower.com auto tinfo = all_type_info(Py_TYPE(nurse.ptr())); 146112391Sjason@lowepower.com if (!tinfo.empty()) { 146212391Sjason@lowepower.com /* It's a pybind-registered type, so we can store the patient in the 146312391Sjason@lowepower.com * internal list. */ 146412391Sjason@lowepower.com add_patient(nurse.ptr(), patient.ptr()); 146512391Sjason@lowepower.com } 146612391Sjason@lowepower.com else { 146712391Sjason@lowepower.com /* Fall back to clever approach based on weak references taken from 146812391Sjason@lowepower.com * Boost.Python. This is not used for pybind-registered types because 146912391Sjason@lowepower.com * the objects can be destroyed out-of-order in a GC pass. */ 147012391Sjason@lowepower.com cpp_function disable_lifesupport( 147112391Sjason@lowepower.com [patient](handle weakref) { patient.dec_ref(); weakref.dec_ref(); }); 147211986Sandreas.sandberg@arm.com 147312391Sjason@lowepower.com weakref wr(nurse, disable_lifesupport); 147411986Sandreas.sandberg@arm.com 147512391Sjason@lowepower.com patient.inc_ref(); /* reference patient and leak the weak reference */ 147612391Sjason@lowepower.com (void) wr.release(); 147712391Sjason@lowepower.com } 147811986Sandreas.sandberg@arm.com} 147911986Sandreas.sandberg@arm.com 148012037Sandreas.sandberg@arm.comPYBIND11_NOINLINE inline void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret) { 148112391Sjason@lowepower.com auto get_arg = [&](size_t n) { 148212391Sjason@lowepower.com if (n == 0) 148312391Sjason@lowepower.com return ret; 148412391Sjason@lowepower.com else if (n == 1 && call.init_self) 148512391Sjason@lowepower.com return call.init_self; 148612391Sjason@lowepower.com else if (n <= call.args.size()) 148712391Sjason@lowepower.com return call.args[n - 1]; 148812391Sjason@lowepower.com return handle(); 148912391Sjason@lowepower.com }; 149012391Sjason@lowepower.com 149112391Sjason@lowepower.com keep_alive_impl(get_arg(Nurse), get_arg(Patient)); 149212391Sjason@lowepower.com} 149312391Sjason@lowepower.com 149412391Sjason@lowepower.cominline std::pair<decltype(internals::registered_types_py)::iterator, bool> all_type_info_get_cache(PyTypeObject *type) { 149512391Sjason@lowepower.com auto res = get_internals().registered_types_py 149612391Sjason@lowepower.com#ifdef __cpp_lib_unordered_map_try_emplace 149712391Sjason@lowepower.com .try_emplace(type); 149812391Sjason@lowepower.com#else 149912391Sjason@lowepower.com .emplace(type, std::vector<detail::type_info *>()); 150012391Sjason@lowepower.com#endif 150112391Sjason@lowepower.com if (res.second) { 150212391Sjason@lowepower.com // New cache entry created; set up a weak reference to automatically remove it if the type 150312391Sjason@lowepower.com // gets destroyed: 150412391Sjason@lowepower.com weakref((PyObject *) type, cpp_function([type](handle wr) { 150512391Sjason@lowepower.com get_internals().registered_types_py.erase(type); 150612391Sjason@lowepower.com wr.dec_ref(); 150712391Sjason@lowepower.com })).release(); 150812391Sjason@lowepower.com } 150912391Sjason@lowepower.com 151012391Sjason@lowepower.com return res; 151111986Sandreas.sandberg@arm.com} 151211986Sandreas.sandberg@arm.com 151311986Sandreas.sandberg@arm.comtemplate <typename Iterator, typename Sentinel, bool KeyIterator, return_value_policy Policy> 151411986Sandreas.sandberg@arm.comstruct iterator_state { 151511986Sandreas.sandberg@arm.com Iterator it; 151611986Sandreas.sandberg@arm.com Sentinel end; 151712391Sjason@lowepower.com bool first_or_done; 151811986Sandreas.sandberg@arm.com}; 151911986Sandreas.sandberg@arm.com 152011986Sandreas.sandberg@arm.comNAMESPACE_END(detail) 152111986Sandreas.sandberg@arm.com 152212037Sandreas.sandberg@arm.com/// Makes a python iterator from a first and past-the-end C++ InputIterator. 152311986Sandreas.sandberg@arm.comtemplate <return_value_policy Policy = return_value_policy::reference_internal, 152411986Sandreas.sandberg@arm.com typename Iterator, 152511986Sandreas.sandberg@arm.com typename Sentinel, 152611986Sandreas.sandberg@arm.com typename ValueType = decltype(*std::declval<Iterator>()), 152711986Sandreas.sandberg@arm.com typename... Extra> 152811986Sandreas.sandberg@arm.comiterator make_iterator(Iterator first, Sentinel last, Extra &&... extra) { 152911986Sandreas.sandberg@arm.com typedef detail::iterator_state<Iterator, Sentinel, false, Policy> state; 153011986Sandreas.sandberg@arm.com 153111986Sandreas.sandberg@arm.com if (!detail::get_type_info(typeid(state), false)) { 153212391Sjason@lowepower.com class_<state>(handle(), "iterator", pybind11::module_local()) 153311986Sandreas.sandberg@arm.com .def("__iter__", [](state &s) -> state& { return s; }) 153411986Sandreas.sandberg@arm.com .def("__next__", [](state &s) -> ValueType { 153512391Sjason@lowepower.com if (!s.first_or_done) 153611986Sandreas.sandberg@arm.com ++s.it; 153711986Sandreas.sandberg@arm.com else 153812391Sjason@lowepower.com s.first_or_done = false; 153912391Sjason@lowepower.com if (s.it == s.end) { 154012391Sjason@lowepower.com s.first_or_done = true; 154111986Sandreas.sandberg@arm.com throw stop_iteration(); 154212391Sjason@lowepower.com } 154311986Sandreas.sandberg@arm.com return *s.it; 154411986Sandreas.sandberg@arm.com }, std::forward<Extra>(extra)..., Policy); 154511986Sandreas.sandberg@arm.com } 154611986Sandreas.sandberg@arm.com 154712391Sjason@lowepower.com return cast(state{first, last, true}); 154811986Sandreas.sandberg@arm.com} 154911986Sandreas.sandberg@arm.com 155012037Sandreas.sandberg@arm.com/// Makes an python iterator over the keys (`.first`) of a iterator over pairs from a 155112037Sandreas.sandberg@arm.com/// first and past-the-end InputIterator. 155211986Sandreas.sandberg@arm.comtemplate <return_value_policy Policy = return_value_policy::reference_internal, 155311986Sandreas.sandberg@arm.com typename Iterator, 155411986Sandreas.sandberg@arm.com typename Sentinel, 155511986Sandreas.sandberg@arm.com typename KeyType = decltype((*std::declval<Iterator>()).first), 155611986Sandreas.sandberg@arm.com typename... Extra> 155711986Sandreas.sandberg@arm.comiterator make_key_iterator(Iterator first, Sentinel last, Extra &&... extra) { 155811986Sandreas.sandberg@arm.com typedef detail::iterator_state<Iterator, Sentinel, true, Policy> state; 155911986Sandreas.sandberg@arm.com 156011986Sandreas.sandberg@arm.com if (!detail::get_type_info(typeid(state), false)) { 156112391Sjason@lowepower.com class_<state>(handle(), "iterator", pybind11::module_local()) 156211986Sandreas.sandberg@arm.com .def("__iter__", [](state &s) -> state& { return s; }) 156311986Sandreas.sandberg@arm.com .def("__next__", [](state &s) -> KeyType { 156412391Sjason@lowepower.com if (!s.first_or_done) 156511986Sandreas.sandberg@arm.com ++s.it; 156611986Sandreas.sandberg@arm.com else 156712391Sjason@lowepower.com s.first_or_done = false; 156812391Sjason@lowepower.com if (s.it == s.end) { 156912391Sjason@lowepower.com s.first_or_done = true; 157011986Sandreas.sandberg@arm.com throw stop_iteration(); 157112391Sjason@lowepower.com } 157211986Sandreas.sandberg@arm.com return (*s.it).first; 157311986Sandreas.sandberg@arm.com }, std::forward<Extra>(extra)..., Policy); 157411986Sandreas.sandberg@arm.com } 157511986Sandreas.sandberg@arm.com 157612391Sjason@lowepower.com return cast(state{first, last, true}); 157711986Sandreas.sandberg@arm.com} 157811986Sandreas.sandberg@arm.com 157912037Sandreas.sandberg@arm.com/// Makes an iterator over values of an stl container or other container supporting 158012037Sandreas.sandberg@arm.com/// `std::begin()`/`std::end()` 158111986Sandreas.sandberg@arm.comtemplate <return_value_policy Policy = return_value_policy::reference_internal, 158211986Sandreas.sandberg@arm.com typename Type, typename... Extra> iterator make_iterator(Type &value, Extra&&... extra) { 158311986Sandreas.sandberg@arm.com return make_iterator<Policy>(std::begin(value), std::end(value), extra...); 158411986Sandreas.sandberg@arm.com} 158511986Sandreas.sandberg@arm.com 158612037Sandreas.sandberg@arm.com/// Makes an iterator over the keys (`.first`) of a stl map-like container supporting 158712037Sandreas.sandberg@arm.com/// `std::begin()`/`std::end()` 158811986Sandreas.sandberg@arm.comtemplate <return_value_policy Policy = return_value_policy::reference_internal, 158911986Sandreas.sandberg@arm.com typename Type, typename... Extra> iterator make_key_iterator(Type &value, Extra&&... extra) { 159011986Sandreas.sandberg@arm.com return make_key_iterator<Policy>(std::begin(value), std::end(value), extra...); 159111986Sandreas.sandberg@arm.com} 159211986Sandreas.sandberg@arm.com 159311986Sandreas.sandberg@arm.comtemplate <typename InputType, typename OutputType> void implicitly_convertible() { 159412391Sjason@lowepower.com struct set_flag { 159512391Sjason@lowepower.com bool &flag; 159612391Sjason@lowepower.com set_flag(bool &flag) : flag(flag) { flag = true; } 159712391Sjason@lowepower.com ~set_flag() { flag = false; } 159812391Sjason@lowepower.com }; 159911986Sandreas.sandberg@arm.com auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject * { 160012391Sjason@lowepower.com static bool currently_used = false; 160112391Sjason@lowepower.com if (currently_used) // implicit conversions are non-reentrant 160212391Sjason@lowepower.com return nullptr; 160312391Sjason@lowepower.com set_flag flag_helper(currently_used); 160412037Sandreas.sandberg@arm.com if (!detail::make_caster<InputType>().load(obj, false)) 160511986Sandreas.sandberg@arm.com return nullptr; 160611986Sandreas.sandberg@arm.com tuple args(1); 160711986Sandreas.sandberg@arm.com args[0] = obj; 160811986Sandreas.sandberg@arm.com PyObject *result = PyObject_Call((PyObject *) type, args.ptr(), nullptr); 160911986Sandreas.sandberg@arm.com if (result == nullptr) 161011986Sandreas.sandberg@arm.com PyErr_Clear(); 161111986Sandreas.sandberg@arm.com return result; 161211986Sandreas.sandberg@arm.com }; 161311986Sandreas.sandberg@arm.com 161411986Sandreas.sandberg@arm.com if (auto tinfo = detail::get_type_info(typeid(OutputType))) 161511986Sandreas.sandberg@arm.com tinfo->implicit_conversions.push_back(implicit_caster); 161611986Sandreas.sandberg@arm.com else 161711986Sandreas.sandberg@arm.com pybind11_fail("implicitly_convertible: Unable to find type " + type_id<OutputType>()); 161811986Sandreas.sandberg@arm.com} 161911986Sandreas.sandberg@arm.com 162011986Sandreas.sandberg@arm.comtemplate <typename ExceptionTranslator> 162111986Sandreas.sandberg@arm.comvoid register_exception_translator(ExceptionTranslator&& translator) { 162211986Sandreas.sandberg@arm.com detail::get_internals().registered_exception_translators.push_front( 162311986Sandreas.sandberg@arm.com std::forward<ExceptionTranslator>(translator)); 162411986Sandreas.sandberg@arm.com} 162511986Sandreas.sandberg@arm.com 162612391Sjason@lowepower.com/** 162712391Sjason@lowepower.com * Wrapper to generate a new Python exception type. 162811986Sandreas.sandberg@arm.com * 162911986Sandreas.sandberg@arm.com * This should only be used with PyErr_SetString for now. 163011986Sandreas.sandberg@arm.com * It is not (yet) possible to use as a py::base. 163111986Sandreas.sandberg@arm.com * Template type argument is reserved for future use. 163211986Sandreas.sandberg@arm.com */ 163311986Sandreas.sandberg@arm.comtemplate <typename type> 163411986Sandreas.sandberg@arm.comclass exception : public object { 163511986Sandreas.sandberg@arm.compublic: 163611986Sandreas.sandberg@arm.com exception(handle scope, const char *name, PyObject *base = PyExc_Exception) { 163711986Sandreas.sandberg@arm.com std::string full_name = scope.attr("__name__").cast<std::string>() + 163811986Sandreas.sandberg@arm.com std::string(".") + name; 163912037Sandreas.sandberg@arm.com m_ptr = PyErr_NewException(const_cast<char *>(full_name.c_str()), base, NULL); 164011986Sandreas.sandberg@arm.com if (hasattr(scope, name)) 164111986Sandreas.sandberg@arm.com pybind11_fail("Error during initialization: multiple incompatible " 164211986Sandreas.sandberg@arm.com "definitions with name \"" + std::string(name) + "\""); 164311986Sandreas.sandberg@arm.com scope.attr(name) = *this; 164411986Sandreas.sandberg@arm.com } 164511986Sandreas.sandberg@arm.com 164611986Sandreas.sandberg@arm.com // Sets the current python exception to this exception object with the given message 164711986Sandreas.sandberg@arm.com void operator()(const char *message) { 164811986Sandreas.sandberg@arm.com PyErr_SetString(m_ptr, message); 164911986Sandreas.sandberg@arm.com } 165011986Sandreas.sandberg@arm.com}; 165111986Sandreas.sandberg@arm.com 165212391Sjason@lowepower.com/** 165312391Sjason@lowepower.com * Registers a Python exception in `m` of the given `name` and installs an exception translator to 165411986Sandreas.sandberg@arm.com * translate the C++ exception to the created Python exception using the exceptions what() method. 165511986Sandreas.sandberg@arm.com * This is intended for simple exception translations; for more complex translation, register the 165611986Sandreas.sandberg@arm.com * exception object and translator directly. 165711986Sandreas.sandberg@arm.com */ 165811986Sandreas.sandberg@arm.comtemplate <typename CppException> 165911986Sandreas.sandberg@arm.comexception<CppException> ®ister_exception(handle scope, 166011986Sandreas.sandberg@arm.com const char *name, 166111986Sandreas.sandberg@arm.com PyObject *base = PyExc_Exception) { 166211986Sandreas.sandberg@arm.com static exception<CppException> ex(scope, name, base); 166311986Sandreas.sandberg@arm.com register_exception_translator([](std::exception_ptr p) { 166411986Sandreas.sandberg@arm.com if (!p) return; 166511986Sandreas.sandberg@arm.com try { 166611986Sandreas.sandberg@arm.com std::rethrow_exception(p); 166711986Sandreas.sandberg@arm.com } catch (const CppException &e) { 166811986Sandreas.sandberg@arm.com ex(e.what()); 166911986Sandreas.sandberg@arm.com } 167011986Sandreas.sandberg@arm.com }); 167111986Sandreas.sandberg@arm.com return ex; 167211986Sandreas.sandberg@arm.com} 167311986Sandreas.sandberg@arm.com 167411986Sandreas.sandberg@arm.comNAMESPACE_BEGIN(detail) 167511986Sandreas.sandberg@arm.comPYBIND11_NOINLINE inline void print(tuple args, dict kwargs) { 167611986Sandreas.sandberg@arm.com auto strings = tuple(args.size()); 167711986Sandreas.sandberg@arm.com for (size_t i = 0; i < args.size(); ++i) { 167811986Sandreas.sandberg@arm.com strings[i] = str(args[i]); 167911986Sandreas.sandberg@arm.com } 168011986Sandreas.sandberg@arm.com auto sep = kwargs.contains("sep") ? kwargs["sep"] : cast(" "); 168111986Sandreas.sandberg@arm.com auto line = sep.attr("join")(strings); 168211986Sandreas.sandberg@arm.com 168311986Sandreas.sandberg@arm.com object file; 168411986Sandreas.sandberg@arm.com if (kwargs.contains("file")) { 168511986Sandreas.sandberg@arm.com file = kwargs["file"].cast<object>(); 168611986Sandreas.sandberg@arm.com } else { 168711986Sandreas.sandberg@arm.com try { 168811986Sandreas.sandberg@arm.com file = module::import("sys").attr("stdout"); 168911986Sandreas.sandberg@arm.com } catch (const error_already_set &) { 169011986Sandreas.sandberg@arm.com /* If print() is called from code that is executed as 169111986Sandreas.sandberg@arm.com part of garbage collection during interpreter shutdown, 169211986Sandreas.sandberg@arm.com importing 'sys' can fail. Give up rather than crashing the 169311986Sandreas.sandberg@arm.com interpreter in this case. */ 169411986Sandreas.sandberg@arm.com return; 169511986Sandreas.sandberg@arm.com } 169611986Sandreas.sandberg@arm.com } 169711986Sandreas.sandberg@arm.com 169811986Sandreas.sandberg@arm.com auto write = file.attr("write"); 169911986Sandreas.sandberg@arm.com write(line); 170011986Sandreas.sandberg@arm.com write(kwargs.contains("end") ? kwargs["end"] : cast("\n")); 170111986Sandreas.sandberg@arm.com 170211986Sandreas.sandberg@arm.com if (kwargs.contains("flush") && kwargs["flush"].cast<bool>()) 170311986Sandreas.sandberg@arm.com file.attr("flush")(); 170411986Sandreas.sandberg@arm.com} 170511986Sandreas.sandberg@arm.comNAMESPACE_END(detail) 170611986Sandreas.sandberg@arm.com 170711986Sandreas.sandberg@arm.comtemplate <return_value_policy policy = return_value_policy::automatic_reference, typename... Args> 170811986Sandreas.sandberg@arm.comvoid print(Args &&...args) { 170911986Sandreas.sandberg@arm.com auto c = detail::collect_arguments<policy>(std::forward<Args>(args)...); 171011986Sandreas.sandberg@arm.com detail::print(c.args(), c.kwargs()); 171111986Sandreas.sandberg@arm.com} 171211986Sandreas.sandberg@arm.com 171312037Sandreas.sandberg@arm.com#if defined(WITH_THREAD) && !defined(PYPY_VERSION) 171411986Sandreas.sandberg@arm.com 171511986Sandreas.sandberg@arm.com/* The functions below essentially reproduce the PyGILState_* API using a RAII 171611986Sandreas.sandberg@arm.com * pattern, but there are a few important differences: 171711986Sandreas.sandberg@arm.com * 171811986Sandreas.sandberg@arm.com * 1. When acquiring the GIL from an non-main thread during the finalization 171911986Sandreas.sandberg@arm.com * phase, the GILState API blindly terminates the calling thread, which 172011986Sandreas.sandberg@arm.com * is often not what is wanted. This API does not do this. 172111986Sandreas.sandberg@arm.com * 172211986Sandreas.sandberg@arm.com * 2. The gil_scoped_release function can optionally cut the relationship 172311986Sandreas.sandberg@arm.com * of a PyThreadState and its associated thread, which allows moving it to 172411986Sandreas.sandberg@arm.com * another thread (this is a fairly rare/advanced use case). 172511986Sandreas.sandberg@arm.com * 172611986Sandreas.sandberg@arm.com * 3. The reference count of an acquired thread state can be controlled. This 172711986Sandreas.sandberg@arm.com * can be handy to prevent cases where callbacks issued from an external 172811986Sandreas.sandberg@arm.com * thread would otherwise constantly construct and destroy thread state data 172911986Sandreas.sandberg@arm.com * structures. 173011986Sandreas.sandberg@arm.com * 173111986Sandreas.sandberg@arm.com * See the Python bindings of NanoGUI (http://github.com/wjakob/nanogui) for an 173211986Sandreas.sandberg@arm.com * example which uses features 2 and 3 to migrate the Python thread of 173311986Sandreas.sandberg@arm.com * execution to another thread (to run the event loop on the original thread, 173411986Sandreas.sandberg@arm.com * in this case). 173511986Sandreas.sandberg@arm.com */ 173611986Sandreas.sandberg@arm.com 173711986Sandreas.sandberg@arm.comclass gil_scoped_acquire { 173811986Sandreas.sandberg@arm.compublic: 173911986Sandreas.sandberg@arm.com PYBIND11_NOINLINE gil_scoped_acquire() { 174011986Sandreas.sandberg@arm.com auto const &internals = detail::get_internals(); 174111986Sandreas.sandberg@arm.com tstate = (PyThreadState *) PyThread_get_key_value(internals.tstate); 174211986Sandreas.sandberg@arm.com 174311986Sandreas.sandberg@arm.com if (!tstate) { 174411986Sandreas.sandberg@arm.com tstate = PyThreadState_New(internals.istate); 174511986Sandreas.sandberg@arm.com #if !defined(NDEBUG) 174611986Sandreas.sandberg@arm.com if (!tstate) 174711986Sandreas.sandberg@arm.com pybind11_fail("scoped_acquire: could not create thread state!"); 174811986Sandreas.sandberg@arm.com #endif 174911986Sandreas.sandberg@arm.com tstate->gilstate_counter = 0; 175011986Sandreas.sandberg@arm.com #if PY_MAJOR_VERSION < 3 175111986Sandreas.sandberg@arm.com PyThread_delete_key_value(internals.tstate); 175211986Sandreas.sandberg@arm.com #endif 175311986Sandreas.sandberg@arm.com PyThread_set_key_value(internals.tstate, tstate); 175411986Sandreas.sandberg@arm.com } else { 175511986Sandreas.sandberg@arm.com release = detail::get_thread_state_unchecked() != tstate; 175611986Sandreas.sandberg@arm.com } 175711986Sandreas.sandberg@arm.com 175811986Sandreas.sandberg@arm.com if (release) { 175911986Sandreas.sandberg@arm.com /* Work around an annoying assertion in PyThreadState_Swap */ 176011986Sandreas.sandberg@arm.com #if defined(Py_DEBUG) 176111986Sandreas.sandberg@arm.com PyInterpreterState *interp = tstate->interp; 176211986Sandreas.sandberg@arm.com tstate->interp = nullptr; 176311986Sandreas.sandberg@arm.com #endif 176411986Sandreas.sandberg@arm.com PyEval_AcquireThread(tstate); 176511986Sandreas.sandberg@arm.com #if defined(Py_DEBUG) 176611986Sandreas.sandberg@arm.com tstate->interp = interp; 176711986Sandreas.sandberg@arm.com #endif 176811986Sandreas.sandberg@arm.com } 176911986Sandreas.sandberg@arm.com 177011986Sandreas.sandberg@arm.com inc_ref(); 177111986Sandreas.sandberg@arm.com } 177211986Sandreas.sandberg@arm.com 177311986Sandreas.sandberg@arm.com void inc_ref() { 177411986Sandreas.sandberg@arm.com ++tstate->gilstate_counter; 177511986Sandreas.sandberg@arm.com } 177611986Sandreas.sandberg@arm.com 177711986Sandreas.sandberg@arm.com PYBIND11_NOINLINE void dec_ref() { 177811986Sandreas.sandberg@arm.com --tstate->gilstate_counter; 177911986Sandreas.sandberg@arm.com #if !defined(NDEBUG) 178011986Sandreas.sandberg@arm.com if (detail::get_thread_state_unchecked() != tstate) 178111986Sandreas.sandberg@arm.com pybind11_fail("scoped_acquire::dec_ref(): thread state must be current!"); 178211986Sandreas.sandberg@arm.com if (tstate->gilstate_counter < 0) 178311986Sandreas.sandberg@arm.com pybind11_fail("scoped_acquire::dec_ref(): reference count underflow!"); 178411986Sandreas.sandberg@arm.com #endif 178511986Sandreas.sandberg@arm.com if (tstate->gilstate_counter == 0) { 178611986Sandreas.sandberg@arm.com #if !defined(NDEBUG) 178711986Sandreas.sandberg@arm.com if (!release) 178811986Sandreas.sandberg@arm.com pybind11_fail("scoped_acquire::dec_ref(): internal error!"); 178911986Sandreas.sandberg@arm.com #endif 179011986Sandreas.sandberg@arm.com PyThreadState_Clear(tstate); 179111986Sandreas.sandberg@arm.com PyThreadState_DeleteCurrent(); 179211986Sandreas.sandberg@arm.com PyThread_delete_key_value(detail::get_internals().tstate); 179311986Sandreas.sandberg@arm.com release = false; 179411986Sandreas.sandberg@arm.com } 179511986Sandreas.sandberg@arm.com } 179611986Sandreas.sandberg@arm.com 179711986Sandreas.sandberg@arm.com PYBIND11_NOINLINE ~gil_scoped_acquire() { 179811986Sandreas.sandberg@arm.com dec_ref(); 179911986Sandreas.sandberg@arm.com if (release) 180011986Sandreas.sandberg@arm.com PyEval_SaveThread(); 180111986Sandreas.sandberg@arm.com } 180211986Sandreas.sandberg@arm.comprivate: 180311986Sandreas.sandberg@arm.com PyThreadState *tstate = nullptr; 180411986Sandreas.sandberg@arm.com bool release = true; 180511986Sandreas.sandberg@arm.com}; 180611986Sandreas.sandberg@arm.com 180711986Sandreas.sandberg@arm.comclass gil_scoped_release { 180811986Sandreas.sandberg@arm.compublic: 180911986Sandreas.sandberg@arm.com explicit gil_scoped_release(bool disassoc = false) : disassoc(disassoc) { 181012391Sjason@lowepower.com // `get_internals()` must be called here unconditionally in order to initialize 181112391Sjason@lowepower.com // `internals.tstate` for subsequent `gil_scoped_acquire` calls. Otherwise, an 181212391Sjason@lowepower.com // initialization race could occur as multiple threads try `gil_scoped_acquire`. 181312391Sjason@lowepower.com const auto &internals = detail::get_internals(); 181411986Sandreas.sandberg@arm.com tstate = PyEval_SaveThread(); 181511986Sandreas.sandberg@arm.com if (disassoc) { 181612391Sjason@lowepower.com auto key = internals.tstate; 181711986Sandreas.sandberg@arm.com #if PY_MAJOR_VERSION < 3 181811986Sandreas.sandberg@arm.com PyThread_delete_key_value(key); 181911986Sandreas.sandberg@arm.com #else 182011986Sandreas.sandberg@arm.com PyThread_set_key_value(key, nullptr); 182111986Sandreas.sandberg@arm.com #endif 182211986Sandreas.sandberg@arm.com } 182311986Sandreas.sandberg@arm.com } 182411986Sandreas.sandberg@arm.com ~gil_scoped_release() { 182511986Sandreas.sandberg@arm.com if (!tstate) 182611986Sandreas.sandberg@arm.com return; 182711986Sandreas.sandberg@arm.com PyEval_RestoreThread(tstate); 182811986Sandreas.sandberg@arm.com if (disassoc) { 182911986Sandreas.sandberg@arm.com auto key = detail::get_internals().tstate; 183011986Sandreas.sandberg@arm.com #if PY_MAJOR_VERSION < 3 183111986Sandreas.sandberg@arm.com PyThread_delete_key_value(key); 183211986Sandreas.sandberg@arm.com #endif 183311986Sandreas.sandberg@arm.com PyThread_set_key_value(key, tstate); 183411986Sandreas.sandberg@arm.com } 183511986Sandreas.sandberg@arm.com } 183611986Sandreas.sandberg@arm.comprivate: 183711986Sandreas.sandberg@arm.com PyThreadState *tstate; 183811986Sandreas.sandberg@arm.com bool disassoc; 183911986Sandreas.sandberg@arm.com}; 184012037Sandreas.sandberg@arm.com#elif defined(PYPY_VERSION) 184112037Sandreas.sandberg@arm.comclass gil_scoped_acquire { 184212037Sandreas.sandberg@arm.com PyGILState_STATE state; 184312037Sandreas.sandberg@arm.compublic: 184412037Sandreas.sandberg@arm.com gil_scoped_acquire() { state = PyGILState_Ensure(); } 184512037Sandreas.sandberg@arm.com ~gil_scoped_acquire() { PyGILState_Release(state); } 184612037Sandreas.sandberg@arm.com}; 184712037Sandreas.sandberg@arm.com 184812037Sandreas.sandberg@arm.comclass gil_scoped_release { 184912037Sandreas.sandberg@arm.com PyThreadState *state; 185012037Sandreas.sandberg@arm.compublic: 185112037Sandreas.sandberg@arm.com gil_scoped_release() { state = PyEval_SaveThread(); } 185212037Sandreas.sandberg@arm.com ~gil_scoped_release() { PyEval_RestoreThread(state); } 185312037Sandreas.sandberg@arm.com}; 185411986Sandreas.sandberg@arm.com#else 185511986Sandreas.sandberg@arm.comclass gil_scoped_acquire { }; 185611986Sandreas.sandberg@arm.comclass gil_scoped_release { }; 185711986Sandreas.sandberg@arm.com#endif 185811986Sandreas.sandberg@arm.com 185911986Sandreas.sandberg@arm.comerror_already_set::~error_already_set() { 186012391Sjason@lowepower.com if (type) { 186111986Sandreas.sandberg@arm.com gil_scoped_acquire gil; 186212391Sjason@lowepower.com type.release().dec_ref(); 186312391Sjason@lowepower.com value.release().dec_ref(); 186412391Sjason@lowepower.com trace.release().dec_ref(); 186511986Sandreas.sandberg@arm.com } 186611986Sandreas.sandberg@arm.com} 186711986Sandreas.sandberg@arm.com 186811986Sandreas.sandberg@arm.cominline function get_type_overload(const void *this_ptr, const detail::type_info *this_type, const char *name) { 186912037Sandreas.sandberg@arm.com handle self = detail::get_object_handle(this_ptr, this_type); 187012037Sandreas.sandberg@arm.com if (!self) 187111986Sandreas.sandberg@arm.com return function(); 187212037Sandreas.sandberg@arm.com handle type = self.get_type(); 187311986Sandreas.sandberg@arm.com auto key = std::make_pair(type.ptr(), name); 187411986Sandreas.sandberg@arm.com 187511986Sandreas.sandberg@arm.com /* Cache functions that aren't overloaded in Python to avoid 187611986Sandreas.sandberg@arm.com many costly Python dictionary lookups below */ 187711986Sandreas.sandberg@arm.com auto &cache = detail::get_internals().inactive_overload_cache; 187811986Sandreas.sandberg@arm.com if (cache.find(key) != cache.end()) 187911986Sandreas.sandberg@arm.com return function(); 188011986Sandreas.sandberg@arm.com 188112037Sandreas.sandberg@arm.com function overload = getattr(self, name, function()); 188211986Sandreas.sandberg@arm.com if (overload.is_cpp_function()) { 188311986Sandreas.sandberg@arm.com cache.insert(key); 188411986Sandreas.sandberg@arm.com return function(); 188511986Sandreas.sandberg@arm.com } 188611986Sandreas.sandberg@arm.com 188712037Sandreas.sandberg@arm.com /* Don't call dispatch code if invoked from overridden function. 188812037Sandreas.sandberg@arm.com Unfortunately this doesn't work on PyPy. */ 188912037Sandreas.sandberg@arm.com#if !defined(PYPY_VERSION) 189011986Sandreas.sandberg@arm.com PyFrameObject *frame = PyThreadState_Get()->frame; 189111986Sandreas.sandberg@arm.com if (frame && (std::string) str(frame->f_code->co_name) == name && 189211986Sandreas.sandberg@arm.com frame->f_code->co_argcount > 0) { 189311986Sandreas.sandberg@arm.com PyFrame_FastToLocals(frame); 189411986Sandreas.sandberg@arm.com PyObject *self_caller = PyDict_GetItem( 189511986Sandreas.sandberg@arm.com frame->f_locals, PyTuple_GET_ITEM(frame->f_code->co_varnames, 0)); 189612037Sandreas.sandberg@arm.com if (self_caller == self.ptr()) 189711986Sandreas.sandberg@arm.com return function(); 189811986Sandreas.sandberg@arm.com } 189912037Sandreas.sandberg@arm.com#else 190012037Sandreas.sandberg@arm.com /* PyPy currently doesn't provide a detailed cpyext emulation of 190112037Sandreas.sandberg@arm.com frame objects, so we have to emulate this using Python. This 190212037Sandreas.sandberg@arm.com is going to be slow..*/ 190312037Sandreas.sandberg@arm.com dict d; d["self"] = self; d["name"] = pybind11::str(name); 190412037Sandreas.sandberg@arm.com PyObject *result = PyRun_String( 190512037Sandreas.sandberg@arm.com "import inspect\n" 190612037Sandreas.sandberg@arm.com "frame = inspect.currentframe()\n" 190712037Sandreas.sandberg@arm.com "if frame is not None:\n" 190812037Sandreas.sandberg@arm.com " frame = frame.f_back\n" 190912037Sandreas.sandberg@arm.com " if frame is not None and str(frame.f_code.co_name) == name and " 191012037Sandreas.sandberg@arm.com "frame.f_code.co_argcount > 0:\n" 191112037Sandreas.sandberg@arm.com " self_caller = frame.f_locals[frame.f_code.co_varnames[0]]\n" 191212037Sandreas.sandberg@arm.com " if self_caller == self:\n" 191312037Sandreas.sandberg@arm.com " self = None\n", 191412037Sandreas.sandberg@arm.com Py_file_input, d.ptr(), d.ptr()); 191512037Sandreas.sandberg@arm.com if (result == nullptr) 191612037Sandreas.sandberg@arm.com throw error_already_set(); 191712391Sjason@lowepower.com if (d["self"].is_none()) 191812037Sandreas.sandberg@arm.com return function(); 191912037Sandreas.sandberg@arm.com Py_DECREF(result); 192012037Sandreas.sandberg@arm.com#endif 192112037Sandreas.sandberg@arm.com 192211986Sandreas.sandberg@arm.com return overload; 192311986Sandreas.sandberg@arm.com} 192411986Sandreas.sandberg@arm.com 192511986Sandreas.sandberg@arm.comtemplate <class T> function get_overload(const T *this_ptr, const char *name) { 192611986Sandreas.sandberg@arm.com auto tinfo = detail::get_type_info(typeid(T)); 192711986Sandreas.sandberg@arm.com return tinfo ? get_type_overload(this_ptr, tinfo, name) : function(); 192811986Sandreas.sandberg@arm.com} 192911986Sandreas.sandberg@arm.com 193011986Sandreas.sandberg@arm.com#define PYBIND11_OVERLOAD_INT(ret_type, cname, name, ...) { \ 193111986Sandreas.sandberg@arm.com pybind11::gil_scoped_acquire gil; \ 193211986Sandreas.sandberg@arm.com pybind11::function overload = pybind11::get_overload(static_cast<const cname *>(this), name); \ 193311986Sandreas.sandberg@arm.com if (overload) { \ 193411986Sandreas.sandberg@arm.com auto o = overload(__VA_ARGS__); \ 193511986Sandreas.sandberg@arm.com if (pybind11::detail::cast_is_temporary_value_reference<ret_type>::value) { \ 193611986Sandreas.sandberg@arm.com static pybind11::detail::overload_caster_t<ret_type> caster; \ 193711986Sandreas.sandberg@arm.com return pybind11::detail::cast_ref<ret_type>(std::move(o), caster); \ 193811986Sandreas.sandberg@arm.com } \ 193911986Sandreas.sandberg@arm.com else return pybind11::detail::cast_safe<ret_type>(std::move(o)); \ 194011986Sandreas.sandberg@arm.com } \ 194111986Sandreas.sandberg@arm.com } 194211986Sandreas.sandberg@arm.com 194311986Sandreas.sandberg@arm.com#define PYBIND11_OVERLOAD_NAME(ret_type, cname, name, fn, ...) \ 194411986Sandreas.sandberg@arm.com PYBIND11_OVERLOAD_INT(ret_type, cname, name, __VA_ARGS__) \ 194511986Sandreas.sandberg@arm.com return cname::fn(__VA_ARGS__) 194611986Sandreas.sandberg@arm.com 194711986Sandreas.sandberg@arm.com#define PYBIND11_OVERLOAD_PURE_NAME(ret_type, cname, name, fn, ...) \ 194811986Sandreas.sandberg@arm.com PYBIND11_OVERLOAD_INT(ret_type, cname, name, __VA_ARGS__) \ 194911986Sandreas.sandberg@arm.com pybind11::pybind11_fail("Tried to call pure virtual function \"" #cname "::" name "\""); 195011986Sandreas.sandberg@arm.com 195111986Sandreas.sandberg@arm.com#define PYBIND11_OVERLOAD(ret_type, cname, fn, ...) \ 195211986Sandreas.sandberg@arm.com PYBIND11_OVERLOAD_NAME(ret_type, cname, #fn, fn, __VA_ARGS__) 195311986Sandreas.sandberg@arm.com 195411986Sandreas.sandberg@arm.com#define PYBIND11_OVERLOAD_PURE(ret_type, cname, fn, ...) \ 195511986Sandreas.sandberg@arm.com PYBIND11_OVERLOAD_PURE_NAME(ret_type, cname, #fn, fn, __VA_ARGS__) 195611986Sandreas.sandberg@arm.com 195712391Sjason@lowepower.comNAMESPACE_END(PYBIND11_NAMESPACE) 195811986Sandreas.sandberg@arm.com 195911986Sandreas.sandberg@arm.com#if defined(_MSC_VER) 196011986Sandreas.sandberg@arm.com# pragma warning(pop) 196111986Sandreas.sandberg@arm.com#elif defined(__INTEL_COMPILER) 196211986Sandreas.sandberg@arm.com/* Leave ignored warnings on */ 196311986Sandreas.sandberg@arm.com#elif defined(__GNUG__) && !defined(__clang__) 196411986Sandreas.sandberg@arm.com# pragma GCC diagnostic pop 196511986Sandreas.sandberg@arm.com#endif 1966