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
1314299Sbbruce@ucdavis.edu#if defined(__INTEL_COMPILER)
1414299Sbbruce@ucdavis.edu#  pragma warning push
1514299Sbbruce@ucdavis.edu#  pragma warning disable 68    // integer conversion resulted in a change of sign
1614299Sbbruce@ucdavis.edu#  pragma warning disable 186   // pointless comparison of unsigned integer with zero
1714299Sbbruce@ucdavis.edu#  pragma warning disable 878   // incompatible exception specifications
1814299Sbbruce@ucdavis.edu#  pragma warning disable 1334  // the "template" keyword used for syntactic disambiguation may only be used within a template
1914299Sbbruce@ucdavis.edu#  pragma warning disable 1682  // implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
2014299Sbbruce@ucdavis.edu#  pragma warning disable 1786  // function "strdup" was declared deprecated
2114299Sbbruce@ucdavis.edu#  pragma warning disable 1875  // offsetof applied to non-POD (Plain Old Data) types is nonstandard
2214299Sbbruce@ucdavis.edu#  pragma warning disable 2196  // warning #2196: routine is both "inline" and "noinline"
2314299Sbbruce@ucdavis.edu#elif defined(_MSC_VER)
2411986Sandreas.sandberg@arm.com#  pragma warning(push)
2511986Sandreas.sandberg@arm.com#  pragma warning(disable: 4100) // warning C4100: Unreferenced formal parameter
2611986Sandreas.sandberg@arm.com#  pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
2711986Sandreas.sandberg@arm.com#  pragma warning(disable: 4512) // warning C4512: Assignment operator was implicitly defined as deleted
2811986Sandreas.sandberg@arm.com#  pragma warning(disable: 4800) // warning C4800: 'int': forcing value to bool 'true' or 'false' (performance warning)
2911986Sandreas.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
3011986Sandreas.sandberg@arm.com#  pragma warning(disable: 4702) // warning C4702: unreachable code
3111986Sandreas.sandberg@arm.com#  pragma warning(disable: 4522) // warning C4522: multiple assignment operators specified
3211986Sandreas.sandberg@arm.com#elif defined(__GNUG__) && !defined(__clang__)
3311986Sandreas.sandberg@arm.com#  pragma GCC diagnostic push
3411986Sandreas.sandberg@arm.com#  pragma GCC diagnostic ignored "-Wunused-but-set-parameter"
3511986Sandreas.sandberg@arm.com#  pragma GCC diagnostic ignored "-Wunused-but-set-variable"
3611986Sandreas.sandberg@arm.com#  pragma GCC diagnostic ignored "-Wmissing-field-initializers"
3711986Sandreas.sandberg@arm.com#  pragma GCC diagnostic ignored "-Wstrict-aliasing"
3811986Sandreas.sandberg@arm.com#  pragma GCC diagnostic ignored "-Wattributes"
3912391Sjason@lowepower.com#  if __GNUC__ >= 7
4012391Sjason@lowepower.com#    pragma GCC diagnostic ignored "-Wnoexcept-type"
4112391Sjason@lowepower.com#  endif
4211986Sandreas.sandberg@arm.com#endif
4311986Sandreas.sandberg@arm.com
4411986Sandreas.sandberg@arm.com#include "attr.h"
4511986Sandreas.sandberg@arm.com#include "options.h"
4612391Sjason@lowepower.com#include "detail/class.h"
4712391Sjason@lowepower.com#include "detail/init.h"
4811986Sandreas.sandberg@arm.com
4914299Sbbruce@ucdavis.edu#if defined(__GNUG__) && !defined(__clang__)
5014299Sbbruce@ucdavis.edu#  include <cxxabi.h>
5114299Sbbruce@ucdavis.edu#endif
5214299Sbbruce@ucdavis.edu
5312391Sjason@lowepower.comNAMESPACE_BEGIN(PYBIND11_NAMESPACE)
5411986Sandreas.sandberg@arm.com
5511986Sandreas.sandberg@arm.com/// Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object
5611986Sandreas.sandberg@arm.comclass cpp_function : public function {
5711986Sandreas.sandberg@arm.compublic:
5811986Sandreas.sandberg@arm.com    cpp_function() { }
5914299Sbbruce@ucdavis.edu    cpp_function(std::nullptr_t) { }
6011986Sandreas.sandberg@arm.com
6111986Sandreas.sandberg@arm.com    /// Construct a cpp_function from a vanilla function pointer
6211986Sandreas.sandberg@arm.com    template <typename Return, typename... Args, typename... Extra>
6311986Sandreas.sandberg@arm.com    cpp_function(Return (*f)(Args...), const Extra&... extra) {
6411986Sandreas.sandberg@arm.com        initialize(f, f, extra...);
6511986Sandreas.sandberg@arm.com    }
6611986Sandreas.sandberg@arm.com
6711986Sandreas.sandberg@arm.com    /// Construct a cpp_function from a lambda function (possibly with internal state)
6812391Sjason@lowepower.com    template <typename Func, typename... Extra,
6912391Sjason@lowepower.com              typename = detail::enable_if_t<detail::is_lambda<Func>::value>>
7012037Sandreas.sandberg@arm.com    cpp_function(Func &&f, const Extra&... extra) {
7111986Sandreas.sandberg@arm.com        initialize(std::forward<Func>(f),
7212391Sjason@lowepower.com                   (detail::function_signature_t<Func> *) nullptr, extra...);
7311986Sandreas.sandberg@arm.com    }
7411986Sandreas.sandberg@arm.com
7511986Sandreas.sandberg@arm.com    /// Construct a cpp_function from a class method (non-const)
7611986Sandreas.sandberg@arm.com    template <typename Return, typename Class, typename... Arg, typename... Extra>
7711986Sandreas.sandberg@arm.com    cpp_function(Return (Class::*f)(Arg...), const Extra&... extra) {
7811986Sandreas.sandberg@arm.com        initialize([f](Class *c, Arg... args) -> Return { return (c->*f)(args...); },
7911986Sandreas.sandberg@arm.com                   (Return (*) (Class *, Arg...)) nullptr, extra...);
8011986Sandreas.sandberg@arm.com    }
8111986Sandreas.sandberg@arm.com
8211986Sandreas.sandberg@arm.com    /// Construct a cpp_function from a class method (const)
8311986Sandreas.sandberg@arm.com    template <typename Return, typename Class, typename... Arg, typename... Extra>
8411986Sandreas.sandberg@arm.com    cpp_function(Return (Class::*f)(Arg...) const, const Extra&... extra) {
8511986Sandreas.sandberg@arm.com        initialize([f](const Class *c, Arg... args) -> Return { return (c->*f)(args...); },
8611986Sandreas.sandberg@arm.com                   (Return (*)(const Class *, Arg ...)) nullptr, extra...);
8711986Sandreas.sandberg@arm.com    }
8811986Sandreas.sandberg@arm.com
8911986Sandreas.sandberg@arm.com    /// Return the function name
9011986Sandreas.sandberg@arm.com    object name() const { return attr("__name__"); }
9111986Sandreas.sandberg@arm.com
9211986Sandreas.sandberg@arm.comprotected:
9311986Sandreas.sandberg@arm.com    /// Space optimization: don't inline this frequently instantiated fragment
9411986Sandreas.sandberg@arm.com    PYBIND11_NOINLINE detail::function_record *make_function_record() {
9511986Sandreas.sandberg@arm.com        return new detail::function_record();
9611986Sandreas.sandberg@arm.com    }
9711986Sandreas.sandberg@arm.com
9811986Sandreas.sandberg@arm.com    /// Special internal constructor for functors, lambda functions, etc.
9911986Sandreas.sandberg@arm.com    template <typename Func, typename Return, typename... Args, typename... Extra>
10011986Sandreas.sandberg@arm.com    void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
10114299Sbbruce@ucdavis.edu        using namespace detail;
10214299Sbbruce@ucdavis.edu        struct capture { remove_reference_t<Func> f; };
10311986Sandreas.sandberg@arm.com
10411986Sandreas.sandberg@arm.com        /* Store the function including any extra state it might have (e.g. a lambda capture object) */
10511986Sandreas.sandberg@arm.com        auto rec = make_function_record();
10611986Sandreas.sandberg@arm.com
10711986Sandreas.sandberg@arm.com        /* Store the capture object directly in the function record if there is enough space */
10811986Sandreas.sandberg@arm.com        if (sizeof(capture) <= sizeof(rec->data)) {
10911986Sandreas.sandberg@arm.com            /* Without these pragmas, GCC warns that there might not be
11011986Sandreas.sandberg@arm.com               enough space to use the placement new operator. However, the
11111986Sandreas.sandberg@arm.com               'if' statement above ensures that this is the case. */
11211986Sandreas.sandberg@arm.com#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
11311986Sandreas.sandberg@arm.com#  pragma GCC diagnostic push
11411986Sandreas.sandberg@arm.com#  pragma GCC diagnostic ignored "-Wplacement-new"
11511986Sandreas.sandberg@arm.com#endif
11611986Sandreas.sandberg@arm.com            new ((capture *) &rec->data) capture { std::forward<Func>(f) };
11711986Sandreas.sandberg@arm.com#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
11811986Sandreas.sandberg@arm.com#  pragma GCC diagnostic pop
11911986Sandreas.sandberg@arm.com#endif
12011986Sandreas.sandberg@arm.com            if (!std::is_trivially_destructible<Func>::value)
12114299Sbbruce@ucdavis.edu                rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
12211986Sandreas.sandberg@arm.com        } else {
12311986Sandreas.sandberg@arm.com            rec->data[0] = new capture { std::forward<Func>(f) };
12414299Sbbruce@ucdavis.edu            rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
12511986Sandreas.sandberg@arm.com        }
12611986Sandreas.sandberg@arm.com
12711986Sandreas.sandberg@arm.com        /* Type casters for the function arguments and return value */
12814299Sbbruce@ucdavis.edu        using cast_in = argument_loader<Args...>;
12914299Sbbruce@ucdavis.edu        using cast_out = make_caster<
13014299Sbbruce@ucdavis.edu            conditional_t<std::is_void<Return>::value, void_type, Return>
13111986Sandreas.sandberg@arm.com        >;
13211986Sandreas.sandberg@arm.com
13314299Sbbruce@ucdavis.edu        static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
13412037Sandreas.sandberg@arm.com                      "The number of argument annotations does not match the number of function arguments");
13512037Sandreas.sandberg@arm.com
13611986Sandreas.sandberg@arm.com        /* Dispatch code which converts function arguments and performs the actual function call */
13714299Sbbruce@ucdavis.edu        rec->impl = [](function_call &call) -> handle {
13811986Sandreas.sandberg@arm.com            cast_in args_converter;
13911986Sandreas.sandberg@arm.com
14011986Sandreas.sandberg@arm.com            /* Try to cast the function arguments into the C++ domain */
14112037Sandreas.sandberg@arm.com            if (!args_converter.load_args(call))
14211986Sandreas.sandberg@arm.com                return PYBIND11_TRY_NEXT_OVERLOAD;
14311986Sandreas.sandberg@arm.com
14411986Sandreas.sandberg@arm.com            /* Invoke call policy pre-call hook */
14514299Sbbruce@ucdavis.edu            process_attributes<Extra...>::precall(call);
14611986Sandreas.sandberg@arm.com
14711986Sandreas.sandberg@arm.com            /* Get a pointer to the capture object */
14812037Sandreas.sandberg@arm.com            auto data = (sizeof(capture) <= sizeof(call.func.data)
14912037Sandreas.sandberg@arm.com                         ? &call.func.data : call.func.data[0]);
15012037Sandreas.sandberg@arm.com            capture *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
15111986Sandreas.sandberg@arm.com
15212037Sandreas.sandberg@arm.com            /* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
15314299Sbbruce@ucdavis.edu            return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
15411986Sandreas.sandberg@arm.com
15512391Sjason@lowepower.com            /* Function scope guard -- defaults to the compile-to-nothing `void_type` */
15614299Sbbruce@ucdavis.edu            using Guard = extract_guard_t<Extra...>;
15712391Sjason@lowepower.com
15811986Sandreas.sandberg@arm.com            /* Perform the function call */
15912391Sjason@lowepower.com            handle result = cast_out::cast(
16012391Sjason@lowepower.com                std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
16111986Sandreas.sandberg@arm.com
16211986Sandreas.sandberg@arm.com            /* Invoke call policy post-call hook */
16314299Sbbruce@ucdavis.edu            process_attributes<Extra...>::postcall(call, result);
16411986Sandreas.sandberg@arm.com
16511986Sandreas.sandberg@arm.com            return result;
16611986Sandreas.sandberg@arm.com        };
16711986Sandreas.sandberg@arm.com
16811986Sandreas.sandberg@arm.com        /* Process any user-provided function attributes */
16914299Sbbruce@ucdavis.edu        process_attributes<Extra...>::init(extra..., rec);
17011986Sandreas.sandberg@arm.com
17111986Sandreas.sandberg@arm.com        /* Generate a readable signature describing the function's arguments and return value types */
17214299Sbbruce@ucdavis.edu        static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
17314299Sbbruce@ucdavis.edu        PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
17411986Sandreas.sandberg@arm.com
17511986Sandreas.sandberg@arm.com        /* Register the function with Python from generic (non-templated) code */
17614299Sbbruce@ucdavis.edu        initialize_generic(rec, signature.text, types.data(), sizeof...(Args));
17711986Sandreas.sandberg@arm.com
17811986Sandreas.sandberg@arm.com        if (cast_in::has_args) rec->has_args = true;
17911986Sandreas.sandberg@arm.com        if (cast_in::has_kwargs) rec->has_kwargs = true;
18011986Sandreas.sandberg@arm.com
18111986Sandreas.sandberg@arm.com        /* Stash some additional information used by an important optimization in 'functional.h' */
18211986Sandreas.sandberg@arm.com        using FunctionType = Return (*)(Args...);
18311986Sandreas.sandberg@arm.com        constexpr bool is_function_ptr =
18411986Sandreas.sandberg@arm.com            std::is_convertible<Func, FunctionType>::value &&
18511986Sandreas.sandberg@arm.com            sizeof(capture) == sizeof(void *);
18611986Sandreas.sandberg@arm.com        if (is_function_ptr) {
18711986Sandreas.sandberg@arm.com            rec->is_stateless = true;
18812037Sandreas.sandberg@arm.com            rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
18911986Sandreas.sandberg@arm.com        }
19011986Sandreas.sandberg@arm.com    }
19111986Sandreas.sandberg@arm.com
19211986Sandreas.sandberg@arm.com    /// Register a function call with Python (generic non-templated code goes here)
19311986Sandreas.sandberg@arm.com    void initialize_generic(detail::function_record *rec, const char *text,
19411986Sandreas.sandberg@arm.com                            const std::type_info *const *types, size_t args) {
19511986Sandreas.sandberg@arm.com
19611986Sandreas.sandberg@arm.com        /* Create copies of all referenced C-style strings */
19711986Sandreas.sandberg@arm.com        rec->name = strdup(rec->name ? rec->name : "");
19811986Sandreas.sandberg@arm.com        if (rec->doc) rec->doc = strdup(rec->doc);
19911986Sandreas.sandberg@arm.com        for (auto &a: rec->args) {
20011986Sandreas.sandberg@arm.com            if (a.name)
20111986Sandreas.sandberg@arm.com                a.name = strdup(a.name);
20211986Sandreas.sandberg@arm.com            if (a.descr)
20311986Sandreas.sandberg@arm.com                a.descr = strdup(a.descr);
20411986Sandreas.sandberg@arm.com            else if (a.value)
20511986Sandreas.sandberg@arm.com                a.descr = strdup(a.value.attr("__repr__")().cast<std::string>().c_str());
20611986Sandreas.sandberg@arm.com        }
20711986Sandreas.sandberg@arm.com
20812391Sjason@lowepower.com        rec->is_constructor = !strcmp(rec->name, "__init__") || !strcmp(rec->name, "__setstate__");
20912391Sjason@lowepower.com
21012391Sjason@lowepower.com#if !defined(NDEBUG) && !defined(PYBIND11_DISABLE_NEW_STYLE_INIT_WARNING)
21112391Sjason@lowepower.com        if (rec->is_constructor && !rec->is_new_style_constructor) {
21212391Sjason@lowepower.com            const auto class_name = std::string(((PyTypeObject *) rec->scope.ptr())->tp_name);
21312391Sjason@lowepower.com            const auto func_name = std::string(rec->name);
21412391Sjason@lowepower.com            PyErr_WarnEx(
21512391Sjason@lowepower.com                PyExc_FutureWarning,
21612391Sjason@lowepower.com                ("pybind11-bound class '" + class_name + "' is using an old-style "
21712391Sjason@lowepower.com                 "placement-new '" + func_name + "' which has been deprecated. See "
21812391Sjason@lowepower.com                 "the upgrade guide in pybind11's docs. This message is only visible "
21912391Sjason@lowepower.com                 "when compiled in debug mode.").c_str(), 0
22012391Sjason@lowepower.com            );
22112391Sjason@lowepower.com        }
22212391Sjason@lowepower.com#endif
22312391Sjason@lowepower.com
22411986Sandreas.sandberg@arm.com        /* Generate a proper function signature */
22511986Sandreas.sandberg@arm.com        std::string signature;
22614299Sbbruce@ucdavis.edu        size_t type_index = 0, arg_index = 0;
22714299Sbbruce@ucdavis.edu        for (auto *pc = text; *pc != '\0'; ++pc) {
22814299Sbbruce@ucdavis.edu            const auto c = *pc;
22911986Sandreas.sandberg@arm.com
23011986Sandreas.sandberg@arm.com            if (c == '{') {
23114299Sbbruce@ucdavis.edu                // Write arg name for everything except *args and **kwargs.
23214299Sbbruce@ucdavis.edu                if (*(pc + 1) == '*')
23314299Sbbruce@ucdavis.edu                    continue;
23414299Sbbruce@ucdavis.edu
23514299Sbbruce@ucdavis.edu                if (arg_index < rec->args.size() && rec->args[arg_index].name) {
23614299Sbbruce@ucdavis.edu                    signature += rec->args[arg_index].name;
23714299Sbbruce@ucdavis.edu                } else if (arg_index == 0 && rec->is_method) {
23814299Sbbruce@ucdavis.edu                    signature += "self";
23914299Sbbruce@ucdavis.edu                } else {
24014299Sbbruce@ucdavis.edu                    signature += "arg" + std::to_string(arg_index - (rec->is_method ? 1 : 0));
24111986Sandreas.sandberg@arm.com                }
24214299Sbbruce@ucdavis.edu                signature += ": ";
24311986Sandreas.sandberg@arm.com            } else if (c == '}') {
24414299Sbbruce@ucdavis.edu                // Write default value if available.
24514299Sbbruce@ucdavis.edu                if (arg_index < rec->args.size() && rec->args[arg_index].descr) {
24614299Sbbruce@ucdavis.edu                    signature += " = ";
24714299Sbbruce@ucdavis.edu                    signature += rec->args[arg_index].descr;
24811986Sandreas.sandberg@arm.com                }
24914299Sbbruce@ucdavis.edu                arg_index++;
25011986Sandreas.sandberg@arm.com            } else if (c == '%') {
25111986Sandreas.sandberg@arm.com                const std::type_info *t = types[type_index++];
25211986Sandreas.sandberg@arm.com                if (!t)
25311986Sandreas.sandberg@arm.com                    pybind11_fail("Internal error while parsing type signature (1)");
25411986Sandreas.sandberg@arm.com                if (auto tinfo = detail::get_type_info(*t)) {
25514299Sbbruce@ucdavis.edu                    handle th((PyObject *) tinfo->type);
25614299Sbbruce@ucdavis.edu                    signature +=
25714299Sbbruce@ucdavis.edu                        th.attr("__module__").cast<std::string>() + "." +
25814299Sbbruce@ucdavis.edu                        th.attr("__qualname__").cast<std::string>(); // Python 3.3+, but we backport it to earlier versions
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.
26214299Sbbruce@ucdavis.edu                    signature +=
26314299Sbbruce@ucdavis.edu                        rec->scope.attr("__module__").cast<std::string>() + "." +
26414299Sbbruce@ucdavis.edu                        rec->scope.attr("__qualname__").cast<std::string>();
26511986Sandreas.sandberg@arm.com                } else {
26611986Sandreas.sandberg@arm.com                    std::string tname(t->name());
26711986Sandreas.sandberg@arm.com                    detail::clean_type_id(tname);
26811986Sandreas.sandberg@arm.com                    signature += tname;
26911986Sandreas.sandberg@arm.com                }
27011986Sandreas.sandberg@arm.com            } else {
27111986Sandreas.sandberg@arm.com                signature += c;
27211986Sandreas.sandberg@arm.com            }
27311986Sandreas.sandberg@arm.com        }
27414299Sbbruce@ucdavis.edu        if (arg_index != args || types[type_index] != nullptr)
27511986Sandreas.sandberg@arm.com            pybind11_fail("Internal error while parsing type signature (2)");
27611986Sandreas.sandberg@arm.com
27711986Sandreas.sandberg@arm.com#if PY_MAJOR_VERSION < 3
27811986Sandreas.sandberg@arm.com        if (strcmp(rec->name, "__next__") == 0) {
27911986Sandreas.sandberg@arm.com            std::free(rec->name);
28011986Sandreas.sandberg@arm.com            rec->name = strdup("next");
28111986Sandreas.sandberg@arm.com        } else if (strcmp(rec->name, "__bool__") == 0) {
28211986Sandreas.sandberg@arm.com            std::free(rec->name);
28311986Sandreas.sandberg@arm.com            rec->name = strdup("__nonzero__");
28411986Sandreas.sandberg@arm.com        }
28511986Sandreas.sandberg@arm.com#endif
28611986Sandreas.sandberg@arm.com        rec->signature = strdup(signature.c_str());
28711986Sandreas.sandberg@arm.com        rec->args.shrink_to_fit();
28812037Sandreas.sandberg@arm.com        rec->nargs = (std::uint16_t) args;
28911986Sandreas.sandberg@arm.com
29012391Sjason@lowepower.com        if (rec->sibling && PYBIND11_INSTANCE_METHOD_CHECK(rec->sibling.ptr()))
29112391Sjason@lowepower.com            rec->sibling = PYBIND11_INSTANCE_METHOD_GET_FUNCTION(rec->sibling.ptr());
29211986Sandreas.sandberg@arm.com
29311986Sandreas.sandberg@arm.com        detail::function_record *chain = nullptr, *chain_start = rec;
29411986Sandreas.sandberg@arm.com        if (rec->sibling) {
29511986Sandreas.sandberg@arm.com            if (PyCFunction_Check(rec->sibling.ptr())) {
29612037Sandreas.sandberg@arm.com                auto rec_capsule = reinterpret_borrow<capsule>(PyCFunction_GET_SELF(rec->sibling.ptr()));
29711986Sandreas.sandberg@arm.com                chain = (detail::function_record *) rec_capsule;
29811986Sandreas.sandberg@arm.com                /* Never append a method to an overload chain of a parent class;
29911986Sandreas.sandberg@arm.com                   instead, hide the parent's overloads in this case */
30012391Sjason@lowepower.com                if (!chain->scope.is(rec->scope))
30111986Sandreas.sandberg@arm.com                    chain = nullptr;
30211986Sandreas.sandberg@arm.com            }
30311986Sandreas.sandberg@arm.com            // Don't trigger for things like the default __init__, which are wrapper_descriptors that we are intentionally replacing
30411986Sandreas.sandberg@arm.com            else if (!rec->sibling.is_none() && rec->name[0] != '_')
30511986Sandreas.sandberg@arm.com                pybind11_fail("Cannot overload existing non-function object \"" + std::string(rec->name) +
30611986Sandreas.sandberg@arm.com                        "\" with a function of the same name");
30711986Sandreas.sandberg@arm.com        }
30811986Sandreas.sandberg@arm.com
30911986Sandreas.sandberg@arm.com        if (!chain) {
31011986Sandreas.sandberg@arm.com            /* No existing overload was found, create a new function object */
31111986Sandreas.sandberg@arm.com            rec->def = new PyMethodDef();
31212391Sjason@lowepower.com            std::memset(rec->def, 0, sizeof(PyMethodDef));
31311986Sandreas.sandberg@arm.com            rec->def->ml_name = rec->name;
31412894Sjason@lowepower.com            rec->def->ml_meth = reinterpret_cast<PyCFunction>(reinterpret_cast<void (*) (void)>(*dispatcher));
31511986Sandreas.sandberg@arm.com            rec->def->ml_flags = METH_VARARGS | METH_KEYWORDS;
31611986Sandreas.sandberg@arm.com
31712037Sandreas.sandberg@arm.com            capsule rec_capsule(rec, [](void *ptr) {
31812037Sandreas.sandberg@arm.com                destruct((detail::function_record *) ptr);
31911986Sandreas.sandberg@arm.com            });
32011986Sandreas.sandberg@arm.com
32111986Sandreas.sandberg@arm.com            object scope_module;
32211986Sandreas.sandberg@arm.com            if (rec->scope) {
32311986Sandreas.sandberg@arm.com                if (hasattr(rec->scope, "__module__")) {
32411986Sandreas.sandberg@arm.com                    scope_module = rec->scope.attr("__module__");
32511986Sandreas.sandberg@arm.com                } else if (hasattr(rec->scope, "__name__")) {
32611986Sandreas.sandberg@arm.com                    scope_module = rec->scope.attr("__name__");
32711986Sandreas.sandberg@arm.com                }
32811986Sandreas.sandberg@arm.com            }
32911986Sandreas.sandberg@arm.com
33011986Sandreas.sandberg@arm.com            m_ptr = PyCFunction_NewEx(rec->def, rec_capsule.ptr(), scope_module.ptr());
33111986Sandreas.sandberg@arm.com            if (!m_ptr)
33211986Sandreas.sandberg@arm.com                pybind11_fail("cpp_function::cpp_function(): Could not allocate function object");
33311986Sandreas.sandberg@arm.com        } else {
33411986Sandreas.sandberg@arm.com            /* Append at the end of the overload chain */
33511986Sandreas.sandberg@arm.com            m_ptr = rec->sibling.ptr();
33611986Sandreas.sandberg@arm.com            inc_ref();
33711986Sandreas.sandberg@arm.com            chain_start = chain;
33812391Sjason@lowepower.com            if (chain->is_method != rec->is_method)
33912391Sjason@lowepower.com                pybind11_fail("overloading a method with both static and instance methods is not supported; "
34012391Sjason@lowepower.com                    #if defined(NDEBUG)
34112391Sjason@lowepower.com                        "compile in debug mode for more details"
34212391Sjason@lowepower.com                    #else
34312391Sjason@lowepower.com                        "error while attempting to bind " + std::string(rec->is_method ? "instance" : "static") + " method " +
34412391Sjason@lowepower.com                        std::string(pybind11::str(rec->scope.attr("__name__"))) + "." + std::string(rec->name) + signature
34512391Sjason@lowepower.com                    #endif
34612391Sjason@lowepower.com                );
34711986Sandreas.sandberg@arm.com            while (chain->next)
34811986Sandreas.sandberg@arm.com                chain = chain->next;
34911986Sandreas.sandberg@arm.com            chain->next = rec;
35011986Sandreas.sandberg@arm.com        }
35111986Sandreas.sandberg@arm.com
35211986Sandreas.sandberg@arm.com        std::string signatures;
35311986Sandreas.sandberg@arm.com        int index = 0;
35411986Sandreas.sandberg@arm.com        /* Create a nice pydoc rec including all signatures and
35511986Sandreas.sandberg@arm.com           docstrings of the functions in the overload chain */
35611986Sandreas.sandberg@arm.com        if (chain && options::show_function_signatures()) {
35711986Sandreas.sandberg@arm.com            // First a generic signature
35811986Sandreas.sandberg@arm.com            signatures += rec->name;
35911986Sandreas.sandberg@arm.com            signatures += "(*args, **kwargs)\n";
36011986Sandreas.sandberg@arm.com            signatures += "Overloaded function.\n\n";
36111986Sandreas.sandberg@arm.com        }
36211986Sandreas.sandberg@arm.com        // Then specific overload signatures
36312037Sandreas.sandberg@arm.com        bool first_user_def = true;
36411986Sandreas.sandberg@arm.com        for (auto it = chain_start; it != nullptr; it = it->next) {
36511986Sandreas.sandberg@arm.com            if (options::show_function_signatures()) {
36612037Sandreas.sandberg@arm.com                if (index > 0) signatures += "\n";
36711986Sandreas.sandberg@arm.com                if (chain)
36811986Sandreas.sandberg@arm.com                    signatures += std::to_string(++index) + ". ";
36911986Sandreas.sandberg@arm.com                signatures += rec->name;
37011986Sandreas.sandberg@arm.com                signatures += it->signature;
37111986Sandreas.sandberg@arm.com                signatures += "\n";
37211986Sandreas.sandberg@arm.com            }
37311986Sandreas.sandberg@arm.com            if (it->doc && strlen(it->doc) > 0 && options::show_user_defined_docstrings()) {
37412037Sandreas.sandberg@arm.com                // If we're appending another docstring, and aren't printing function signatures, we
37512037Sandreas.sandberg@arm.com                // need to append a newline first:
37612037Sandreas.sandberg@arm.com                if (!options::show_function_signatures()) {
37712037Sandreas.sandberg@arm.com                    if (first_user_def) first_user_def = false;
37812037Sandreas.sandberg@arm.com                    else signatures += "\n";
37912037Sandreas.sandberg@arm.com                }
38011986Sandreas.sandberg@arm.com                if (options::show_function_signatures()) signatures += "\n";
38111986Sandreas.sandberg@arm.com                signatures += it->doc;
38211986Sandreas.sandberg@arm.com                if (options::show_function_signatures()) signatures += "\n";
38311986Sandreas.sandberg@arm.com            }
38411986Sandreas.sandberg@arm.com        }
38511986Sandreas.sandberg@arm.com
38611986Sandreas.sandberg@arm.com        /* Install docstring */
38711986Sandreas.sandberg@arm.com        PyCFunctionObject *func = (PyCFunctionObject *) m_ptr;
38811986Sandreas.sandberg@arm.com        if (func->m_ml->ml_doc)
38912037Sandreas.sandberg@arm.com            std::free(const_cast<char *>(func->m_ml->ml_doc));
39011986Sandreas.sandberg@arm.com        func->m_ml->ml_doc = strdup(signatures.c_str());
39111986Sandreas.sandberg@arm.com
39211986Sandreas.sandberg@arm.com        if (rec->is_method) {
39311986Sandreas.sandberg@arm.com            m_ptr = PYBIND11_INSTANCE_METHOD_NEW(m_ptr, rec->scope.ptr());
39411986Sandreas.sandberg@arm.com            if (!m_ptr)
39511986Sandreas.sandberg@arm.com                pybind11_fail("cpp_function::cpp_function(): Could not allocate instance method object");
39611986Sandreas.sandberg@arm.com            Py_DECREF(func);
39711986Sandreas.sandberg@arm.com        }
39811986Sandreas.sandberg@arm.com    }
39911986Sandreas.sandberg@arm.com
40011986Sandreas.sandberg@arm.com    /// When a cpp_function is GCed, release any memory allocated by pybind11
40111986Sandreas.sandberg@arm.com    static void destruct(detail::function_record *rec) {
40211986Sandreas.sandberg@arm.com        while (rec) {
40311986Sandreas.sandberg@arm.com            detail::function_record *next = rec->next;
40411986Sandreas.sandberg@arm.com            if (rec->free_data)
40511986Sandreas.sandberg@arm.com                rec->free_data(rec);
40611986Sandreas.sandberg@arm.com            std::free((char *) rec->name);
40711986Sandreas.sandberg@arm.com            std::free((char *) rec->doc);
40811986Sandreas.sandberg@arm.com            std::free((char *) rec->signature);
40911986Sandreas.sandberg@arm.com            for (auto &arg: rec->args) {
41012037Sandreas.sandberg@arm.com                std::free(const_cast<char *>(arg.name));
41112037Sandreas.sandberg@arm.com                std::free(const_cast<char *>(arg.descr));
41211986Sandreas.sandberg@arm.com                arg.value.dec_ref();
41311986Sandreas.sandberg@arm.com            }
41411986Sandreas.sandberg@arm.com            if (rec->def) {
41512037Sandreas.sandberg@arm.com                std::free(const_cast<char *>(rec->def->ml_doc));
41611986Sandreas.sandberg@arm.com                delete rec->def;
41711986Sandreas.sandberg@arm.com            }
41811986Sandreas.sandberg@arm.com            delete rec;
41911986Sandreas.sandberg@arm.com            rec = next;
42011986Sandreas.sandberg@arm.com        }
42111986Sandreas.sandberg@arm.com    }
42211986Sandreas.sandberg@arm.com
42311986Sandreas.sandberg@arm.com    /// Main dispatch logic for calls to functions bound using pybind11
42412037Sandreas.sandberg@arm.com    static PyObject *dispatcher(PyObject *self, PyObject *args_in, PyObject *kwargs_in) {
42512037Sandreas.sandberg@arm.com        using namespace detail;
42612037Sandreas.sandberg@arm.com
42711986Sandreas.sandberg@arm.com        /* Iterator over the list of potentially admissible overloads */
42814299Sbbruce@ucdavis.edu        const function_record *overloads = (function_record *) PyCapsule_GetPointer(self, nullptr),
42914299Sbbruce@ucdavis.edu                              *it = overloads;
43011986Sandreas.sandberg@arm.com
43111986Sandreas.sandberg@arm.com        /* Need to know how many arguments + keyword arguments there are to pick the right overload */
43212037Sandreas.sandberg@arm.com        const size_t n_args_in = (size_t) PyTuple_GET_SIZE(args_in);
43311986Sandreas.sandberg@arm.com
43412037Sandreas.sandberg@arm.com        handle parent = n_args_in > 0 ? PyTuple_GET_ITEM(args_in, 0) : nullptr,
43511986Sandreas.sandberg@arm.com               result = PYBIND11_TRY_NEXT_OVERLOAD;
43612037Sandreas.sandberg@arm.com
43712391Sjason@lowepower.com        auto self_value_and_holder = value_and_holder();
43812391Sjason@lowepower.com        if (overloads->is_constructor) {
43912391Sjason@lowepower.com            const auto tinfo = get_type_info((PyTypeObject *) overloads->scope.ptr());
44012391Sjason@lowepower.com            const auto pi = reinterpret_cast<instance *>(parent.ptr());
44112391Sjason@lowepower.com            self_value_and_holder = pi->get_value_and_holder(tinfo, false);
44212391Sjason@lowepower.com
44312391Sjason@lowepower.com            if (!self_value_and_holder.type || !self_value_and_holder.inst) {
44412391Sjason@lowepower.com                PyErr_SetString(PyExc_TypeError, "__init__(self, ...) called with invalid `self` argument");
44512391Sjason@lowepower.com                return nullptr;
44612391Sjason@lowepower.com            }
44712391Sjason@lowepower.com
44812391Sjason@lowepower.com            // If this value is already registered it must mean __init__ is invoked multiple times;
44912391Sjason@lowepower.com            // we really can't support that in C++, so just ignore the second __init__.
45012391Sjason@lowepower.com            if (self_value_and_holder.instance_registered())
45112391Sjason@lowepower.com                return none().release().ptr();
45212391Sjason@lowepower.com        }
45312391Sjason@lowepower.com
45411986Sandreas.sandberg@arm.com        try {
45512037Sandreas.sandberg@arm.com            // We do this in two passes: in the first pass, we load arguments with `convert=false`;
45612037Sandreas.sandberg@arm.com            // in the second, we allow conversion (except for arguments with an explicit
45712037Sandreas.sandberg@arm.com            // py::arg().noconvert()).  This lets us prefer calls without conversion, with
45812037Sandreas.sandberg@arm.com            // conversion as a fallback.
45912037Sandreas.sandberg@arm.com            std::vector<function_call> second_pass;
46012037Sandreas.sandberg@arm.com
46112037Sandreas.sandberg@arm.com            // However, if there are no overloads, we can just skip the no-convert pass entirely
46212037Sandreas.sandberg@arm.com            const bool overloaded = it != nullptr && it->next != nullptr;
46312037Sandreas.sandberg@arm.com
46411986Sandreas.sandberg@arm.com            for (; it != nullptr; it = it->next) {
46511986Sandreas.sandberg@arm.com
46611986Sandreas.sandberg@arm.com                /* For each overload:
46712037Sandreas.sandberg@arm.com                   1. Copy all positional arguments we were given, also checking to make sure that
46812037Sandreas.sandberg@arm.com                      named positional arguments weren't *also* specified via kwarg.
46912037Sandreas.sandberg@arm.com                   2. If we weren't given enough, try to make up the omitted ones by checking
47012037Sandreas.sandberg@arm.com                      whether they were provided by a kwarg matching the `py::arg("name")` name.  If
47112037Sandreas.sandberg@arm.com                      so, use it (and remove it from kwargs; if not, see if the function binding
47212037Sandreas.sandberg@arm.com                      provided a default that we can use.
47312037Sandreas.sandberg@arm.com                   3. Ensure that either all keyword arguments were "consumed", or that the function
47412037Sandreas.sandberg@arm.com                      takes a kwargs argument to accept unconsumed kwargs.
47512037Sandreas.sandberg@arm.com                   4. Any positional arguments still left get put into a tuple (for args), and any
47612037Sandreas.sandberg@arm.com                      leftover kwargs get put into a dict.
47712037Sandreas.sandberg@arm.com                   5. Pack everything into a vector; if we have py::args or py::kwargs, they are an
47812037Sandreas.sandberg@arm.com                      extra tuple or dict at the end of the positional arguments.
47912037Sandreas.sandberg@arm.com                   6. Call the function call dispatcher (function_record::impl)
48012037Sandreas.sandberg@arm.com
48112037Sandreas.sandberg@arm.com                   If one of these fail, move on to the next overload and keep trying until we get a
48212037Sandreas.sandberg@arm.com                   result other than PYBIND11_TRY_NEXT_OVERLOAD.
48311986Sandreas.sandberg@arm.com                 */
48412037Sandreas.sandberg@arm.com
48514299Sbbruce@ucdavis.edu                const function_record &func = *it;
48612037Sandreas.sandberg@arm.com                size_t pos_args = func.nargs;    // Number of positional arguments that we need
48712037Sandreas.sandberg@arm.com                if (func.has_args) --pos_args;   // (but don't count py::args
48812037Sandreas.sandberg@arm.com                if (func.has_kwargs) --pos_args; //  or py::kwargs)
48912037Sandreas.sandberg@arm.com
49012037Sandreas.sandberg@arm.com                if (!func.has_args && n_args_in > pos_args)
49112037Sandreas.sandberg@arm.com                    continue; // Too many arguments for this overload
49212037Sandreas.sandberg@arm.com
49312037Sandreas.sandberg@arm.com                if (n_args_in < pos_args && func.args.size() < pos_args)
49412037Sandreas.sandberg@arm.com                    continue; // Not enough arguments given, and not enough defaults to fill in the blanks
49512037Sandreas.sandberg@arm.com
49612037Sandreas.sandberg@arm.com                function_call call(func, parent);
49712037Sandreas.sandberg@arm.com
49814299Sbbruce@ucdavis.edu                size_t args_to_copy = (std::min)(pos_args, n_args_in); // Protect std::min with parentheses
49912037Sandreas.sandberg@arm.com                size_t args_copied = 0;
50012037Sandreas.sandberg@arm.com
50112391Sjason@lowepower.com                // 0. Inject new-style `self` argument
50212391Sjason@lowepower.com                if (func.is_new_style_constructor) {
50312391Sjason@lowepower.com                    // The `value` may have been preallocated by an old-style `__init__`
50412391Sjason@lowepower.com                    // if it was a preceding candidate for overload resolution.
50512391Sjason@lowepower.com                    if (self_value_and_holder)
50612391Sjason@lowepower.com                        self_value_and_holder.type->dealloc(self_value_and_holder);
50712391Sjason@lowepower.com
50812391Sjason@lowepower.com                    call.init_self = PyTuple_GET_ITEM(args_in, 0);
50912391Sjason@lowepower.com                    call.args.push_back(reinterpret_cast<PyObject *>(&self_value_and_holder));
51012391Sjason@lowepower.com                    call.args_convert.push_back(false);
51112391Sjason@lowepower.com                    ++args_copied;
51212391Sjason@lowepower.com                }
51312391Sjason@lowepower.com
51412037Sandreas.sandberg@arm.com                // 1. Copy any position arguments given.
51512391Sjason@lowepower.com                bool bad_arg = false;
51612037Sandreas.sandberg@arm.com                for (; args_copied < args_to_copy; ++args_copied) {
51714299Sbbruce@ucdavis.edu                    const argument_record *arg_rec = args_copied < func.args.size() ? &func.args[args_copied] : nullptr;
51812391Sjason@lowepower.com                    if (kwargs_in && arg_rec && arg_rec->name && PyDict_GetItemString(kwargs_in, arg_rec->name)) {
51912391Sjason@lowepower.com                        bad_arg = true;
52012037Sandreas.sandberg@arm.com                        break;
52111986Sandreas.sandberg@arm.com                    }
52211986Sandreas.sandberg@arm.com
52312391Sjason@lowepower.com                    handle arg(PyTuple_GET_ITEM(args_in, args_copied));
52412391Sjason@lowepower.com                    if (arg_rec && !arg_rec->none && arg.is_none()) {
52512391Sjason@lowepower.com                        bad_arg = true;
52612391Sjason@lowepower.com                        break;
52712391Sjason@lowepower.com                    }
52812391Sjason@lowepower.com                    call.args.push_back(arg);
52912391Sjason@lowepower.com                    call.args_convert.push_back(arg_rec ? arg_rec->convert : true);
53012037Sandreas.sandberg@arm.com                }
53112391Sjason@lowepower.com                if (bad_arg)
53212037Sandreas.sandberg@arm.com                    continue; // Maybe it was meant for another overload (issue #688)
53312037Sandreas.sandberg@arm.com
53412037Sandreas.sandberg@arm.com                // We'll need to copy this if we steal some kwargs for defaults
53512037Sandreas.sandberg@arm.com                dict kwargs = reinterpret_borrow<dict>(kwargs_in);
53612037Sandreas.sandberg@arm.com
53712037Sandreas.sandberg@arm.com                // 2. Check kwargs and, failing that, defaults that may help complete the list
53812037Sandreas.sandberg@arm.com                if (args_copied < pos_args) {
53912037Sandreas.sandberg@arm.com                    bool copied_kwargs = false;
54012037Sandreas.sandberg@arm.com
54112037Sandreas.sandberg@arm.com                    for (; args_copied < pos_args; ++args_copied) {
54212037Sandreas.sandberg@arm.com                        const auto &arg = func.args[args_copied];
54311986Sandreas.sandberg@arm.com
54411986Sandreas.sandberg@arm.com                        handle value;
54512037Sandreas.sandberg@arm.com                        if (kwargs_in && arg.name)
54612037Sandreas.sandberg@arm.com                            value = PyDict_GetItemString(kwargs.ptr(), arg.name);
54711986Sandreas.sandberg@arm.com
54811986Sandreas.sandberg@arm.com                        if (value) {
54912037Sandreas.sandberg@arm.com                            // Consume a kwargs value
55012037Sandreas.sandberg@arm.com                            if (!copied_kwargs) {
55112037Sandreas.sandberg@arm.com                                kwargs = reinterpret_steal<dict>(PyDict_Copy(kwargs.ptr()));
55212037Sandreas.sandberg@arm.com                                copied_kwargs = true;
55312037Sandreas.sandberg@arm.com                            }
55412037Sandreas.sandberg@arm.com                            PyDict_DelItemString(kwargs.ptr(), arg.name);
55512037Sandreas.sandberg@arm.com                        } else if (arg.value) {
55612037Sandreas.sandberg@arm.com                            value = arg.value;
55712037Sandreas.sandberg@arm.com                        }
55812037Sandreas.sandberg@arm.com
55912037Sandreas.sandberg@arm.com                        if (value) {
56012037Sandreas.sandberg@arm.com                            call.args.push_back(value);
56112037Sandreas.sandberg@arm.com                            call.args_convert.push_back(arg.convert);
56212037Sandreas.sandberg@arm.com                        }
56312037Sandreas.sandberg@arm.com                        else
56411986Sandreas.sandberg@arm.com                            break;
56512037Sandreas.sandberg@arm.com                    }
56612037Sandreas.sandberg@arm.com
56712037Sandreas.sandberg@arm.com                    if (args_copied < pos_args)
56812037Sandreas.sandberg@arm.com                        continue; // Not enough arguments, defaults, or kwargs to fill the positional arguments
56912037Sandreas.sandberg@arm.com                }
57012037Sandreas.sandberg@arm.com
57112037Sandreas.sandberg@arm.com                // 3. Check everything was consumed (unless we have a kwargs arg)
57212037Sandreas.sandberg@arm.com                if (kwargs && kwargs.size() > 0 && !func.has_kwargs)
57312037Sandreas.sandberg@arm.com                    continue; // Unconsumed kwargs, but no py::kwargs argument to accept them
57412037Sandreas.sandberg@arm.com
57512037Sandreas.sandberg@arm.com                // 4a. If we have a py::args argument, create a new tuple with leftovers
57612037Sandreas.sandberg@arm.com                if (func.has_args) {
57714299Sbbruce@ucdavis.edu                    tuple extra_args;
57812037Sandreas.sandberg@arm.com                    if (args_to_copy == 0) {
57912037Sandreas.sandberg@arm.com                        // We didn't copy out any position arguments from the args_in tuple, so we
58012037Sandreas.sandberg@arm.com                        // can reuse it directly without copying:
58112037Sandreas.sandberg@arm.com                        extra_args = reinterpret_borrow<tuple>(args_in);
58212037Sandreas.sandberg@arm.com                    } else if (args_copied >= n_args_in) {
58312037Sandreas.sandberg@arm.com                        extra_args = tuple(0);
58412037Sandreas.sandberg@arm.com                    } else {
58512037Sandreas.sandberg@arm.com                        size_t args_size = n_args_in - args_copied;
58612037Sandreas.sandberg@arm.com                        extra_args = tuple(args_size);
58712037Sandreas.sandberg@arm.com                        for (size_t i = 0; i < args_size; ++i) {
58814299Sbbruce@ucdavis.edu                            extra_args[i] = PyTuple_GET_ITEM(args_in, args_copied + i);
58911986Sandreas.sandberg@arm.com                        }
59011986Sandreas.sandberg@arm.com                    }
59112037Sandreas.sandberg@arm.com                    call.args.push_back(extra_args);
59212037Sandreas.sandberg@arm.com                    call.args_convert.push_back(false);
59314299Sbbruce@ucdavis.edu                    call.args_ref = std::move(extra_args);
59411986Sandreas.sandberg@arm.com                }
59511986Sandreas.sandberg@arm.com
59612037Sandreas.sandberg@arm.com                // 4b. If we have a py::kwargs, pass on any remaining kwargs
59712037Sandreas.sandberg@arm.com                if (func.has_kwargs) {
59812037Sandreas.sandberg@arm.com                    if (!kwargs.ptr())
59912037Sandreas.sandberg@arm.com                        kwargs = dict(); // If we didn't get one, send an empty one
60012037Sandreas.sandberg@arm.com                    call.args.push_back(kwargs);
60112037Sandreas.sandberg@arm.com                    call.args_convert.push_back(false);
60214299Sbbruce@ucdavis.edu                    call.kwargs_ref = std::move(kwargs);
60312037Sandreas.sandberg@arm.com                }
60412037Sandreas.sandberg@arm.com
60512037Sandreas.sandberg@arm.com                // 5. Put everything in a vector.  Not technically step 5, we've been building it
60612037Sandreas.sandberg@arm.com                // in `call.args` all along.
60712037Sandreas.sandberg@arm.com                #if !defined(NDEBUG)
60812037Sandreas.sandberg@arm.com                if (call.args.size() != func.nargs || call.args_convert.size() != func.nargs)
60912037Sandreas.sandberg@arm.com                    pybind11_fail("Internal error: function call dispatcher inserted wrong number of arguments!");
61012037Sandreas.sandberg@arm.com                #endif
61112037Sandreas.sandberg@arm.com
61212037Sandreas.sandberg@arm.com                std::vector<bool> second_pass_convert;
61312037Sandreas.sandberg@arm.com                if (overloaded) {
61412037Sandreas.sandberg@arm.com                    // We're in the first no-convert pass, so swap out the conversion flags for a
61512037Sandreas.sandberg@arm.com                    // set of all-false flags.  If the call fails, we'll swap the flags back in for
61612037Sandreas.sandberg@arm.com                    // the conversion-allowed call below.
61712037Sandreas.sandberg@arm.com                    second_pass_convert.resize(func.nargs, false);
61812037Sandreas.sandberg@arm.com                    call.args_convert.swap(second_pass_convert);
61912037Sandreas.sandberg@arm.com                }
62012037Sandreas.sandberg@arm.com
62112037Sandreas.sandberg@arm.com                // 6. Call the function.
62211986Sandreas.sandberg@arm.com                try {
62312391Sjason@lowepower.com                    loader_life_support guard{};
62412037Sandreas.sandberg@arm.com                    result = func.impl(call);
62511986Sandreas.sandberg@arm.com                } catch (reference_cast_error &) {
62611986Sandreas.sandberg@arm.com                    result = PYBIND11_TRY_NEXT_OVERLOAD;
62711986Sandreas.sandberg@arm.com                }
62811986Sandreas.sandberg@arm.com
62911986Sandreas.sandberg@arm.com                if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD)
63011986Sandreas.sandberg@arm.com                    break;
63112037Sandreas.sandberg@arm.com
63212037Sandreas.sandberg@arm.com                if (overloaded) {
63312037Sandreas.sandberg@arm.com                    // The (overloaded) call failed; if the call has at least one argument that
63412037Sandreas.sandberg@arm.com                    // permits conversion (i.e. it hasn't been explicitly specified `.noconvert()`)
63512037Sandreas.sandberg@arm.com                    // then add this call to the list of second pass overloads to try.
63612037Sandreas.sandberg@arm.com                    for (size_t i = func.is_method ? 1 : 0; i < pos_args; i++) {
63712037Sandreas.sandberg@arm.com                        if (second_pass_convert[i]) {
63812037Sandreas.sandberg@arm.com                            // Found one: swap the converting flags back in and store the call for
63912037Sandreas.sandberg@arm.com                            // the second pass.
64012037Sandreas.sandberg@arm.com                            call.args_convert.swap(second_pass_convert);
64112037Sandreas.sandberg@arm.com                            second_pass.push_back(std::move(call));
64212037Sandreas.sandberg@arm.com                            break;
64312037Sandreas.sandberg@arm.com                        }
64412037Sandreas.sandberg@arm.com                    }
64512037Sandreas.sandberg@arm.com                }
64612037Sandreas.sandberg@arm.com            }
64712037Sandreas.sandberg@arm.com
64812037Sandreas.sandberg@arm.com            if (overloaded && !second_pass.empty() && result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) {
64912037Sandreas.sandberg@arm.com                // The no-conversion pass finished without success, try again with conversion allowed
65012037Sandreas.sandberg@arm.com                for (auto &call : second_pass) {
65112037Sandreas.sandberg@arm.com                    try {
65212391Sjason@lowepower.com                        loader_life_support guard{};
65312037Sandreas.sandberg@arm.com                        result = call.func.impl(call);
65412037Sandreas.sandberg@arm.com                    } catch (reference_cast_error &) {
65512037Sandreas.sandberg@arm.com                        result = PYBIND11_TRY_NEXT_OVERLOAD;
65612037Sandreas.sandberg@arm.com                    }
65712037Sandreas.sandberg@arm.com
65814299Sbbruce@ucdavis.edu                    if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD) {
65914299Sbbruce@ucdavis.edu                        // The error reporting logic below expects 'it' to be valid, as it would be
66014299Sbbruce@ucdavis.edu                        // if we'd encountered this failure in the first-pass loop.
66114299Sbbruce@ucdavis.edu                        if (!result)
66214299Sbbruce@ucdavis.edu                            it = &call.func;
66312037Sandreas.sandberg@arm.com                        break;
66414299Sbbruce@ucdavis.edu                    }
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;
67014299Sbbruce@ucdavis.edu#if defined(__GNUG__) && !defined(__clang__)
67114299Sbbruce@ucdavis.edu        } catch ( abi::__forced_unwind& ) {
67214299Sbbruce@ucdavis.edu            throw;
67314299Sbbruce@ucdavis.edu#endif
67411986Sandreas.sandberg@arm.com        } catch (...) {
67511986Sandreas.sandberg@arm.com            /* When an exception is caught, give each registered exception
67611986Sandreas.sandberg@arm.com               translator a chance to translate it to a Python exception
67711986Sandreas.sandberg@arm.com               in reverse order of registration.
67811986Sandreas.sandberg@arm.com
67911986Sandreas.sandberg@arm.com               A translator may choose to do one of the following:
68011986Sandreas.sandberg@arm.com
68111986Sandreas.sandberg@arm.com                - catch the exception and call PyErr_SetString or PyErr_SetObject
68211986Sandreas.sandberg@arm.com                  to set a standard (or custom) Python exception, or
68311986Sandreas.sandberg@arm.com                - do nothing and let the exception fall through to the next translator, or
68411986Sandreas.sandberg@arm.com                - delegate translation to the next translator by throwing a new type of exception. */
68511986Sandreas.sandberg@arm.com
68611986Sandreas.sandberg@arm.com            auto last_exception = std::current_exception();
68712037Sandreas.sandberg@arm.com            auto &registered_exception_translators = get_internals().registered_exception_translators;
68811986Sandreas.sandberg@arm.com            for (auto& translator : registered_exception_translators) {
68911986Sandreas.sandberg@arm.com                try {
69011986Sandreas.sandberg@arm.com                    translator(last_exception);
69111986Sandreas.sandberg@arm.com                } catch (...) {
69211986Sandreas.sandberg@arm.com                    last_exception = std::current_exception();
69311986Sandreas.sandberg@arm.com                    continue;
69411986Sandreas.sandberg@arm.com                }
69511986Sandreas.sandberg@arm.com                return nullptr;
69611986Sandreas.sandberg@arm.com            }
69711986Sandreas.sandberg@arm.com            PyErr_SetString(PyExc_SystemError, "Exception escaped from default exception translator!");
69811986Sandreas.sandberg@arm.com            return nullptr;
69911986Sandreas.sandberg@arm.com        }
70011986Sandreas.sandberg@arm.com
70112391Sjason@lowepower.com        auto append_note_if_missing_header_is_suspected = [](std::string &msg) {
70212391Sjason@lowepower.com            if (msg.find("std::") != std::string::npos) {
70312391Sjason@lowepower.com                msg += "\n\n"
70412391Sjason@lowepower.com                       "Did you forget to `#include <pybind11/stl.h>`? Or <pybind11/complex.h>,\n"
70512391Sjason@lowepower.com                       "<pybind11/functional.h>, <pybind11/chrono.h>, etc. Some automatic\n"
70612391Sjason@lowepower.com                       "conversions are optional and require extra headers to be included\n"
70712391Sjason@lowepower.com                       "when compiling your pybind11 module.";
70812391Sjason@lowepower.com            }
70912391Sjason@lowepower.com        };
71012391Sjason@lowepower.com
71111986Sandreas.sandberg@arm.com        if (result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) {
71211986Sandreas.sandberg@arm.com            if (overloads->is_operator)
71311986Sandreas.sandberg@arm.com                return handle(Py_NotImplemented).inc_ref().ptr();
71411986Sandreas.sandberg@arm.com
71511986Sandreas.sandberg@arm.com            std::string msg = std::string(overloads->name) + "(): incompatible " +
71611986Sandreas.sandberg@arm.com                std::string(overloads->is_constructor ? "constructor" : "function") +
71711986Sandreas.sandberg@arm.com                " arguments. The following argument types are supported:\n";
71811986Sandreas.sandberg@arm.com
71911986Sandreas.sandberg@arm.com            int ctr = 0;
72014299Sbbruce@ucdavis.edu            for (const function_record *it2 = overloads; it2 != nullptr; it2 = it2->next) {
72111986Sandreas.sandberg@arm.com                msg += "    "+ std::to_string(++ctr) + ". ";
72211986Sandreas.sandberg@arm.com
72311986Sandreas.sandberg@arm.com                bool wrote_sig = false;
72411986Sandreas.sandberg@arm.com                if (overloads->is_constructor) {
72511986Sandreas.sandberg@arm.com                    // For a constructor, rewrite `(self: Object, arg0, ...) -> NoneType` as `Object(arg0, ...)`
72611986Sandreas.sandberg@arm.com                    std::string sig = it2->signature;
72711986Sandreas.sandberg@arm.com                    size_t start = sig.find('(') + 7; // skip "(self: "
72811986Sandreas.sandberg@arm.com                    if (start < sig.size()) {
72911986Sandreas.sandberg@arm.com                        // End at the , for the next argument
73011986Sandreas.sandberg@arm.com                        size_t end = sig.find(", "), next = end + 2;
73111986Sandreas.sandberg@arm.com                        size_t ret = sig.rfind(" -> ");
73211986Sandreas.sandberg@arm.com                        // Or the ), if there is no comma:
73311986Sandreas.sandberg@arm.com                        if (end >= sig.size()) next = end = sig.find(')');
73411986Sandreas.sandberg@arm.com                        if (start < end && next < sig.size()) {
73511986Sandreas.sandberg@arm.com                            msg.append(sig, start, end - start);
73611986Sandreas.sandberg@arm.com                            msg += '(';
73711986Sandreas.sandberg@arm.com                            msg.append(sig, next, ret - next);
73811986Sandreas.sandberg@arm.com                            wrote_sig = true;
73911986Sandreas.sandberg@arm.com                        }
74011986Sandreas.sandberg@arm.com                    }
74111986Sandreas.sandberg@arm.com                }
74211986Sandreas.sandberg@arm.com                if (!wrote_sig) msg += it2->signature;
74311986Sandreas.sandberg@arm.com
74411986Sandreas.sandberg@arm.com                msg += "\n";
74511986Sandreas.sandberg@arm.com            }
74611986Sandreas.sandberg@arm.com            msg += "\nInvoked with: ";
74712037Sandreas.sandberg@arm.com            auto args_ = reinterpret_borrow<tuple>(args_in);
74812037Sandreas.sandberg@arm.com            bool some_args = false;
74911986Sandreas.sandberg@arm.com            for (size_t ti = overloads->is_constructor ? 1 : 0; ti < args_.size(); ++ti) {
75012037Sandreas.sandberg@arm.com                if (!some_args) some_args = true;
75112037Sandreas.sandberg@arm.com                else msg += ", ";
75211986Sandreas.sandberg@arm.com                msg += pybind11::repr(args_[ti]);
75311986Sandreas.sandberg@arm.com            }
75412037Sandreas.sandberg@arm.com            if (kwargs_in) {
75512037Sandreas.sandberg@arm.com                auto kwargs = reinterpret_borrow<dict>(kwargs_in);
75612037Sandreas.sandberg@arm.com                if (kwargs.size() > 0) {
75712037Sandreas.sandberg@arm.com                    if (some_args) msg += "; ";
75812037Sandreas.sandberg@arm.com                    msg += "kwargs: ";
75912037Sandreas.sandberg@arm.com                    bool first = true;
76012037Sandreas.sandberg@arm.com                    for (auto kwarg : kwargs) {
76112037Sandreas.sandberg@arm.com                        if (first) first = false;
76212037Sandreas.sandberg@arm.com                        else msg += ", ";
76312037Sandreas.sandberg@arm.com                        msg += pybind11::str("{}={!r}").format(kwarg.first, kwarg.second);
76412037Sandreas.sandberg@arm.com                    }
76512037Sandreas.sandberg@arm.com                }
76612037Sandreas.sandberg@arm.com            }
76712037Sandreas.sandberg@arm.com
76812391Sjason@lowepower.com            append_note_if_missing_header_is_suspected(msg);
76911986Sandreas.sandberg@arm.com            PyErr_SetString(PyExc_TypeError, msg.c_str());
77011986Sandreas.sandberg@arm.com            return nullptr;
77111986Sandreas.sandberg@arm.com        } else if (!result) {
77211986Sandreas.sandberg@arm.com            std::string msg = "Unable to convert function return value to a "
77311986Sandreas.sandberg@arm.com                              "Python type! The signature was\n\t";
77411986Sandreas.sandberg@arm.com            msg += it->signature;
77512391Sjason@lowepower.com            append_note_if_missing_header_is_suspected(msg);
77611986Sandreas.sandberg@arm.com            PyErr_SetString(PyExc_TypeError, msg.c_str());
77711986Sandreas.sandberg@arm.com            return nullptr;
77811986Sandreas.sandberg@arm.com        } else {
77912391Sjason@lowepower.com            if (overloads->is_constructor && !self_value_and_holder.holder_constructed()) {
78012391Sjason@lowepower.com                auto *pi = reinterpret_cast<instance *>(parent.ptr());
78112391Sjason@lowepower.com                self_value_and_holder.type->init_instance(pi, nullptr);
78211986Sandreas.sandberg@arm.com            }
78311986Sandreas.sandberg@arm.com            return result.ptr();
78411986Sandreas.sandberg@arm.com        }
78511986Sandreas.sandberg@arm.com    }
78611986Sandreas.sandberg@arm.com};
78711986Sandreas.sandberg@arm.com
78811986Sandreas.sandberg@arm.com/// Wrapper for Python extension modules
78911986Sandreas.sandberg@arm.comclass module : public object {
79011986Sandreas.sandberg@arm.compublic:
79111986Sandreas.sandberg@arm.com    PYBIND11_OBJECT_DEFAULT(module, object, PyModule_Check)
79211986Sandreas.sandberg@arm.com
79312037Sandreas.sandberg@arm.com    /// Create a new top-level Python module with the given name and docstring
79411986Sandreas.sandberg@arm.com    explicit module(const char *name, const char *doc = nullptr) {
79511986Sandreas.sandberg@arm.com        if (!options::show_user_defined_docstrings()) doc = nullptr;
79611986Sandreas.sandberg@arm.com#if PY_MAJOR_VERSION >= 3
79711986Sandreas.sandberg@arm.com        PyModuleDef *def = new PyModuleDef();
79812391Sjason@lowepower.com        std::memset(def, 0, sizeof(PyModuleDef));
79911986Sandreas.sandberg@arm.com        def->m_name = name;
80011986Sandreas.sandberg@arm.com        def->m_doc = doc;
80111986Sandreas.sandberg@arm.com        def->m_size = -1;
80211986Sandreas.sandberg@arm.com        Py_INCREF(def);
80311986Sandreas.sandberg@arm.com        m_ptr = PyModule_Create(def);
80411986Sandreas.sandberg@arm.com#else
80511986Sandreas.sandberg@arm.com        m_ptr = Py_InitModule3(name, nullptr, doc);
80611986Sandreas.sandberg@arm.com#endif
80711986Sandreas.sandberg@arm.com        if (m_ptr == nullptr)
80811986Sandreas.sandberg@arm.com            pybind11_fail("Internal error in module::module()");
80911986Sandreas.sandberg@arm.com        inc_ref();
81011986Sandreas.sandberg@arm.com    }
81111986Sandreas.sandberg@arm.com
81212037Sandreas.sandberg@arm.com    /** \rst
81312037Sandreas.sandberg@arm.com        Create Python binding for a new function within the module scope. ``Func``
81412037Sandreas.sandberg@arm.com        can be a plain C++ function, a function pointer, or a lambda function. For
81512037Sandreas.sandberg@arm.com        details on the ``Extra&& ... extra`` argument, see section :ref:`extras`.
81612037Sandreas.sandberg@arm.com    \endrst */
81711986Sandreas.sandberg@arm.com    template <typename Func, typename... Extra>
81811986Sandreas.sandberg@arm.com    module &def(const char *name_, Func &&f, const Extra& ... extra) {
81911986Sandreas.sandberg@arm.com        cpp_function func(std::forward<Func>(f), name(name_), scope(*this),
82011986Sandreas.sandberg@arm.com                          sibling(getattr(*this, name_, none())), extra...);
82111986Sandreas.sandberg@arm.com        // NB: allow overwriting here because cpp_function sets up a chain with the intention of
82211986Sandreas.sandberg@arm.com        // overwriting (and has already checked internally that it isn't overwriting non-functions).
82311986Sandreas.sandberg@arm.com        add_object(name_, func, true /* overwrite */);
82411986Sandreas.sandberg@arm.com        return *this;
82511986Sandreas.sandberg@arm.com    }
82611986Sandreas.sandberg@arm.com
82712037Sandreas.sandberg@arm.com    /** \rst
82812037Sandreas.sandberg@arm.com        Create and return a new Python submodule with the given name and docstring.
82912037Sandreas.sandberg@arm.com        This also works recursively, i.e.
83012037Sandreas.sandberg@arm.com
83112037Sandreas.sandberg@arm.com        .. code-block:: cpp
83212037Sandreas.sandberg@arm.com
83312037Sandreas.sandberg@arm.com            py::module m("example", "pybind11 example plugin");
83412037Sandreas.sandberg@arm.com            py::module m2 = m.def_submodule("sub", "A submodule of 'example'");
83512037Sandreas.sandberg@arm.com            py::module m3 = m2.def_submodule("subsub", "A submodule of 'example.sub'");
83612037Sandreas.sandberg@arm.com    \endrst */
83711986Sandreas.sandberg@arm.com    module def_submodule(const char *name, const char *doc = nullptr) {
83811986Sandreas.sandberg@arm.com        std::string full_name = std::string(PyModule_GetName(m_ptr))
83911986Sandreas.sandberg@arm.com            + std::string(".") + std::string(name);
84011986Sandreas.sandberg@arm.com        auto result = reinterpret_borrow<module>(PyImport_AddModule(full_name.c_str()));
84111986Sandreas.sandberg@arm.com        if (doc && options::show_user_defined_docstrings())
84211986Sandreas.sandberg@arm.com            result.attr("__doc__") = pybind11::str(doc);
84311986Sandreas.sandberg@arm.com        attr(name) = result;
84411986Sandreas.sandberg@arm.com        return result;
84511986Sandreas.sandberg@arm.com    }
84611986Sandreas.sandberg@arm.com
84712037Sandreas.sandberg@arm.com    /// Import and return a module or throws `error_already_set`.
84811986Sandreas.sandberg@arm.com    static module import(const char *name) {
84911986Sandreas.sandberg@arm.com        PyObject *obj = PyImport_ImportModule(name);
85011986Sandreas.sandberg@arm.com        if (!obj)
85111986Sandreas.sandberg@arm.com            throw error_already_set();
85211986Sandreas.sandberg@arm.com        return reinterpret_steal<module>(obj);
85311986Sandreas.sandberg@arm.com    }
85411986Sandreas.sandberg@arm.com
85512391Sjason@lowepower.com    /// Reload the module or throws `error_already_set`.
85612391Sjason@lowepower.com    void reload() {
85712391Sjason@lowepower.com        PyObject *obj = PyImport_ReloadModule(ptr());
85812391Sjason@lowepower.com        if (!obj)
85912391Sjason@lowepower.com            throw error_already_set();
86012391Sjason@lowepower.com        *this = reinterpret_steal<module>(obj);
86112391Sjason@lowepower.com    }
86212391Sjason@lowepower.com
86311986Sandreas.sandberg@arm.com    // Adds an object to the module using the given name.  Throws if an object with the given name
86411986Sandreas.sandberg@arm.com    // already exists.
86511986Sandreas.sandberg@arm.com    //
86611986Sandreas.sandberg@arm.com    // overwrite should almost always be false: attempting to overwrite objects that pybind11 has
86711986Sandreas.sandberg@arm.com    // established will, in most cases, break things.
86812391Sjason@lowepower.com    PYBIND11_NOINLINE void add_object(const char *name, handle obj, bool overwrite = false) {
86911986Sandreas.sandberg@arm.com        if (!overwrite && hasattr(*this, name))
87011986Sandreas.sandberg@arm.com            pybind11_fail("Error during initialization: multiple incompatible definitions with name \"" +
87111986Sandreas.sandberg@arm.com                    std::string(name) + "\"");
87211986Sandreas.sandberg@arm.com
87312391Sjason@lowepower.com        PyModule_AddObject(ptr(), name, obj.inc_ref().ptr() /* steals a reference */);
87411986Sandreas.sandberg@arm.com    }
87511986Sandreas.sandberg@arm.com};
87611986Sandreas.sandberg@arm.com
87712391Sjason@lowepower.com/// \ingroup python_builtins
87812391Sjason@lowepower.com/// Return a dictionary representing the global variables in the current execution frame,
87912391Sjason@lowepower.com/// or ``__main__.__dict__`` if there is no frame (usually when the interpreter is embedded).
88012391Sjason@lowepower.cominline dict globals() {
88112391Sjason@lowepower.com    PyObject *p = PyEval_GetGlobals();
88212391Sjason@lowepower.com    return reinterpret_borrow<dict>(p ? p : module::import("__main__").attr("__dict__").ptr());
88312391Sjason@lowepower.com}
88412391Sjason@lowepower.com
88511986Sandreas.sandberg@arm.comNAMESPACE_BEGIN(detail)
88611986Sandreas.sandberg@arm.com/// Generic support for creating new Python heap types
88711986Sandreas.sandberg@arm.comclass generic_type : public object {
88811986Sandreas.sandberg@arm.com    template <typename...> friend class class_;
88911986Sandreas.sandberg@arm.compublic:
89011986Sandreas.sandberg@arm.com    PYBIND11_OBJECT_DEFAULT(generic_type, object, PyType_Check)
89111986Sandreas.sandberg@arm.comprotected:
89212037Sandreas.sandberg@arm.com    void initialize(const type_record &rec) {
89312037Sandreas.sandberg@arm.com        if (rec.scope && hasattr(rec.scope, rec.name))
89412037Sandreas.sandberg@arm.com            pybind11_fail("generic_type: cannot initialize type \"" + std::string(rec.name) +
89512037Sandreas.sandberg@arm.com                          "\": an object with that name is already defined");
89611986Sandreas.sandberg@arm.com
89712391Sjason@lowepower.com        if (rec.module_local ? get_local_type_info(*rec.type) : get_global_type_info(*rec.type))
89812037Sandreas.sandberg@arm.com            pybind11_fail("generic_type: type \"" + std::string(rec.name) +
89911986Sandreas.sandberg@arm.com                          "\" is already registered!");
90011986Sandreas.sandberg@arm.com
90112037Sandreas.sandberg@arm.com        m_ptr = make_new_python_type(rec);
90211986Sandreas.sandberg@arm.com
90311986Sandreas.sandberg@arm.com        /* Register supplemental type information in C++ dict */
90412037Sandreas.sandberg@arm.com        auto *tinfo = new detail::type_info();
90512037Sandreas.sandberg@arm.com        tinfo->type = (PyTypeObject *) m_ptr;
90612391Sjason@lowepower.com        tinfo->cpptype = rec.type;
90712037Sandreas.sandberg@arm.com        tinfo->type_size = rec.type_size;
90814299Sbbruce@ucdavis.edu        tinfo->type_align = rec.type_align;
90912037Sandreas.sandberg@arm.com        tinfo->operator_new = rec.operator_new;
91012391Sjason@lowepower.com        tinfo->holder_size_in_ptrs = size_in_ptrs(rec.holder_size);
91112391Sjason@lowepower.com        tinfo->init_instance = rec.init_instance;
91212037Sandreas.sandberg@arm.com        tinfo->dealloc = rec.dealloc;
91312391Sjason@lowepower.com        tinfo->simple_type = true;
91412391Sjason@lowepower.com        tinfo->simple_ancestors = true;
91512391Sjason@lowepower.com        tinfo->default_holder = rec.default_holder;
91612391Sjason@lowepower.com        tinfo->module_local = rec.module_local;
91712037Sandreas.sandberg@arm.com
91812037Sandreas.sandberg@arm.com        auto &internals = get_internals();
91912037Sandreas.sandberg@arm.com        auto tindex = std::type_index(*rec.type);
92011986Sandreas.sandberg@arm.com        tinfo->direct_conversions = &internals.direct_conversions[tindex];
92112391Sjason@lowepower.com        if (rec.module_local)
92212391Sjason@lowepower.com            registered_local_types_cpp()[tindex] = tinfo;
92312391Sjason@lowepower.com        else
92412391Sjason@lowepower.com            internals.registered_types_cpp[tindex] = tinfo;
92512391Sjason@lowepower.com        internals.registered_types_py[(PyTypeObject *) m_ptr] = { tinfo };
92611986Sandreas.sandberg@arm.com
92712391Sjason@lowepower.com        if (rec.bases.size() > 1 || rec.multiple_inheritance) {
92812037Sandreas.sandberg@arm.com            mark_parents_nonsimple(tinfo->type);
92912391Sjason@lowepower.com            tinfo->simple_ancestors = false;
93012391Sjason@lowepower.com        }
93112391Sjason@lowepower.com        else if (rec.bases.size() == 1) {
93212391Sjason@lowepower.com            auto parent_tinfo = get_type_info((PyTypeObject *) rec.bases[0].ptr());
93312391Sjason@lowepower.com            tinfo->simple_ancestors = parent_tinfo->simple_ancestors;
93412391Sjason@lowepower.com        }
93512391Sjason@lowepower.com
93612391Sjason@lowepower.com        if (rec.module_local) {
93712391Sjason@lowepower.com            // Stash the local typeinfo and loader so that external modules can access it.
93812391Sjason@lowepower.com            tinfo->module_local_load = &type_caster_generic::local_load;
93912391Sjason@lowepower.com            setattr(m_ptr, PYBIND11_MODULE_LOCAL_ID, capsule(tinfo));
94012391Sjason@lowepower.com        }
94111986Sandreas.sandberg@arm.com    }
94211986Sandreas.sandberg@arm.com
94311986Sandreas.sandberg@arm.com    /// Helper function which tags all parents of a type using mult. inheritance
94411986Sandreas.sandberg@arm.com    void mark_parents_nonsimple(PyTypeObject *value) {
94511986Sandreas.sandberg@arm.com        auto t = reinterpret_borrow<tuple>(value->tp_bases);
94611986Sandreas.sandberg@arm.com        for (handle h : t) {
94711986Sandreas.sandberg@arm.com            auto tinfo2 = get_type_info((PyTypeObject *) h.ptr());
94811986Sandreas.sandberg@arm.com            if (tinfo2)
94911986Sandreas.sandberg@arm.com                tinfo2->simple_type = false;
95011986Sandreas.sandberg@arm.com            mark_parents_nonsimple((PyTypeObject *) h.ptr());
95111986Sandreas.sandberg@arm.com        }
95211986Sandreas.sandberg@arm.com    }
95311986Sandreas.sandberg@arm.com
95411986Sandreas.sandberg@arm.com    void install_buffer_funcs(
95511986Sandreas.sandberg@arm.com            buffer_info *(*get_buffer)(PyObject *, void *),
95611986Sandreas.sandberg@arm.com            void *get_buffer_data) {
95711986Sandreas.sandberg@arm.com        PyHeapTypeObject *type = (PyHeapTypeObject*) m_ptr;
95811986Sandreas.sandberg@arm.com        auto tinfo = detail::get_type_info(&type->ht_type);
95912037Sandreas.sandberg@arm.com
96012037Sandreas.sandberg@arm.com        if (!type->ht_type.tp_as_buffer)
96112037Sandreas.sandberg@arm.com            pybind11_fail(
96212037Sandreas.sandberg@arm.com                "To be able to register buffer protocol support for the type '" +
96312037Sandreas.sandberg@arm.com                std::string(tinfo->type->tp_name) +
96412037Sandreas.sandberg@arm.com                "' the associated class<>(..) invocation must "
96512037Sandreas.sandberg@arm.com                "include the pybind11::buffer_protocol() annotation!");
96612037Sandreas.sandberg@arm.com
96711986Sandreas.sandberg@arm.com        tinfo->get_buffer = get_buffer;
96811986Sandreas.sandberg@arm.com        tinfo->get_buffer_data = get_buffer_data;
96911986Sandreas.sandberg@arm.com    }
97011986Sandreas.sandberg@arm.com
97114299Sbbruce@ucdavis.edu    // rec_func must be set for either fget or fset.
97212037Sandreas.sandberg@arm.com    void def_property_static_impl(const char *name,
97312037Sandreas.sandberg@arm.com                                  handle fget, handle fset,
97414299Sbbruce@ucdavis.edu                                  detail::function_record *rec_func) {
97514299Sbbruce@ucdavis.edu        const auto is_static = rec_func && !(rec_func->is_method && rec_func->scope);
97614299Sbbruce@ucdavis.edu        const auto has_doc = rec_func && rec_func->doc && pybind11::options::show_user_defined_docstrings();
97712037Sandreas.sandberg@arm.com        auto property = handle((PyObject *) (is_static ? get_internals().static_property_type
97812037Sandreas.sandberg@arm.com                                                       : &PyProperty_Type));
97912037Sandreas.sandberg@arm.com        attr(name) = property(fget.ptr() ? fget : none(),
98012037Sandreas.sandberg@arm.com                              fset.ptr() ? fset : none(),
98112037Sandreas.sandberg@arm.com                              /*deleter*/none(),
98214299Sbbruce@ucdavis.edu                              pybind11::str(has_doc ? rec_func->doc : ""));
98311986Sandreas.sandberg@arm.com    }
98412037Sandreas.sandberg@arm.com};
98511986Sandreas.sandberg@arm.com
98612037Sandreas.sandberg@arm.com/// Set the pointer to operator new if it exists. The cast is needed because it can be overloaded.
98712037Sandreas.sandberg@arm.comtemplate <typename T, typename = void_t<decltype(static_cast<void *(*)(size_t)>(T::operator new))>>
98812037Sandreas.sandberg@arm.comvoid set_operator_new(type_record *r) { r->operator_new = &T::operator new; }
98912037Sandreas.sandberg@arm.com
99012037Sandreas.sandberg@arm.comtemplate <typename> void set_operator_new(...) { }
99112037Sandreas.sandberg@arm.com
99212391Sjason@lowepower.comtemplate <typename T, typename SFINAE = void> struct has_operator_delete : std::false_type { };
99312391Sjason@lowepower.comtemplate <typename T> struct has_operator_delete<T, void_t<decltype(static_cast<void (*)(void *)>(T::operator delete))>>
99412391Sjason@lowepower.com    : std::true_type { };
99512391Sjason@lowepower.comtemplate <typename T, typename SFINAE = void> struct has_operator_delete_size : std::false_type { };
99612391Sjason@lowepower.comtemplate <typename T> struct has_operator_delete_size<T, void_t<decltype(static_cast<void (*)(void *, size_t)>(T::operator delete))>>
99712391Sjason@lowepower.com    : std::true_type { };
99812037Sandreas.sandberg@arm.com/// Call class-specific delete if it exists or global otherwise. Can also be an overload set.
99912391Sjason@lowepower.comtemplate <typename T, enable_if_t<has_operator_delete<T>::value, int> = 0>
100014299Sbbruce@ucdavis.eduvoid call_operator_delete(T *p, size_t, size_t) { T::operator delete(p); }
100112391Sjason@lowepower.comtemplate <typename T, enable_if_t<!has_operator_delete<T>::value && has_operator_delete_size<T>::value, int> = 0>
100214299Sbbruce@ucdavis.eduvoid call_operator_delete(T *p, size_t s, size_t) { T::operator delete(p, s); }
100312037Sandreas.sandberg@arm.com
100414299Sbbruce@ucdavis.eduinline void call_operator_delete(void *p, size_t s, size_t a) {
100514299Sbbruce@ucdavis.edu    (void)s; (void)a;
100614299Sbbruce@ucdavis.edu#if defined(PYBIND11_CPP17)
100714299Sbbruce@ucdavis.edu    if (a > __STDCPP_DEFAULT_NEW_ALIGNMENT__)
100814299Sbbruce@ucdavis.edu        ::operator delete(p, s, std::align_val_t(a));
100914299Sbbruce@ucdavis.edu    else
101014299Sbbruce@ucdavis.edu        ::operator delete(p, s);
101114299Sbbruce@ucdavis.edu#else
101214299Sbbruce@ucdavis.edu    ::operator delete(p);
101314299Sbbruce@ucdavis.edu#endif
101414299Sbbruce@ucdavis.edu}
101511986Sandreas.sandberg@arm.com
101611986Sandreas.sandberg@arm.comNAMESPACE_END(detail)
101711986Sandreas.sandberg@arm.com
101812391Sjason@lowepower.com/// Given a pointer to a member function, cast it to its `Derived` version.
101912391Sjason@lowepower.com/// Forward everything else unchanged.
102012391Sjason@lowepower.comtemplate <typename /*Derived*/, typename F>
102112391Sjason@lowepower.comauto method_adaptor(F &&f) -> decltype(std::forward<F>(f)) { return std::forward<F>(f); }
102212391Sjason@lowepower.com
102312391Sjason@lowepower.comtemplate <typename Derived, typename Return, typename Class, typename... Args>
102414299Sbbruce@ucdavis.eduauto method_adaptor(Return (Class::*pmf)(Args...)) -> Return (Derived::*)(Args...) {
102514299Sbbruce@ucdavis.edu    static_assert(detail::is_accessible_base_of<Class, Derived>::value,
102614299Sbbruce@ucdavis.edu        "Cannot bind an inaccessible base class method; use a lambda definition instead");
102714299Sbbruce@ucdavis.edu    return pmf;
102814299Sbbruce@ucdavis.edu}
102912391Sjason@lowepower.com
103012391Sjason@lowepower.comtemplate <typename Derived, typename Return, typename Class, typename... Args>
103114299Sbbruce@ucdavis.eduauto method_adaptor(Return (Class::*pmf)(Args...) const) -> Return (Derived::*)(Args...) const {
103214299Sbbruce@ucdavis.edu    static_assert(detail::is_accessible_base_of<Class, Derived>::value,
103314299Sbbruce@ucdavis.edu        "Cannot bind an inaccessible base class method; use a lambda definition instead");
103414299Sbbruce@ucdavis.edu    return pmf;
103514299Sbbruce@ucdavis.edu}
103612391Sjason@lowepower.com
103711986Sandreas.sandberg@arm.comtemplate <typename type_, typename... options>
103811986Sandreas.sandberg@arm.comclass class_ : public detail::generic_type {
103911986Sandreas.sandberg@arm.com    template <typename T> using is_holder = detail::is_holder_type<type_, T>;
104012391Sjason@lowepower.com    template <typename T> using is_subtype = detail::is_strict_base_of<type_, T>;
104112391Sjason@lowepower.com    template <typename T> using is_base = detail::is_strict_base_of<T, type_>;
104212037Sandreas.sandberg@arm.com    // struct instead of using here to help MSVC:
104312037Sandreas.sandberg@arm.com    template <typename T> struct is_valid_class_option :
104412037Sandreas.sandberg@arm.com        detail::any_of<is_holder<T>, is_subtype<T>, is_base<T>> {};
104511986Sandreas.sandberg@arm.com
104611986Sandreas.sandberg@arm.compublic:
104711986Sandreas.sandberg@arm.com    using type = type_;
104812391Sjason@lowepower.com    using type_alias = detail::exactly_one_t<is_subtype, void, options...>;
104911986Sandreas.sandberg@arm.com    constexpr static bool has_alias = !std::is_void<type_alias>::value;
105012391Sjason@lowepower.com    using holder_type = detail::exactly_one_t<is_holder, std::unique_ptr<type>, options...>;
105111986Sandreas.sandberg@arm.com
105212037Sandreas.sandberg@arm.com    static_assert(detail::all_of<is_valid_class_option<options>...>::value,
105311986Sandreas.sandberg@arm.com            "Unknown/invalid class_ template parameters provided");
105411986Sandreas.sandberg@arm.com
105512391Sjason@lowepower.com    static_assert(!has_alias || std::is_polymorphic<type>::value,
105612391Sjason@lowepower.com            "Cannot use an alias class with a non-polymorphic type");
105712391Sjason@lowepower.com
105811986Sandreas.sandberg@arm.com    PYBIND11_OBJECT(class_, generic_type, PyType_Check)
105911986Sandreas.sandberg@arm.com
106011986Sandreas.sandberg@arm.com    template <typename... Extra>
106111986Sandreas.sandberg@arm.com    class_(handle scope, const char *name, const Extra &... extra) {
106212037Sandreas.sandberg@arm.com        using namespace detail;
106312037Sandreas.sandberg@arm.com
106412037Sandreas.sandberg@arm.com        // MI can only be specified via class_ template options, not constructor parameters
106512037Sandreas.sandberg@arm.com        static_assert(
106612037Sandreas.sandberg@arm.com            none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
106712037Sandreas.sandberg@arm.com            (   constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
106812037Sandreas.sandberg@arm.com                constexpr_sum(is_base<options>::value...)   == 0 && // no template option bases
106912037Sandreas.sandberg@arm.com                none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
107012037Sandreas.sandberg@arm.com            "Error: multiple inheritance bases must be specified via class_ template options");
107112037Sandreas.sandberg@arm.com
107212037Sandreas.sandberg@arm.com        type_record record;
107311986Sandreas.sandberg@arm.com        record.scope = scope;
107411986Sandreas.sandberg@arm.com        record.name = name;
107511986Sandreas.sandberg@arm.com        record.type = &typeid(type);
107612037Sandreas.sandberg@arm.com        record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
107714299Sbbruce@ucdavis.edu        record.type_align = alignof(conditional_t<has_alias, type_alias, type>&);
107812391Sjason@lowepower.com        record.holder_size = sizeof(holder_type);
107912391Sjason@lowepower.com        record.init_instance = init_instance;
108011986Sandreas.sandberg@arm.com        record.dealloc = dealloc;
108114299Sbbruce@ucdavis.edu        record.default_holder = detail::is_instantiation<std::unique_ptr, holder_type>::value;
108212037Sandreas.sandberg@arm.com
108312037Sandreas.sandberg@arm.com        set_operator_new<type>(&record);
108411986Sandreas.sandberg@arm.com
108511986Sandreas.sandberg@arm.com        /* Register base classes specified via template arguments to class_, if any */
108612391Sjason@lowepower.com        PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));
108711986Sandreas.sandberg@arm.com
108811986Sandreas.sandberg@arm.com        /* Process optional arguments, if any */
108912037Sandreas.sandberg@arm.com        process_attributes<Extra...>::init(extra..., &record);
109011986Sandreas.sandberg@arm.com
109112037Sandreas.sandberg@arm.com        generic_type::initialize(record);
109211986Sandreas.sandberg@arm.com
109311986Sandreas.sandberg@arm.com        if (has_alias) {
109412391Sjason@lowepower.com            auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp;
109511986Sandreas.sandberg@arm.com            instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
109611986Sandreas.sandberg@arm.com        }
109711986Sandreas.sandberg@arm.com    }
109811986Sandreas.sandberg@arm.com
109911986Sandreas.sandberg@arm.com    template <typename Base, detail::enable_if_t<is_base<Base>::value, int> = 0>
110011986Sandreas.sandberg@arm.com    static void add_base(detail::type_record &rec) {
110112391Sjason@lowepower.com        rec.add_base(typeid(Base), [](void *src) -> void * {
110211986Sandreas.sandberg@arm.com            return static_cast<Base *>(reinterpret_cast<type *>(src));
110311986Sandreas.sandberg@arm.com        });
110411986Sandreas.sandberg@arm.com    }
110511986Sandreas.sandberg@arm.com
110611986Sandreas.sandberg@arm.com    template <typename Base, detail::enable_if_t<!is_base<Base>::value, int> = 0>
110711986Sandreas.sandberg@arm.com    static void add_base(detail::type_record &) { }
110811986Sandreas.sandberg@arm.com
110911986Sandreas.sandberg@arm.com    template <typename Func, typename... Extra>
111011986Sandreas.sandberg@arm.com    class_ &def(const char *name_, Func&& f, const Extra&... extra) {
111112391Sjason@lowepower.com        cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
111211986Sandreas.sandberg@arm.com                        sibling(getattr(*this, name_, none())), extra...);
111311986Sandreas.sandberg@arm.com        attr(cf.name()) = cf;
111411986Sandreas.sandberg@arm.com        return *this;
111511986Sandreas.sandberg@arm.com    }
111611986Sandreas.sandberg@arm.com
111711986Sandreas.sandberg@arm.com    template <typename Func, typename... Extra> class_ &
111812037Sandreas.sandberg@arm.com    def_static(const char *name_, Func &&f, const Extra&... extra) {
111912037Sandreas.sandberg@arm.com        static_assert(!std::is_member_function_pointer<Func>::value,
112012037Sandreas.sandberg@arm.com                "def_static(...) called with a non-static member function pointer");
112111986Sandreas.sandberg@arm.com        cpp_function cf(std::forward<Func>(f), name(name_), scope(*this),
112211986Sandreas.sandberg@arm.com                        sibling(getattr(*this, name_, none())), extra...);
112314299Sbbruce@ucdavis.edu        attr(cf.name()) = staticmethod(cf);
112411986Sandreas.sandberg@arm.com        return *this;
112511986Sandreas.sandberg@arm.com    }
112611986Sandreas.sandberg@arm.com
112711986Sandreas.sandberg@arm.com    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
112811986Sandreas.sandberg@arm.com    class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
112911986Sandreas.sandberg@arm.com        op.execute(*this, extra...);
113011986Sandreas.sandberg@arm.com        return *this;
113111986Sandreas.sandberg@arm.com    }
113211986Sandreas.sandberg@arm.com
113311986Sandreas.sandberg@arm.com    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
113411986Sandreas.sandberg@arm.com    class_ & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
113511986Sandreas.sandberg@arm.com        op.execute_cast(*this, extra...);
113611986Sandreas.sandberg@arm.com        return *this;
113711986Sandreas.sandberg@arm.com    }
113811986Sandreas.sandberg@arm.com
113911986Sandreas.sandberg@arm.com    template <typename... Args, typename... Extra>
114012391Sjason@lowepower.com    class_ &def(const detail::initimpl::constructor<Args...> &init, const Extra&... extra) {
114111986Sandreas.sandberg@arm.com        init.execute(*this, extra...);
114211986Sandreas.sandberg@arm.com        return *this;
114311986Sandreas.sandberg@arm.com    }
114411986Sandreas.sandberg@arm.com
114511986Sandreas.sandberg@arm.com    template <typename... Args, typename... Extra>
114612391Sjason@lowepower.com    class_ &def(const detail::initimpl::alias_constructor<Args...> &init, const Extra&... extra) {
114711986Sandreas.sandberg@arm.com        init.execute(*this, extra...);
114811986Sandreas.sandberg@arm.com        return *this;
114911986Sandreas.sandberg@arm.com    }
115011986Sandreas.sandberg@arm.com
115112391Sjason@lowepower.com    template <typename... Args, typename... Extra>
115212391Sjason@lowepower.com    class_ &def(detail::initimpl::factory<Args...> &&init, const Extra&... extra) {
115312391Sjason@lowepower.com        std::move(init).execute(*this, extra...);
115412391Sjason@lowepower.com        return *this;
115512391Sjason@lowepower.com    }
115612391Sjason@lowepower.com
115712391Sjason@lowepower.com    template <typename... Args, typename... Extra>
115812391Sjason@lowepower.com    class_ &def(detail::initimpl::pickle_factory<Args...> &&pf, const Extra &...extra) {
115912391Sjason@lowepower.com        std::move(pf).execute(*this, extra...);
116012391Sjason@lowepower.com        return *this;
116112391Sjason@lowepower.com    }
116212391Sjason@lowepower.com
116311986Sandreas.sandberg@arm.com    template <typename Func> class_& def_buffer(Func &&func) {
116411986Sandreas.sandberg@arm.com        struct capture { Func func; };
116511986Sandreas.sandberg@arm.com        capture *ptr = new capture { std::forward<Func>(func) };
116611986Sandreas.sandberg@arm.com        install_buffer_funcs([](PyObject *obj, void *ptr) -> buffer_info* {
116712037Sandreas.sandberg@arm.com            detail::make_caster<type> caster;
116811986Sandreas.sandberg@arm.com            if (!caster.load(obj, false))
116911986Sandreas.sandberg@arm.com                return nullptr;
117011986Sandreas.sandberg@arm.com            return new buffer_info(((capture *) ptr)->func(caster));
117111986Sandreas.sandberg@arm.com        }, ptr);
117211986Sandreas.sandberg@arm.com        return *this;
117311986Sandreas.sandberg@arm.com    }
117411986Sandreas.sandberg@arm.com
117512391Sjason@lowepower.com    template <typename Return, typename Class, typename... Args>
117612391Sjason@lowepower.com    class_ &def_buffer(Return (Class::*func)(Args...)) {
117712391Sjason@lowepower.com        return def_buffer([func] (type &obj) { return (obj.*func)(); });
117812391Sjason@lowepower.com    }
117912391Sjason@lowepower.com
118012391Sjason@lowepower.com    template <typename Return, typename Class, typename... Args>
118112391Sjason@lowepower.com    class_ &def_buffer(Return (Class::*func)(Args...) const) {
118212391Sjason@lowepower.com        return def_buffer([func] (const type &obj) { return (obj.*func)(); });
118312391Sjason@lowepower.com    }
118412391Sjason@lowepower.com
118511986Sandreas.sandberg@arm.com    template <typename C, typename D, typename... Extra>
118611986Sandreas.sandberg@arm.com    class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
118714299Sbbruce@ucdavis.edu        static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readwrite() requires a class member (or base class member)");
118812391Sjason@lowepower.com        cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this)),
118912391Sjason@lowepower.com                     fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this));
119011986Sandreas.sandberg@arm.com        def_property(name, fget, fset, return_value_policy::reference_internal, extra...);
119111986Sandreas.sandberg@arm.com        return *this;
119211986Sandreas.sandberg@arm.com    }
119311986Sandreas.sandberg@arm.com
119411986Sandreas.sandberg@arm.com    template <typename C, typename D, typename... Extra>
119511986Sandreas.sandberg@arm.com    class_ &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) {
119614299Sbbruce@ucdavis.edu        static_assert(std::is_same<C, type>::value || std::is_base_of<C, type>::value, "def_readonly() requires a class member (or base class member)");
119712391Sjason@lowepower.com        cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this));
119811986Sandreas.sandberg@arm.com        def_property_readonly(name, fget, return_value_policy::reference_internal, extra...);
119911986Sandreas.sandberg@arm.com        return *this;
120011986Sandreas.sandberg@arm.com    }
120111986Sandreas.sandberg@arm.com
120211986Sandreas.sandberg@arm.com    template <typename D, typename... Extra>
120311986Sandreas.sandberg@arm.com    class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
120411986Sandreas.sandberg@arm.com        cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this)),
120511986Sandreas.sandberg@arm.com                     fset([pm](object, const D &value) { *pm = value; }, scope(*this));
120611986Sandreas.sandberg@arm.com        def_property_static(name, fget, fset, return_value_policy::reference, extra...);
120711986Sandreas.sandberg@arm.com        return *this;
120811986Sandreas.sandberg@arm.com    }
120911986Sandreas.sandberg@arm.com
121011986Sandreas.sandberg@arm.com    template <typename D, typename... Extra>
121111986Sandreas.sandberg@arm.com    class_ &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
121211986Sandreas.sandberg@arm.com        cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this));
121311986Sandreas.sandberg@arm.com        def_property_readonly_static(name, fget, return_value_policy::reference, extra...);
121411986Sandreas.sandberg@arm.com        return *this;
121511986Sandreas.sandberg@arm.com    }
121611986Sandreas.sandberg@arm.com
121711986Sandreas.sandberg@arm.com    /// Uses return_value_policy::reference_internal by default
121811986Sandreas.sandberg@arm.com    template <typename Getter, typename... Extra>
121911986Sandreas.sandberg@arm.com    class_ &def_property_readonly(const char *name, const Getter &fget, const Extra& ...extra) {
122012391Sjason@lowepower.com        return def_property_readonly(name, cpp_function(method_adaptor<type>(fget)),
122112391Sjason@lowepower.com                                     return_value_policy::reference_internal, extra...);
122211986Sandreas.sandberg@arm.com    }
122311986Sandreas.sandberg@arm.com
122411986Sandreas.sandberg@arm.com    /// Uses cpp_function's return_value_policy by default
122511986Sandreas.sandberg@arm.com    template <typename... Extra>
122611986Sandreas.sandberg@arm.com    class_ &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) {
122714299Sbbruce@ucdavis.edu        return def_property(name, fget, nullptr, extra...);
122811986Sandreas.sandberg@arm.com    }
122911986Sandreas.sandberg@arm.com
123011986Sandreas.sandberg@arm.com    /// Uses return_value_policy::reference by default
123111986Sandreas.sandberg@arm.com    template <typename Getter, typename... Extra>
123211986Sandreas.sandberg@arm.com    class_ &def_property_readonly_static(const char *name, const Getter &fget, const Extra& ...extra) {
123311986Sandreas.sandberg@arm.com        return def_property_readonly_static(name, cpp_function(fget), return_value_policy::reference, extra...);
123411986Sandreas.sandberg@arm.com    }
123511986Sandreas.sandberg@arm.com
123611986Sandreas.sandberg@arm.com    /// Uses cpp_function's return_value_policy by default
123711986Sandreas.sandberg@arm.com    template <typename... Extra>
123811986Sandreas.sandberg@arm.com    class_ &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) {
123914299Sbbruce@ucdavis.edu        return def_property_static(name, fget, nullptr, extra...);
124011986Sandreas.sandberg@arm.com    }
124111986Sandreas.sandberg@arm.com
124211986Sandreas.sandberg@arm.com    /// Uses return_value_policy::reference_internal by default
124312391Sjason@lowepower.com    template <typename Getter, typename Setter, typename... Extra>
124412391Sjason@lowepower.com    class_ &def_property(const char *name, const Getter &fget, const Setter &fset, const Extra& ...extra) {
124512391Sjason@lowepower.com        return def_property(name, fget, cpp_function(method_adaptor<type>(fset)), extra...);
124612391Sjason@lowepower.com    }
124711986Sandreas.sandberg@arm.com    template <typename Getter, typename... Extra>
124811986Sandreas.sandberg@arm.com    class_ &def_property(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
124912391Sjason@lowepower.com        return def_property(name, cpp_function(method_adaptor<type>(fget)), fset,
125012391Sjason@lowepower.com                            return_value_policy::reference_internal, extra...);
125111986Sandreas.sandberg@arm.com    }
125211986Sandreas.sandberg@arm.com
125311986Sandreas.sandberg@arm.com    /// Uses cpp_function's return_value_policy by default
125411986Sandreas.sandberg@arm.com    template <typename... Extra>
125511986Sandreas.sandberg@arm.com    class_ &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
125611986Sandreas.sandberg@arm.com        return def_property_static(name, fget, fset, is_method(*this), extra...);
125711986Sandreas.sandberg@arm.com    }
125811986Sandreas.sandberg@arm.com
125911986Sandreas.sandberg@arm.com    /// Uses return_value_policy::reference by default
126011986Sandreas.sandberg@arm.com    template <typename Getter, typename... Extra>
126111986Sandreas.sandberg@arm.com    class_ &def_property_static(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
126211986Sandreas.sandberg@arm.com        return def_property_static(name, cpp_function(fget), fset, return_value_policy::reference, extra...);
126311986Sandreas.sandberg@arm.com    }
126411986Sandreas.sandberg@arm.com
126511986Sandreas.sandberg@arm.com    /// Uses cpp_function's return_value_policy by default
126611986Sandreas.sandberg@arm.com    template <typename... Extra>
126711986Sandreas.sandberg@arm.com    class_ &def_property_static(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
126814299Sbbruce@ucdavis.edu        static_assert( 0 == detail::constexpr_sum(std::is_base_of<arg, Extra>::value...),
126914299Sbbruce@ucdavis.edu                      "Argument annotations are not allowed for properties");
127011986Sandreas.sandberg@arm.com        auto rec_fget = get_function_record(fget), rec_fset = get_function_record(fset);
127114299Sbbruce@ucdavis.edu        auto *rec_active = rec_fget;
127214299Sbbruce@ucdavis.edu        if (rec_fget) {
127314299Sbbruce@ucdavis.edu           char *doc_prev = rec_fget->doc; /* 'extra' field may include a property-specific documentation string */
127414299Sbbruce@ucdavis.edu           detail::process_attributes<Extra...>::init(extra..., rec_fget);
127514299Sbbruce@ucdavis.edu           if (rec_fget->doc && rec_fget->doc != doc_prev) {
127614299Sbbruce@ucdavis.edu              free(doc_prev);
127714299Sbbruce@ucdavis.edu              rec_fget->doc = strdup(rec_fget->doc);
127814299Sbbruce@ucdavis.edu           }
127911986Sandreas.sandberg@arm.com        }
128011986Sandreas.sandberg@arm.com        if (rec_fset) {
128114299Sbbruce@ucdavis.edu            char *doc_prev = rec_fset->doc;
128211986Sandreas.sandberg@arm.com            detail::process_attributes<Extra...>::init(extra..., rec_fset);
128311986Sandreas.sandberg@arm.com            if (rec_fset->doc && rec_fset->doc != doc_prev) {
128411986Sandreas.sandberg@arm.com                free(doc_prev);
128511986Sandreas.sandberg@arm.com                rec_fset->doc = strdup(rec_fset->doc);
128611986Sandreas.sandberg@arm.com            }
128714299Sbbruce@ucdavis.edu            if (! rec_active) rec_active = rec_fset;
128811986Sandreas.sandberg@arm.com        }
128914299Sbbruce@ucdavis.edu        def_property_static_impl(name, fget, fset, rec_active);
129011986Sandreas.sandberg@arm.com        return *this;
129111986Sandreas.sandberg@arm.com    }
129211986Sandreas.sandberg@arm.com
129311986Sandreas.sandberg@arm.comprivate:
129411986Sandreas.sandberg@arm.com    /// Initialize holder object, variant 1: object derives from enable_shared_from_this
129511986Sandreas.sandberg@arm.com    template <typename T>
129612391Sjason@lowepower.com    static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
129712391Sjason@lowepower.com            const holder_type * /* unused */, const std::enable_shared_from_this<T> * /* dummy */) {
129811986Sandreas.sandberg@arm.com        try {
129912391Sjason@lowepower.com            auto sh = std::dynamic_pointer_cast<typename holder_type::element_type>(
130012391Sjason@lowepower.com                    v_h.value_ptr<type>()->shared_from_this());
130112391Sjason@lowepower.com            if (sh) {
130214299Sbbruce@ucdavis.edu                new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(sh));
130312391Sjason@lowepower.com                v_h.set_holder_constructed();
130411986Sandreas.sandberg@arm.com            }
130512391Sjason@lowepower.com        } catch (const std::bad_weak_ptr &) {}
130612391Sjason@lowepower.com
130712391Sjason@lowepower.com        if (!v_h.holder_constructed() && inst->owned) {
130814299Sbbruce@ucdavis.edu            new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
130912391Sjason@lowepower.com            v_h.set_holder_constructed();
131011986Sandreas.sandberg@arm.com        }
131111986Sandreas.sandberg@arm.com    }
131211986Sandreas.sandberg@arm.com
131312391Sjason@lowepower.com    static void init_holder_from_existing(const detail::value_and_holder &v_h,
131412391Sjason@lowepower.com            const holder_type *holder_ptr, std::true_type /*is_copy_constructible*/) {
131514299Sbbruce@ucdavis.edu        new (std::addressof(v_h.holder<holder_type>())) holder_type(*reinterpret_cast<const holder_type *>(holder_ptr));
131612037Sandreas.sandberg@arm.com    }
131712037Sandreas.sandberg@arm.com
131812391Sjason@lowepower.com    static void init_holder_from_existing(const detail::value_and_holder &v_h,
131912391Sjason@lowepower.com            const holder_type *holder_ptr, std::false_type /*is_copy_constructible*/) {
132014299Sbbruce@ucdavis.edu        new (std::addressof(v_h.holder<holder_type>())) holder_type(std::move(*const_cast<holder_type *>(holder_ptr)));
132112037Sandreas.sandberg@arm.com    }
132212037Sandreas.sandberg@arm.com
132311986Sandreas.sandberg@arm.com    /// Initialize holder object, variant 2: try to construct from existing holder object, if possible
132412391Sjason@lowepower.com    static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
132512391Sjason@lowepower.com            const holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) {
132611986Sandreas.sandberg@arm.com        if (holder_ptr) {
132712391Sjason@lowepower.com            init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible<holder_type>());
132812391Sjason@lowepower.com            v_h.set_holder_constructed();
132912037Sandreas.sandberg@arm.com        } else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
133014299Sbbruce@ucdavis.edu            new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
133112391Sjason@lowepower.com            v_h.set_holder_constructed();
133211986Sandreas.sandberg@arm.com        }
133311986Sandreas.sandberg@arm.com    }
133411986Sandreas.sandberg@arm.com
133512391Sjason@lowepower.com    /// Performs instance initialization including constructing a holder and registering the known
133612391Sjason@lowepower.com    /// instance.  Should be called as soon as the `type` value_ptr is set for an instance.  Takes an
133712391Sjason@lowepower.com    /// optional pointer to an existing holder to use; if not specified and the instance is
133812391Sjason@lowepower.com    /// `.owned`, a new holder will be constructed to manage the value pointer.
133912391Sjason@lowepower.com    static void init_instance(detail::instance *inst, const void *holder_ptr) {
134012391Sjason@lowepower.com        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
134112391Sjason@lowepower.com        if (!v_h.instance_registered()) {
134212391Sjason@lowepower.com            register_instance(inst, v_h.value_ptr(), v_h.type);
134312391Sjason@lowepower.com            v_h.set_instance_registered();
134412391Sjason@lowepower.com        }
134512391Sjason@lowepower.com        init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
134611986Sandreas.sandberg@arm.com    }
134711986Sandreas.sandberg@arm.com
134812391Sjason@lowepower.com    /// Deallocates an instance; via holder, if constructed; otherwise via operator delete.
134912391Sjason@lowepower.com    static void dealloc(detail::value_and_holder &v_h) {
135012391Sjason@lowepower.com        if (v_h.holder_constructed()) {
135112391Sjason@lowepower.com            v_h.holder<holder_type>().~holder_type();
135212391Sjason@lowepower.com            v_h.set_holder_constructed(false);
135312391Sjason@lowepower.com        }
135412391Sjason@lowepower.com        else {
135514299Sbbruce@ucdavis.edu            detail::call_operator_delete(v_h.value_ptr<type>(),
135614299Sbbruce@ucdavis.edu                v_h.type->type_size,
135714299Sbbruce@ucdavis.edu                v_h.type->type_align
135814299Sbbruce@ucdavis.edu            );
135912391Sjason@lowepower.com        }
136012391Sjason@lowepower.com        v_h.value_ptr() = nullptr;
136111986Sandreas.sandberg@arm.com    }
136211986Sandreas.sandberg@arm.com
136311986Sandreas.sandberg@arm.com    static detail::function_record *get_function_record(handle h) {
136411986Sandreas.sandberg@arm.com        h = detail::get_function(h);
136512037Sandreas.sandberg@arm.com        return h ? (detail::function_record *) reinterpret_borrow<capsule>(PyCFunction_GET_SELF(h.ptr()))
136611986Sandreas.sandberg@arm.com                 : nullptr;
136711986Sandreas.sandberg@arm.com    }
136811986Sandreas.sandberg@arm.com};
136911986Sandreas.sandberg@arm.com
137012391Sjason@lowepower.com/// Binds an existing constructor taking arguments Args...
137112391Sjason@lowepower.comtemplate <typename... Args> detail::initimpl::constructor<Args...> init() { return {}; }
137212391Sjason@lowepower.com/// Like `init<Args...>()`, but the instance is always constructed through the alias class (even
137312391Sjason@lowepower.com/// when not inheriting on the Python side).
137412391Sjason@lowepower.comtemplate <typename... Args> detail::initimpl::alias_constructor<Args...> init_alias() { return {}; }
137512391Sjason@lowepower.com
137612391Sjason@lowepower.com/// Binds a factory function as a constructor
137712391Sjason@lowepower.comtemplate <typename Func, typename Ret = detail::initimpl::factory<Func>>
137812391Sjason@lowepower.comRet init(Func &&f) { return {std::forward<Func>(f)}; }
137912391Sjason@lowepower.com
138012391Sjason@lowepower.com/// Dual-argument factory function: the first function is called when no alias is needed, the second
138112391Sjason@lowepower.com/// when an alias is needed (i.e. due to python-side inheritance).  Arguments must be identical.
138212391Sjason@lowepower.comtemplate <typename CFunc, typename AFunc, typename Ret = detail::initimpl::factory<CFunc, AFunc>>
138312391Sjason@lowepower.comRet init(CFunc &&c, AFunc &&a) {
138412391Sjason@lowepower.com    return {std::forward<CFunc>(c), std::forward<AFunc>(a)};
138512391Sjason@lowepower.com}
138612391Sjason@lowepower.com
138712391Sjason@lowepower.com/// Binds pickling functions `__getstate__` and `__setstate__` and ensures that the type
138812391Sjason@lowepower.com/// returned by `__getstate__` is the same as the argument accepted by `__setstate__`.
138912391Sjason@lowepower.comtemplate <typename GetState, typename SetState>
139012391Sjason@lowepower.comdetail::initimpl::pickle_factory<GetState, SetState> pickle(GetState &&g, SetState &&s) {
139112391Sjason@lowepower.com    return {std::forward<GetState>(g), std::forward<SetState>(s)};
139212391Sjason@lowepower.com}
139312391Sjason@lowepower.com
139414299Sbbruce@ucdavis.eduNAMESPACE_BEGIN(detail)
139514299Sbbruce@ucdavis.edustruct enum_base {
139614299Sbbruce@ucdavis.edu    enum_base(handle base, handle parent) : m_base(base), m_parent(parent) { }
139714299Sbbruce@ucdavis.edu
139814299Sbbruce@ucdavis.edu    PYBIND11_NOINLINE void init(bool is_arithmetic, bool is_convertible) {
139914299Sbbruce@ucdavis.edu        m_base.attr("__entries") = dict();
140014299Sbbruce@ucdavis.edu        auto property = handle((PyObject *) &PyProperty_Type);
140114299Sbbruce@ucdavis.edu        auto static_property = handle((PyObject *) get_internals().static_property_type);
140214299Sbbruce@ucdavis.edu
140314299Sbbruce@ucdavis.edu        m_base.attr("__repr__") = cpp_function(
140414299Sbbruce@ucdavis.edu            [](handle arg) -> str {
140514299Sbbruce@ucdavis.edu                handle type = arg.get_type();
140614299Sbbruce@ucdavis.edu                object type_name = type.attr("__name__");
140714299Sbbruce@ucdavis.edu                dict entries = type.attr("__entries");
140814299Sbbruce@ucdavis.edu                for (const auto &kv : entries) {
140914299Sbbruce@ucdavis.edu                    object other = kv.second[int_(0)];
141014299Sbbruce@ucdavis.edu                    if (other.equal(arg))
141114299Sbbruce@ucdavis.edu                        return pybind11::str("{}.{}").format(type_name, kv.first);
141214299Sbbruce@ucdavis.edu                }
141314299Sbbruce@ucdavis.edu                return pybind11::str("{}.???").format(type_name);
141414299Sbbruce@ucdavis.edu            }, is_method(m_base)
141514299Sbbruce@ucdavis.edu        );
141614299Sbbruce@ucdavis.edu
141714299Sbbruce@ucdavis.edu        m_base.attr("name") = property(cpp_function(
141814299Sbbruce@ucdavis.edu            [](handle arg) -> str {
141914299Sbbruce@ucdavis.edu                dict entries = arg.get_type().attr("__entries");
142014299Sbbruce@ucdavis.edu                for (const auto &kv : entries) {
142114299Sbbruce@ucdavis.edu                    if (handle(kv.second[int_(0)]).equal(arg))
142214299Sbbruce@ucdavis.edu                        return pybind11::str(kv.first);
142314299Sbbruce@ucdavis.edu                }
142414299Sbbruce@ucdavis.edu                return "???";
142514299Sbbruce@ucdavis.edu            }, is_method(m_base)
142614299Sbbruce@ucdavis.edu        ));
142714299Sbbruce@ucdavis.edu
142814299Sbbruce@ucdavis.edu        m_base.attr("__doc__") = static_property(cpp_function(
142914299Sbbruce@ucdavis.edu            [](handle arg) -> std::string {
143014299Sbbruce@ucdavis.edu                std::string docstring;
143114299Sbbruce@ucdavis.edu                dict entries = arg.attr("__entries");
143214299Sbbruce@ucdavis.edu                if (((PyTypeObject *) arg.ptr())->tp_doc)
143314299Sbbruce@ucdavis.edu                    docstring += std::string(((PyTypeObject *) arg.ptr())->tp_doc) + "\n\n";
143414299Sbbruce@ucdavis.edu                docstring += "Members:";
143514299Sbbruce@ucdavis.edu                for (const auto &kv : entries) {
143614299Sbbruce@ucdavis.edu                    auto key = std::string(pybind11::str(kv.first));
143714299Sbbruce@ucdavis.edu                    auto comment = kv.second[int_(1)];
143814299Sbbruce@ucdavis.edu                    docstring += "\n\n  " + key;
143914299Sbbruce@ucdavis.edu                    if (!comment.is_none())
144014299Sbbruce@ucdavis.edu                        docstring += " : " + (std::string) pybind11::str(comment);
144114299Sbbruce@ucdavis.edu                }
144214299Sbbruce@ucdavis.edu                return docstring;
144314299Sbbruce@ucdavis.edu            }
144414299Sbbruce@ucdavis.edu        ), none(), none(), "");
144514299Sbbruce@ucdavis.edu
144614299Sbbruce@ucdavis.edu        m_base.attr("__members__") = static_property(cpp_function(
144714299Sbbruce@ucdavis.edu            [](handle arg) -> dict {
144814299Sbbruce@ucdavis.edu                dict entries = arg.attr("__entries"), m;
144914299Sbbruce@ucdavis.edu                for (const auto &kv : entries)
145014299Sbbruce@ucdavis.edu                    m[kv.first] = kv.second[int_(0)];
145114299Sbbruce@ucdavis.edu                return m;
145214299Sbbruce@ucdavis.edu            }), none(), none(), ""
145314299Sbbruce@ucdavis.edu        );
145414299Sbbruce@ucdavis.edu
145514299Sbbruce@ucdavis.edu        #define PYBIND11_ENUM_OP_STRICT(op, expr, strict_behavior)                     \
145614299Sbbruce@ucdavis.edu            m_base.attr(op) = cpp_function(                                            \
145714299Sbbruce@ucdavis.edu                [](object a, object b) {                                               \
145814299Sbbruce@ucdavis.edu                    if (!a.get_type().is(b.get_type()))                                \
145914299Sbbruce@ucdavis.edu                        strict_behavior;                                               \
146014299Sbbruce@ucdavis.edu                    return expr;                                                       \
146114299Sbbruce@ucdavis.edu                },                                                                     \
146214299Sbbruce@ucdavis.edu                is_method(m_base))
146314299Sbbruce@ucdavis.edu
146414299Sbbruce@ucdavis.edu        #define PYBIND11_ENUM_OP_CONV(op, expr)                                        \
146514299Sbbruce@ucdavis.edu            m_base.attr(op) = cpp_function(                                            \
146614299Sbbruce@ucdavis.edu                [](object a_, object b_) {                                             \
146714299Sbbruce@ucdavis.edu                    int_ a(a_), b(b_);                                                 \
146814299Sbbruce@ucdavis.edu                    return expr;                                                       \
146914299Sbbruce@ucdavis.edu                },                                                                     \
147014299Sbbruce@ucdavis.edu                is_method(m_base))
147114299Sbbruce@ucdavis.edu
147214299Sbbruce@ucdavis.edu        #define PYBIND11_ENUM_OP_CONV_LHS(op, expr)                                    \
147314299Sbbruce@ucdavis.edu            m_base.attr(op) = cpp_function(                                            \
147414299Sbbruce@ucdavis.edu                [](object a_, object b) {                                              \
147514299Sbbruce@ucdavis.edu                    int_ a(a_);                                                        \
147614299Sbbruce@ucdavis.edu                    return expr;                                                       \
147714299Sbbruce@ucdavis.edu                },                                                                     \
147814299Sbbruce@ucdavis.edu                is_method(m_base))
147914299Sbbruce@ucdavis.edu
148014299Sbbruce@ucdavis.edu        if (is_convertible) {
148114299Sbbruce@ucdavis.edu            PYBIND11_ENUM_OP_CONV_LHS("__eq__", !b.is_none() &&  a.equal(b));
148214299Sbbruce@ucdavis.edu            PYBIND11_ENUM_OP_CONV_LHS("__ne__",  b.is_none() || !a.equal(b));
148314299Sbbruce@ucdavis.edu
148414299Sbbruce@ucdavis.edu            if (is_arithmetic) {
148514299Sbbruce@ucdavis.edu                PYBIND11_ENUM_OP_CONV("__lt__",   a <  b);
148614299Sbbruce@ucdavis.edu                PYBIND11_ENUM_OP_CONV("__gt__",   a >  b);
148714299Sbbruce@ucdavis.edu                PYBIND11_ENUM_OP_CONV("__le__",   a <= b);
148814299Sbbruce@ucdavis.edu                PYBIND11_ENUM_OP_CONV("__ge__",   a >= b);
148914299Sbbruce@ucdavis.edu                PYBIND11_ENUM_OP_CONV("__and__",  a &  b);
149014299Sbbruce@ucdavis.edu                PYBIND11_ENUM_OP_CONV("__rand__", a &  b);
149114299Sbbruce@ucdavis.edu                PYBIND11_ENUM_OP_CONV("__or__",   a |  b);
149214299Sbbruce@ucdavis.edu                PYBIND11_ENUM_OP_CONV("__ror__",  a |  b);
149314299Sbbruce@ucdavis.edu                PYBIND11_ENUM_OP_CONV("__xor__",  a ^  b);
149414299Sbbruce@ucdavis.edu                PYBIND11_ENUM_OP_CONV("__rxor__", a ^  b);
149514299Sbbruce@ucdavis.edu                m_base.attr("__invert__") = cpp_function(
149614299Sbbruce@ucdavis.edu                    [](object arg) { return ~(int_(arg)); }, is_method(m_base));
149714299Sbbruce@ucdavis.edu            }
149814299Sbbruce@ucdavis.edu        } else {
149914299Sbbruce@ucdavis.edu            PYBIND11_ENUM_OP_STRICT("__eq__",  int_(a).equal(int_(b)), return false);
150014299Sbbruce@ucdavis.edu            PYBIND11_ENUM_OP_STRICT("__ne__", !int_(a).equal(int_(b)), return true);
150114299Sbbruce@ucdavis.edu
150214299Sbbruce@ucdavis.edu            if (is_arithmetic) {
150314299Sbbruce@ucdavis.edu                #define PYBIND11_THROW throw type_error("Expected an enumeration of matching type!");
150414299Sbbruce@ucdavis.edu                PYBIND11_ENUM_OP_STRICT("__lt__", int_(a) <  int_(b), PYBIND11_THROW);
150514299Sbbruce@ucdavis.edu                PYBIND11_ENUM_OP_STRICT("__gt__", int_(a) >  int_(b), PYBIND11_THROW);
150614299Sbbruce@ucdavis.edu                PYBIND11_ENUM_OP_STRICT("__le__", int_(a) <= int_(b), PYBIND11_THROW);
150714299Sbbruce@ucdavis.edu                PYBIND11_ENUM_OP_STRICT("__ge__", int_(a) >= int_(b), PYBIND11_THROW);
150814299Sbbruce@ucdavis.edu                #undef PYBIND11_THROW
150914299Sbbruce@ucdavis.edu            }
151014299Sbbruce@ucdavis.edu        }
151114299Sbbruce@ucdavis.edu
151214299Sbbruce@ucdavis.edu        #undef PYBIND11_ENUM_OP_CONV_LHS
151314299Sbbruce@ucdavis.edu        #undef PYBIND11_ENUM_OP_CONV
151414299Sbbruce@ucdavis.edu        #undef PYBIND11_ENUM_OP_STRICT
151514299Sbbruce@ucdavis.edu
151614299Sbbruce@ucdavis.edu        object getstate = cpp_function(
151714299Sbbruce@ucdavis.edu            [](object arg) { return int_(arg); }, is_method(m_base));
151814299Sbbruce@ucdavis.edu
151914299Sbbruce@ucdavis.edu        m_base.attr("__getstate__") = getstate;
152014299Sbbruce@ucdavis.edu        m_base.attr("__hash__") = getstate;
152114299Sbbruce@ucdavis.edu    }
152214299Sbbruce@ucdavis.edu
152314299Sbbruce@ucdavis.edu    PYBIND11_NOINLINE void value(char const* name_, object value, const char *doc = nullptr) {
152414299Sbbruce@ucdavis.edu        dict entries = m_base.attr("__entries");
152514299Sbbruce@ucdavis.edu        str name(name_);
152614299Sbbruce@ucdavis.edu        if (entries.contains(name)) {
152714299Sbbruce@ucdavis.edu            std::string type_name = (std::string) str(m_base.attr("__name__"));
152814299Sbbruce@ucdavis.edu            throw value_error(type_name + ": element \"" + std::string(name_) + "\" already exists!");
152914299Sbbruce@ucdavis.edu        }
153014299Sbbruce@ucdavis.edu
153114299Sbbruce@ucdavis.edu        entries[name] = std::make_pair(value, doc);
153214299Sbbruce@ucdavis.edu        m_base.attr(name) = value;
153314299Sbbruce@ucdavis.edu    }
153414299Sbbruce@ucdavis.edu
153514299Sbbruce@ucdavis.edu    PYBIND11_NOINLINE void export_values() {
153614299Sbbruce@ucdavis.edu        dict entries = m_base.attr("__entries");
153714299Sbbruce@ucdavis.edu        for (const auto &kv : entries)
153814299Sbbruce@ucdavis.edu            m_parent.attr(kv.first) = kv.second[int_(0)];
153914299Sbbruce@ucdavis.edu    }
154014299Sbbruce@ucdavis.edu
154114299Sbbruce@ucdavis.edu    handle m_base;
154214299Sbbruce@ucdavis.edu    handle m_parent;
154314299Sbbruce@ucdavis.edu};
154414299Sbbruce@ucdavis.edu
154514299Sbbruce@ucdavis.eduNAMESPACE_END(detail)
154614299Sbbruce@ucdavis.edu
154711986Sandreas.sandberg@arm.com/// Binds C++ enumerations and enumeration classes to Python
154811986Sandreas.sandberg@arm.comtemplate <typename Type> class enum_ : public class_<Type> {
154911986Sandreas.sandberg@arm.compublic:
155014299Sbbruce@ucdavis.edu    using Base = class_<Type>;
155114299Sbbruce@ucdavis.edu    using Base::def;
155214299Sbbruce@ucdavis.edu    using Base::attr;
155314299Sbbruce@ucdavis.edu    using Base::def_property_readonly;
155414299Sbbruce@ucdavis.edu    using Base::def_property_readonly_static;
155511986Sandreas.sandberg@arm.com    using Scalar = typename std::underlying_type<Type>::type;
155611986Sandreas.sandberg@arm.com
155711986Sandreas.sandberg@arm.com    template <typename... Extra>
155811986Sandreas.sandberg@arm.com    enum_(const handle &scope, const char *name, const Extra&... extra)
155914299Sbbruce@ucdavis.edu      : class_<Type>(scope, name, extra...), m_base(*this, scope) {
156014299Sbbruce@ucdavis.edu        constexpr bool is_arithmetic = detail::any_of<std::is_same<arithmetic, Extra>...>::value;
156114299Sbbruce@ucdavis.edu        constexpr bool is_convertible = std::is_convertible<Type, Scalar>::value;
156214299Sbbruce@ucdavis.edu        m_base.init(is_arithmetic, is_convertible);
156311986Sandreas.sandberg@arm.com
156412391Sjason@lowepower.com        def(init([](Scalar i) { return static_cast<Type>(i); }));
156511986Sandreas.sandberg@arm.com        def("__int__", [](Type value) { return (Scalar) value; });
156612391Sjason@lowepower.com        #if PY_MAJOR_VERSION < 3
156712391Sjason@lowepower.com            def("__long__", [](Type value) { return (Scalar) value; });
156812391Sjason@lowepower.com        #endif
156914299Sbbruce@ucdavis.edu        #if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 8
157014299Sbbruce@ucdavis.edu            def("__index__", [](Type value) { return (Scalar) value; });
157114299Sbbruce@ucdavis.edu        #endif
157214299Sbbruce@ucdavis.edu
157314299Sbbruce@ucdavis.edu        cpp_function setstate(
157414299Sbbruce@ucdavis.edu            [](Type &value, Scalar arg) { value = static_cast<Type>(arg); },
157514299Sbbruce@ucdavis.edu            is_method(*this));
157614299Sbbruce@ucdavis.edu        attr("__setstate__") = setstate;
157711986Sandreas.sandberg@arm.com    }
157811986Sandreas.sandberg@arm.com
157911986Sandreas.sandberg@arm.com    /// Export enumeration entries into the parent scope
158012037Sandreas.sandberg@arm.com    enum_& export_values() {
158114299Sbbruce@ucdavis.edu        m_base.export_values();
158211986Sandreas.sandberg@arm.com        return *this;
158311986Sandreas.sandberg@arm.com    }
158411986Sandreas.sandberg@arm.com
158511986Sandreas.sandberg@arm.com    /// Add an enumeration entry
158614299Sbbruce@ucdavis.edu    enum_& value(char const* name, Type value, const char *doc = nullptr) {
158714299Sbbruce@ucdavis.edu        m_base.value(name, pybind11::cast(value, return_value_policy::copy), doc);
158811986Sandreas.sandberg@arm.com        return *this;
158911986Sandreas.sandberg@arm.com    }
159012037Sandreas.sandberg@arm.com
159111986Sandreas.sandberg@arm.comprivate:
159214299Sbbruce@ucdavis.edu    detail::enum_base m_base;
159311986Sandreas.sandberg@arm.com};
159411986Sandreas.sandberg@arm.com
159511986Sandreas.sandberg@arm.comNAMESPACE_BEGIN(detail)
159611986Sandreas.sandberg@arm.com
159711986Sandreas.sandberg@arm.com
159811986Sandreas.sandberg@arm.cominline void keep_alive_impl(handle nurse, handle patient) {
159911986Sandreas.sandberg@arm.com    if (!nurse || !patient)
160011986Sandreas.sandberg@arm.com        pybind11_fail("Could not activate keep_alive!");
160111986Sandreas.sandberg@arm.com
160211986Sandreas.sandberg@arm.com    if (patient.is_none() || nurse.is_none())
160311986Sandreas.sandberg@arm.com        return; /* Nothing to keep alive or nothing to be kept alive by */
160411986Sandreas.sandberg@arm.com
160512391Sjason@lowepower.com    auto tinfo = all_type_info(Py_TYPE(nurse.ptr()));
160612391Sjason@lowepower.com    if (!tinfo.empty()) {
160712391Sjason@lowepower.com        /* It's a pybind-registered type, so we can store the patient in the
160812391Sjason@lowepower.com         * internal list. */
160912391Sjason@lowepower.com        add_patient(nurse.ptr(), patient.ptr());
161012391Sjason@lowepower.com    }
161112391Sjason@lowepower.com    else {
161212391Sjason@lowepower.com        /* Fall back to clever approach based on weak references taken from
161312391Sjason@lowepower.com         * Boost.Python. This is not used for pybind-registered types because
161412391Sjason@lowepower.com         * the objects can be destroyed out-of-order in a GC pass. */
161512391Sjason@lowepower.com        cpp_function disable_lifesupport(
161612391Sjason@lowepower.com            [patient](handle weakref) { patient.dec_ref(); weakref.dec_ref(); });
161711986Sandreas.sandberg@arm.com
161812391Sjason@lowepower.com        weakref wr(nurse, disable_lifesupport);
161911986Sandreas.sandberg@arm.com
162012391Sjason@lowepower.com        patient.inc_ref(); /* reference patient and leak the weak reference */
162112391Sjason@lowepower.com        (void) wr.release();
162212391Sjason@lowepower.com    }
162311986Sandreas.sandberg@arm.com}
162411986Sandreas.sandberg@arm.com
162512037Sandreas.sandberg@arm.comPYBIND11_NOINLINE inline void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret) {
162612391Sjason@lowepower.com    auto get_arg = [&](size_t n) {
162712391Sjason@lowepower.com        if (n == 0)
162812391Sjason@lowepower.com            return ret;
162912391Sjason@lowepower.com        else if (n == 1 && call.init_self)
163012391Sjason@lowepower.com            return call.init_self;
163112391Sjason@lowepower.com        else if (n <= call.args.size())
163212391Sjason@lowepower.com            return call.args[n - 1];
163312391Sjason@lowepower.com        return handle();
163412391Sjason@lowepower.com    };
163512391Sjason@lowepower.com
163612391Sjason@lowepower.com    keep_alive_impl(get_arg(Nurse), get_arg(Patient));
163712391Sjason@lowepower.com}
163812391Sjason@lowepower.com
163912391Sjason@lowepower.cominline std::pair<decltype(internals::registered_types_py)::iterator, bool> all_type_info_get_cache(PyTypeObject *type) {
164012391Sjason@lowepower.com    auto res = get_internals().registered_types_py
164112391Sjason@lowepower.com#ifdef __cpp_lib_unordered_map_try_emplace
164212391Sjason@lowepower.com        .try_emplace(type);
164312391Sjason@lowepower.com#else
164412391Sjason@lowepower.com        .emplace(type, std::vector<detail::type_info *>());
164512391Sjason@lowepower.com#endif
164612391Sjason@lowepower.com    if (res.second) {
164712391Sjason@lowepower.com        // New cache entry created; set up a weak reference to automatically remove it if the type
164812391Sjason@lowepower.com        // gets destroyed:
164912391Sjason@lowepower.com        weakref((PyObject *) type, cpp_function([type](handle wr) {
165012391Sjason@lowepower.com            get_internals().registered_types_py.erase(type);
165112391Sjason@lowepower.com            wr.dec_ref();
165212391Sjason@lowepower.com        })).release();
165312391Sjason@lowepower.com    }
165412391Sjason@lowepower.com
165512391Sjason@lowepower.com    return res;
165611986Sandreas.sandberg@arm.com}
165711986Sandreas.sandberg@arm.com
165811986Sandreas.sandberg@arm.comtemplate <typename Iterator, typename Sentinel, bool KeyIterator, return_value_policy Policy>
165911986Sandreas.sandberg@arm.comstruct iterator_state {
166011986Sandreas.sandberg@arm.com    Iterator it;
166111986Sandreas.sandberg@arm.com    Sentinel end;
166212391Sjason@lowepower.com    bool first_or_done;
166311986Sandreas.sandberg@arm.com};
166411986Sandreas.sandberg@arm.com
166511986Sandreas.sandberg@arm.comNAMESPACE_END(detail)
166611986Sandreas.sandberg@arm.com
166712037Sandreas.sandberg@arm.com/// Makes a python iterator from a first and past-the-end C++ InputIterator.
166811986Sandreas.sandberg@arm.comtemplate <return_value_policy Policy = return_value_policy::reference_internal,
166911986Sandreas.sandberg@arm.com          typename Iterator,
167011986Sandreas.sandberg@arm.com          typename Sentinel,
167111986Sandreas.sandberg@arm.com          typename ValueType = decltype(*std::declval<Iterator>()),
167211986Sandreas.sandberg@arm.com          typename... Extra>
167311986Sandreas.sandberg@arm.comiterator make_iterator(Iterator first, Sentinel last, Extra &&... extra) {
167411986Sandreas.sandberg@arm.com    typedef detail::iterator_state<Iterator, Sentinel, false, Policy> state;
167511986Sandreas.sandberg@arm.com
167611986Sandreas.sandberg@arm.com    if (!detail::get_type_info(typeid(state), false)) {
167712391Sjason@lowepower.com        class_<state>(handle(), "iterator", pybind11::module_local())
167811986Sandreas.sandberg@arm.com            .def("__iter__", [](state &s) -> state& { return s; })
167911986Sandreas.sandberg@arm.com            .def("__next__", [](state &s) -> ValueType {
168012391Sjason@lowepower.com                if (!s.first_or_done)
168111986Sandreas.sandberg@arm.com                    ++s.it;
168211986Sandreas.sandberg@arm.com                else
168312391Sjason@lowepower.com                    s.first_or_done = false;
168412391Sjason@lowepower.com                if (s.it == s.end) {
168512391Sjason@lowepower.com                    s.first_or_done = true;
168611986Sandreas.sandberg@arm.com                    throw stop_iteration();
168712391Sjason@lowepower.com                }
168811986Sandreas.sandberg@arm.com                return *s.it;
168911986Sandreas.sandberg@arm.com            }, std::forward<Extra>(extra)..., Policy);
169011986Sandreas.sandberg@arm.com    }
169111986Sandreas.sandberg@arm.com
169212391Sjason@lowepower.com    return cast(state{first, last, true});
169311986Sandreas.sandberg@arm.com}
169411986Sandreas.sandberg@arm.com
169512037Sandreas.sandberg@arm.com/// Makes an python iterator over the keys (`.first`) of a iterator over pairs from a
169612037Sandreas.sandberg@arm.com/// first and past-the-end InputIterator.
169711986Sandreas.sandberg@arm.comtemplate <return_value_policy Policy = return_value_policy::reference_internal,
169811986Sandreas.sandberg@arm.com          typename Iterator,
169911986Sandreas.sandberg@arm.com          typename Sentinel,
170011986Sandreas.sandberg@arm.com          typename KeyType = decltype((*std::declval<Iterator>()).first),
170111986Sandreas.sandberg@arm.com          typename... Extra>
170211986Sandreas.sandberg@arm.comiterator make_key_iterator(Iterator first, Sentinel last, Extra &&... extra) {
170311986Sandreas.sandberg@arm.com    typedef detail::iterator_state<Iterator, Sentinel, true, Policy> state;
170411986Sandreas.sandberg@arm.com
170511986Sandreas.sandberg@arm.com    if (!detail::get_type_info(typeid(state), false)) {
170612391Sjason@lowepower.com        class_<state>(handle(), "iterator", pybind11::module_local())
170711986Sandreas.sandberg@arm.com            .def("__iter__", [](state &s) -> state& { return s; })
170811986Sandreas.sandberg@arm.com            .def("__next__", [](state &s) -> KeyType {
170912391Sjason@lowepower.com                if (!s.first_or_done)
171011986Sandreas.sandberg@arm.com                    ++s.it;
171111986Sandreas.sandberg@arm.com                else
171212391Sjason@lowepower.com                    s.first_or_done = false;
171312391Sjason@lowepower.com                if (s.it == s.end) {
171412391Sjason@lowepower.com                    s.first_or_done = true;
171511986Sandreas.sandberg@arm.com                    throw stop_iteration();
171612391Sjason@lowepower.com                }
171711986Sandreas.sandberg@arm.com                return (*s.it).first;
171811986Sandreas.sandberg@arm.com            }, std::forward<Extra>(extra)..., Policy);
171911986Sandreas.sandberg@arm.com    }
172011986Sandreas.sandberg@arm.com
172112391Sjason@lowepower.com    return cast(state{first, last, true});
172211986Sandreas.sandberg@arm.com}
172311986Sandreas.sandberg@arm.com
172412037Sandreas.sandberg@arm.com/// Makes an iterator over values of an stl container or other container supporting
172512037Sandreas.sandberg@arm.com/// `std::begin()`/`std::end()`
172611986Sandreas.sandberg@arm.comtemplate <return_value_policy Policy = return_value_policy::reference_internal,
172711986Sandreas.sandberg@arm.com          typename Type, typename... Extra> iterator make_iterator(Type &value, Extra&&... extra) {
172811986Sandreas.sandberg@arm.com    return make_iterator<Policy>(std::begin(value), std::end(value), extra...);
172911986Sandreas.sandberg@arm.com}
173011986Sandreas.sandberg@arm.com
173112037Sandreas.sandberg@arm.com/// Makes an iterator over the keys (`.first`) of a stl map-like container supporting
173212037Sandreas.sandberg@arm.com/// `std::begin()`/`std::end()`
173311986Sandreas.sandberg@arm.comtemplate <return_value_policy Policy = return_value_policy::reference_internal,
173411986Sandreas.sandberg@arm.com          typename Type, typename... Extra> iterator make_key_iterator(Type &value, Extra&&... extra) {
173511986Sandreas.sandberg@arm.com    return make_key_iterator<Policy>(std::begin(value), std::end(value), extra...);
173611986Sandreas.sandberg@arm.com}
173711986Sandreas.sandberg@arm.com
173811986Sandreas.sandberg@arm.comtemplate <typename InputType, typename OutputType> void implicitly_convertible() {
173912391Sjason@lowepower.com    struct set_flag {
174012391Sjason@lowepower.com        bool &flag;
174112391Sjason@lowepower.com        set_flag(bool &flag) : flag(flag) { flag = true; }
174212391Sjason@lowepower.com        ~set_flag() { flag = false; }
174312391Sjason@lowepower.com    };
174411986Sandreas.sandberg@arm.com    auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject * {
174512391Sjason@lowepower.com        static bool currently_used = false;
174612391Sjason@lowepower.com        if (currently_used) // implicit conversions are non-reentrant
174712391Sjason@lowepower.com            return nullptr;
174812391Sjason@lowepower.com        set_flag flag_helper(currently_used);
174912037Sandreas.sandberg@arm.com        if (!detail::make_caster<InputType>().load(obj, false))
175011986Sandreas.sandberg@arm.com            return nullptr;
175111986Sandreas.sandberg@arm.com        tuple args(1);
175211986Sandreas.sandberg@arm.com        args[0] = obj;
175311986Sandreas.sandberg@arm.com        PyObject *result = PyObject_Call((PyObject *) type, args.ptr(), nullptr);
175411986Sandreas.sandberg@arm.com        if (result == nullptr)
175511986Sandreas.sandberg@arm.com            PyErr_Clear();
175611986Sandreas.sandberg@arm.com        return result;
175711986Sandreas.sandberg@arm.com    };
175811986Sandreas.sandberg@arm.com
175911986Sandreas.sandberg@arm.com    if (auto tinfo = detail::get_type_info(typeid(OutputType)))
176011986Sandreas.sandberg@arm.com        tinfo->implicit_conversions.push_back(implicit_caster);
176111986Sandreas.sandberg@arm.com    else
176211986Sandreas.sandberg@arm.com        pybind11_fail("implicitly_convertible: Unable to find type " + type_id<OutputType>());
176311986Sandreas.sandberg@arm.com}
176411986Sandreas.sandberg@arm.com
176511986Sandreas.sandberg@arm.comtemplate <typename ExceptionTranslator>
176611986Sandreas.sandberg@arm.comvoid register_exception_translator(ExceptionTranslator&& translator) {
176711986Sandreas.sandberg@arm.com    detail::get_internals().registered_exception_translators.push_front(
176811986Sandreas.sandberg@arm.com        std::forward<ExceptionTranslator>(translator));
176911986Sandreas.sandberg@arm.com}
177011986Sandreas.sandberg@arm.com
177112391Sjason@lowepower.com/**
177212391Sjason@lowepower.com * Wrapper to generate a new Python exception type.
177311986Sandreas.sandberg@arm.com *
177411986Sandreas.sandberg@arm.com * This should only be used with PyErr_SetString for now.
177511986Sandreas.sandberg@arm.com * It is not (yet) possible to use as a py::base.
177611986Sandreas.sandberg@arm.com * Template type argument is reserved for future use.
177711986Sandreas.sandberg@arm.com */
177811986Sandreas.sandberg@arm.comtemplate <typename type>
177911986Sandreas.sandberg@arm.comclass exception : public object {
178011986Sandreas.sandberg@arm.compublic:
178114299Sbbruce@ucdavis.edu    exception() = default;
178211986Sandreas.sandberg@arm.com    exception(handle scope, const char *name, PyObject *base = PyExc_Exception) {
178311986Sandreas.sandberg@arm.com        std::string full_name = scope.attr("__name__").cast<std::string>() +
178411986Sandreas.sandberg@arm.com                                std::string(".") + name;
178512037Sandreas.sandberg@arm.com        m_ptr = PyErr_NewException(const_cast<char *>(full_name.c_str()), base, NULL);
178611986Sandreas.sandberg@arm.com        if (hasattr(scope, name))
178711986Sandreas.sandberg@arm.com            pybind11_fail("Error during initialization: multiple incompatible "
178811986Sandreas.sandberg@arm.com                          "definitions with name \"" + std::string(name) + "\"");
178911986Sandreas.sandberg@arm.com        scope.attr(name) = *this;
179011986Sandreas.sandberg@arm.com    }
179111986Sandreas.sandberg@arm.com
179211986Sandreas.sandberg@arm.com    // Sets the current python exception to this exception object with the given message
179311986Sandreas.sandberg@arm.com    void operator()(const char *message) {
179411986Sandreas.sandberg@arm.com        PyErr_SetString(m_ptr, message);
179511986Sandreas.sandberg@arm.com    }
179611986Sandreas.sandberg@arm.com};
179711986Sandreas.sandberg@arm.com
179814299Sbbruce@ucdavis.eduNAMESPACE_BEGIN(detail)
179914299Sbbruce@ucdavis.edu// Returns a reference to a function-local static exception object used in the simple
180014299Sbbruce@ucdavis.edu// register_exception approach below.  (It would be simpler to have the static local variable
180114299Sbbruce@ucdavis.edu// directly in register_exception, but that makes clang <3.5 segfault - issue #1349).
180214299Sbbruce@ucdavis.edutemplate <typename CppException>
180314299Sbbruce@ucdavis.eduexception<CppException> &get_exception_object() { static exception<CppException> ex; return ex; }
180414299Sbbruce@ucdavis.eduNAMESPACE_END(detail)
180514299Sbbruce@ucdavis.edu
180612391Sjason@lowepower.com/**
180712391Sjason@lowepower.com * Registers a Python exception in `m` of the given `name` and installs an exception translator to
180811986Sandreas.sandberg@arm.com * translate the C++ exception to the created Python exception using the exceptions what() method.
180911986Sandreas.sandberg@arm.com * This is intended for simple exception translations; for more complex translation, register the
181011986Sandreas.sandberg@arm.com * exception object and translator directly.
181111986Sandreas.sandberg@arm.com */
181211986Sandreas.sandberg@arm.comtemplate <typename CppException>
181311986Sandreas.sandberg@arm.comexception<CppException> &register_exception(handle scope,
181411986Sandreas.sandberg@arm.com                                            const char *name,
181511986Sandreas.sandberg@arm.com                                            PyObject *base = PyExc_Exception) {
181614299Sbbruce@ucdavis.edu    auto &ex = detail::get_exception_object<CppException>();
181714299Sbbruce@ucdavis.edu    if (!ex) ex = exception<CppException>(scope, name, base);
181814299Sbbruce@ucdavis.edu
181911986Sandreas.sandberg@arm.com    register_exception_translator([](std::exception_ptr p) {
182011986Sandreas.sandberg@arm.com        if (!p) return;
182111986Sandreas.sandberg@arm.com        try {
182211986Sandreas.sandberg@arm.com            std::rethrow_exception(p);
182311986Sandreas.sandberg@arm.com        } catch (const CppException &e) {
182414299Sbbruce@ucdavis.edu            detail::get_exception_object<CppException>()(e.what());
182511986Sandreas.sandberg@arm.com        }
182611986Sandreas.sandberg@arm.com    });
182711986Sandreas.sandberg@arm.com    return ex;
182811986Sandreas.sandberg@arm.com}
182911986Sandreas.sandberg@arm.com
183011986Sandreas.sandberg@arm.comNAMESPACE_BEGIN(detail)
183111986Sandreas.sandberg@arm.comPYBIND11_NOINLINE inline void print(tuple args, dict kwargs) {
183211986Sandreas.sandberg@arm.com    auto strings = tuple(args.size());
183311986Sandreas.sandberg@arm.com    for (size_t i = 0; i < args.size(); ++i) {
183411986Sandreas.sandberg@arm.com        strings[i] = str(args[i]);
183511986Sandreas.sandberg@arm.com    }
183611986Sandreas.sandberg@arm.com    auto sep = kwargs.contains("sep") ? kwargs["sep"] : cast(" ");
183711986Sandreas.sandberg@arm.com    auto line = sep.attr("join")(strings);
183811986Sandreas.sandberg@arm.com
183911986Sandreas.sandberg@arm.com    object file;
184011986Sandreas.sandberg@arm.com    if (kwargs.contains("file")) {
184111986Sandreas.sandberg@arm.com        file = kwargs["file"].cast<object>();
184211986Sandreas.sandberg@arm.com    } else {
184311986Sandreas.sandberg@arm.com        try {
184411986Sandreas.sandberg@arm.com            file = module::import("sys").attr("stdout");
184511986Sandreas.sandberg@arm.com        } catch (const error_already_set &) {
184611986Sandreas.sandberg@arm.com            /* If print() is called from code that is executed as
184711986Sandreas.sandberg@arm.com               part of garbage collection during interpreter shutdown,
184811986Sandreas.sandberg@arm.com               importing 'sys' can fail. Give up rather than crashing the
184911986Sandreas.sandberg@arm.com               interpreter in this case. */
185011986Sandreas.sandberg@arm.com            return;
185111986Sandreas.sandberg@arm.com        }
185211986Sandreas.sandberg@arm.com    }
185311986Sandreas.sandberg@arm.com
185411986Sandreas.sandberg@arm.com    auto write = file.attr("write");
185511986Sandreas.sandberg@arm.com    write(line);
185611986Sandreas.sandberg@arm.com    write(kwargs.contains("end") ? kwargs["end"] : cast("\n"));
185711986Sandreas.sandberg@arm.com
185811986Sandreas.sandberg@arm.com    if (kwargs.contains("flush") && kwargs["flush"].cast<bool>())
185911986Sandreas.sandberg@arm.com        file.attr("flush")();
186011986Sandreas.sandberg@arm.com}
186111986Sandreas.sandberg@arm.comNAMESPACE_END(detail)
186211986Sandreas.sandberg@arm.com
186311986Sandreas.sandberg@arm.comtemplate <return_value_policy policy = return_value_policy::automatic_reference, typename... Args>
186411986Sandreas.sandberg@arm.comvoid print(Args &&...args) {
186511986Sandreas.sandberg@arm.com    auto c = detail::collect_arguments<policy>(std::forward<Args>(args)...);
186611986Sandreas.sandberg@arm.com    detail::print(c.args(), c.kwargs());
186711986Sandreas.sandberg@arm.com}
186811986Sandreas.sandberg@arm.com
186912037Sandreas.sandberg@arm.com#if defined(WITH_THREAD) && !defined(PYPY_VERSION)
187011986Sandreas.sandberg@arm.com
187111986Sandreas.sandberg@arm.com/* The functions below essentially reproduce the PyGILState_* API using a RAII
187211986Sandreas.sandberg@arm.com * pattern, but there are a few important differences:
187311986Sandreas.sandberg@arm.com *
187411986Sandreas.sandberg@arm.com * 1. When acquiring the GIL from an non-main thread during the finalization
187511986Sandreas.sandberg@arm.com *    phase, the GILState API blindly terminates the calling thread, which
187611986Sandreas.sandberg@arm.com *    is often not what is wanted. This API does not do this.
187711986Sandreas.sandberg@arm.com *
187811986Sandreas.sandberg@arm.com * 2. The gil_scoped_release function can optionally cut the relationship
187911986Sandreas.sandberg@arm.com *    of a PyThreadState and its associated thread, which allows moving it to
188011986Sandreas.sandberg@arm.com *    another thread (this is a fairly rare/advanced use case).
188111986Sandreas.sandberg@arm.com *
188211986Sandreas.sandberg@arm.com * 3. The reference count of an acquired thread state can be controlled. This
188311986Sandreas.sandberg@arm.com *    can be handy to prevent cases where callbacks issued from an external
188411986Sandreas.sandberg@arm.com *    thread would otherwise constantly construct and destroy thread state data
188511986Sandreas.sandberg@arm.com *    structures.
188611986Sandreas.sandberg@arm.com *
188711986Sandreas.sandberg@arm.com * See the Python bindings of NanoGUI (http://github.com/wjakob/nanogui) for an
188811986Sandreas.sandberg@arm.com * example which uses features 2 and 3 to migrate the Python thread of
188911986Sandreas.sandberg@arm.com * execution to another thread (to run the event loop on the original thread,
189011986Sandreas.sandberg@arm.com * in this case).
189111986Sandreas.sandberg@arm.com */
189211986Sandreas.sandberg@arm.com
189311986Sandreas.sandberg@arm.comclass gil_scoped_acquire {
189411986Sandreas.sandberg@arm.compublic:
189511986Sandreas.sandberg@arm.com    PYBIND11_NOINLINE gil_scoped_acquire() {
189611986Sandreas.sandberg@arm.com        auto const &internals = detail::get_internals();
189714299Sbbruce@ucdavis.edu        tstate = (PyThreadState *) PYBIND11_TLS_GET_VALUE(internals.tstate);
189814299Sbbruce@ucdavis.edu
189914299Sbbruce@ucdavis.edu        if (!tstate) {
190014299Sbbruce@ucdavis.edu            /* Check if the GIL was acquired using the PyGILState_* API instead (e.g. if
190114299Sbbruce@ucdavis.edu               calling from a Python thread). Since we use a different key, this ensures
190214299Sbbruce@ucdavis.edu               we don't create a new thread state and deadlock in PyEval_AcquireThread
190314299Sbbruce@ucdavis.edu               below. Note we don't save this state with internals.tstate, since we don't
190414299Sbbruce@ucdavis.edu               create it we would fail to clear it (its reference count should be > 0). */
190514299Sbbruce@ucdavis.edu            tstate = PyGILState_GetThisThreadState();
190614299Sbbruce@ucdavis.edu        }
190711986Sandreas.sandberg@arm.com
190811986Sandreas.sandberg@arm.com        if (!tstate) {
190911986Sandreas.sandberg@arm.com            tstate = PyThreadState_New(internals.istate);
191011986Sandreas.sandberg@arm.com            #if !defined(NDEBUG)
191111986Sandreas.sandberg@arm.com                if (!tstate)
191211986Sandreas.sandberg@arm.com                    pybind11_fail("scoped_acquire: could not create thread state!");
191311986Sandreas.sandberg@arm.com            #endif
191411986Sandreas.sandberg@arm.com            tstate->gilstate_counter = 0;
191514299Sbbruce@ucdavis.edu            PYBIND11_TLS_REPLACE_VALUE(internals.tstate, tstate);
191611986Sandreas.sandberg@arm.com        } else {
191711986Sandreas.sandberg@arm.com            release = detail::get_thread_state_unchecked() != tstate;
191811986Sandreas.sandberg@arm.com        }
191911986Sandreas.sandberg@arm.com
192011986Sandreas.sandberg@arm.com        if (release) {
192111986Sandreas.sandberg@arm.com            /* Work around an annoying assertion in PyThreadState_Swap */
192211986Sandreas.sandberg@arm.com            #if defined(Py_DEBUG)
192311986Sandreas.sandberg@arm.com                PyInterpreterState *interp = tstate->interp;
192411986Sandreas.sandberg@arm.com                tstate->interp = nullptr;
192511986Sandreas.sandberg@arm.com            #endif
192611986Sandreas.sandberg@arm.com            PyEval_AcquireThread(tstate);
192711986Sandreas.sandberg@arm.com            #if defined(Py_DEBUG)
192811986Sandreas.sandberg@arm.com                tstate->interp = interp;
192911986Sandreas.sandberg@arm.com            #endif
193011986Sandreas.sandberg@arm.com        }
193111986Sandreas.sandberg@arm.com
193211986Sandreas.sandberg@arm.com        inc_ref();
193311986Sandreas.sandberg@arm.com    }
193411986Sandreas.sandberg@arm.com
193511986Sandreas.sandberg@arm.com    void inc_ref() {
193611986Sandreas.sandberg@arm.com        ++tstate->gilstate_counter;
193711986Sandreas.sandberg@arm.com    }
193811986Sandreas.sandberg@arm.com
193911986Sandreas.sandberg@arm.com    PYBIND11_NOINLINE void dec_ref() {
194011986Sandreas.sandberg@arm.com        --tstate->gilstate_counter;
194111986Sandreas.sandberg@arm.com        #if !defined(NDEBUG)
194211986Sandreas.sandberg@arm.com            if (detail::get_thread_state_unchecked() != tstate)
194311986Sandreas.sandberg@arm.com                pybind11_fail("scoped_acquire::dec_ref(): thread state must be current!");
194411986Sandreas.sandberg@arm.com            if (tstate->gilstate_counter < 0)
194511986Sandreas.sandberg@arm.com                pybind11_fail("scoped_acquire::dec_ref(): reference count underflow!");
194611986Sandreas.sandberg@arm.com        #endif
194711986Sandreas.sandberg@arm.com        if (tstate->gilstate_counter == 0) {
194811986Sandreas.sandberg@arm.com            #if !defined(NDEBUG)
194911986Sandreas.sandberg@arm.com                if (!release)
195011986Sandreas.sandberg@arm.com                    pybind11_fail("scoped_acquire::dec_ref(): internal error!");
195111986Sandreas.sandberg@arm.com            #endif
195211986Sandreas.sandberg@arm.com            PyThreadState_Clear(tstate);
195311986Sandreas.sandberg@arm.com            PyThreadState_DeleteCurrent();
195414299Sbbruce@ucdavis.edu            PYBIND11_TLS_DELETE_VALUE(detail::get_internals().tstate);
195511986Sandreas.sandberg@arm.com            release = false;
195611986Sandreas.sandberg@arm.com        }
195711986Sandreas.sandberg@arm.com    }
195811986Sandreas.sandberg@arm.com
195911986Sandreas.sandberg@arm.com    PYBIND11_NOINLINE ~gil_scoped_acquire() {
196011986Sandreas.sandberg@arm.com        dec_ref();
196111986Sandreas.sandberg@arm.com        if (release)
196211986Sandreas.sandberg@arm.com           PyEval_SaveThread();
196311986Sandreas.sandberg@arm.com    }
196411986Sandreas.sandberg@arm.comprivate:
196511986Sandreas.sandberg@arm.com    PyThreadState *tstate = nullptr;
196611986Sandreas.sandberg@arm.com    bool release = true;
196711986Sandreas.sandberg@arm.com};
196811986Sandreas.sandberg@arm.com
196911986Sandreas.sandberg@arm.comclass gil_scoped_release {
197011986Sandreas.sandberg@arm.compublic:
197111986Sandreas.sandberg@arm.com    explicit gil_scoped_release(bool disassoc = false) : disassoc(disassoc) {
197212391Sjason@lowepower.com        // `get_internals()` must be called here unconditionally in order to initialize
197312391Sjason@lowepower.com        // `internals.tstate` for subsequent `gil_scoped_acquire` calls. Otherwise, an
197412391Sjason@lowepower.com        // initialization race could occur as multiple threads try `gil_scoped_acquire`.
197512391Sjason@lowepower.com        const auto &internals = detail::get_internals();
197611986Sandreas.sandberg@arm.com        tstate = PyEval_SaveThread();
197711986Sandreas.sandberg@arm.com        if (disassoc) {
197812391Sjason@lowepower.com            auto key = internals.tstate;
197914299Sbbruce@ucdavis.edu            PYBIND11_TLS_DELETE_VALUE(key);
198011986Sandreas.sandberg@arm.com        }
198111986Sandreas.sandberg@arm.com    }
198211986Sandreas.sandberg@arm.com    ~gil_scoped_release() {
198311986Sandreas.sandberg@arm.com        if (!tstate)
198411986Sandreas.sandberg@arm.com            return;
198511986Sandreas.sandberg@arm.com        PyEval_RestoreThread(tstate);
198611986Sandreas.sandberg@arm.com        if (disassoc) {
198711986Sandreas.sandberg@arm.com            auto key = detail::get_internals().tstate;
198814299Sbbruce@ucdavis.edu            PYBIND11_TLS_REPLACE_VALUE(key, tstate);
198911986Sandreas.sandberg@arm.com        }
199011986Sandreas.sandberg@arm.com    }
199111986Sandreas.sandberg@arm.comprivate:
199211986Sandreas.sandberg@arm.com    PyThreadState *tstate;
199311986Sandreas.sandberg@arm.com    bool disassoc;
199411986Sandreas.sandberg@arm.com};
199512037Sandreas.sandberg@arm.com#elif defined(PYPY_VERSION)
199612037Sandreas.sandberg@arm.comclass gil_scoped_acquire {
199712037Sandreas.sandberg@arm.com    PyGILState_STATE state;
199812037Sandreas.sandberg@arm.compublic:
199912037Sandreas.sandberg@arm.com    gil_scoped_acquire() { state = PyGILState_Ensure(); }
200012037Sandreas.sandberg@arm.com    ~gil_scoped_acquire() { PyGILState_Release(state); }
200112037Sandreas.sandberg@arm.com};
200212037Sandreas.sandberg@arm.com
200312037Sandreas.sandberg@arm.comclass gil_scoped_release {
200412037Sandreas.sandberg@arm.com    PyThreadState *state;
200512037Sandreas.sandberg@arm.compublic:
200612037Sandreas.sandberg@arm.com    gil_scoped_release() { state = PyEval_SaveThread(); }
200712037Sandreas.sandberg@arm.com    ~gil_scoped_release() { PyEval_RestoreThread(state); }
200812037Sandreas.sandberg@arm.com};
200911986Sandreas.sandberg@arm.com#else
201011986Sandreas.sandberg@arm.comclass gil_scoped_acquire { };
201111986Sandreas.sandberg@arm.comclass gil_scoped_release { };
201211986Sandreas.sandberg@arm.com#endif
201311986Sandreas.sandberg@arm.com
201411986Sandreas.sandberg@arm.comerror_already_set::~error_already_set() {
201514299Sbbruce@ucdavis.edu    if (m_type) {
201611986Sandreas.sandberg@arm.com        gil_scoped_acquire gil;
201714299Sbbruce@ucdavis.edu        error_scope scope;
201814299Sbbruce@ucdavis.edu        m_type.release().dec_ref();
201914299Sbbruce@ucdavis.edu        m_value.release().dec_ref();
202014299Sbbruce@ucdavis.edu        m_trace.release().dec_ref();
202111986Sandreas.sandberg@arm.com    }
202211986Sandreas.sandberg@arm.com}
202311986Sandreas.sandberg@arm.com
202411986Sandreas.sandberg@arm.cominline function get_type_overload(const void *this_ptr, const detail::type_info *this_type, const char *name)  {
202512037Sandreas.sandberg@arm.com    handle self = detail::get_object_handle(this_ptr, this_type);
202612037Sandreas.sandberg@arm.com    if (!self)
202711986Sandreas.sandberg@arm.com        return function();
202812037Sandreas.sandberg@arm.com    handle type = self.get_type();
202911986Sandreas.sandberg@arm.com    auto key = std::make_pair(type.ptr(), name);
203011986Sandreas.sandberg@arm.com
203111986Sandreas.sandberg@arm.com    /* Cache functions that aren't overloaded in Python to avoid
203211986Sandreas.sandberg@arm.com       many costly Python dictionary lookups below */
203311986Sandreas.sandberg@arm.com    auto &cache = detail::get_internals().inactive_overload_cache;
203411986Sandreas.sandberg@arm.com    if (cache.find(key) != cache.end())
203511986Sandreas.sandberg@arm.com        return function();
203611986Sandreas.sandberg@arm.com
203712037Sandreas.sandberg@arm.com    function overload = getattr(self, name, function());
203811986Sandreas.sandberg@arm.com    if (overload.is_cpp_function()) {
203911986Sandreas.sandberg@arm.com        cache.insert(key);
204011986Sandreas.sandberg@arm.com        return function();
204111986Sandreas.sandberg@arm.com    }
204211986Sandreas.sandberg@arm.com
204312037Sandreas.sandberg@arm.com    /* Don't call dispatch code if invoked from overridden function.
204412037Sandreas.sandberg@arm.com       Unfortunately this doesn't work on PyPy. */
204512037Sandreas.sandberg@arm.com#if !defined(PYPY_VERSION)
204611986Sandreas.sandberg@arm.com    PyFrameObject *frame = PyThreadState_Get()->frame;
204711986Sandreas.sandberg@arm.com    if (frame && (std::string) str(frame->f_code->co_name) == name &&
204811986Sandreas.sandberg@arm.com        frame->f_code->co_argcount > 0) {
204911986Sandreas.sandberg@arm.com        PyFrame_FastToLocals(frame);
205011986Sandreas.sandberg@arm.com        PyObject *self_caller = PyDict_GetItem(
205111986Sandreas.sandberg@arm.com            frame->f_locals, PyTuple_GET_ITEM(frame->f_code->co_varnames, 0));
205212037Sandreas.sandberg@arm.com        if (self_caller == self.ptr())
205311986Sandreas.sandberg@arm.com            return function();
205411986Sandreas.sandberg@arm.com    }
205512037Sandreas.sandberg@arm.com#else
205612037Sandreas.sandberg@arm.com    /* PyPy currently doesn't provide a detailed cpyext emulation of
205712037Sandreas.sandberg@arm.com       frame objects, so we have to emulate this using Python. This
205812037Sandreas.sandberg@arm.com       is going to be slow..*/
205912037Sandreas.sandberg@arm.com    dict d; d["self"] = self; d["name"] = pybind11::str(name);
206012037Sandreas.sandberg@arm.com    PyObject *result = PyRun_String(
206112037Sandreas.sandberg@arm.com        "import inspect\n"
206212037Sandreas.sandberg@arm.com        "frame = inspect.currentframe()\n"
206312037Sandreas.sandberg@arm.com        "if frame is not None:\n"
206412037Sandreas.sandberg@arm.com        "    frame = frame.f_back\n"
206512037Sandreas.sandberg@arm.com        "    if frame is not None and str(frame.f_code.co_name) == name and "
206612037Sandreas.sandberg@arm.com        "frame.f_code.co_argcount > 0:\n"
206712037Sandreas.sandberg@arm.com        "        self_caller = frame.f_locals[frame.f_code.co_varnames[0]]\n"
206812037Sandreas.sandberg@arm.com        "        if self_caller == self:\n"
206912037Sandreas.sandberg@arm.com        "            self = None\n",
207012037Sandreas.sandberg@arm.com        Py_file_input, d.ptr(), d.ptr());
207112037Sandreas.sandberg@arm.com    if (result == nullptr)
207212037Sandreas.sandberg@arm.com        throw error_already_set();
207312391Sjason@lowepower.com    if (d["self"].is_none())
207412037Sandreas.sandberg@arm.com        return function();
207512037Sandreas.sandberg@arm.com    Py_DECREF(result);
207612037Sandreas.sandberg@arm.com#endif
207712037Sandreas.sandberg@arm.com
207811986Sandreas.sandberg@arm.com    return overload;
207911986Sandreas.sandberg@arm.com}
208011986Sandreas.sandberg@arm.com
208114299Sbbruce@ucdavis.edu/** \rst
208214299Sbbruce@ucdavis.edu  Try to retrieve a python method by the provided name from the instance pointed to by the this_ptr.
208314299Sbbruce@ucdavis.edu
208414299Sbbruce@ucdavis.edu  :this_ptr: The pointer to the object the overload should be retrieved for. This should be the first
208514299Sbbruce@ucdavis.edu                   non-trampoline class encountered in the inheritance chain.
208614299Sbbruce@ucdavis.edu  :name: The name of the overloaded Python method to retrieve.
208714299Sbbruce@ucdavis.edu  :return: The Python method by this name from the object or an empty function wrapper.
208814299Sbbruce@ucdavis.edu \endrst */
208911986Sandreas.sandberg@arm.comtemplate <class T> function get_overload(const T *this_ptr, const char *name) {
209011986Sandreas.sandberg@arm.com    auto tinfo = detail::get_type_info(typeid(T));
209111986Sandreas.sandberg@arm.com    return tinfo ? get_type_overload(this_ptr, tinfo, name) : function();
209211986Sandreas.sandberg@arm.com}
209311986Sandreas.sandberg@arm.com
209411986Sandreas.sandberg@arm.com#define PYBIND11_OVERLOAD_INT(ret_type, cname, name, ...) { \
209511986Sandreas.sandberg@arm.com        pybind11::gil_scoped_acquire gil; \
209611986Sandreas.sandberg@arm.com        pybind11::function overload = pybind11::get_overload(static_cast<const cname *>(this), name); \
209711986Sandreas.sandberg@arm.com        if (overload) { \
209811986Sandreas.sandberg@arm.com            auto o = overload(__VA_ARGS__); \
209911986Sandreas.sandberg@arm.com            if (pybind11::detail::cast_is_temporary_value_reference<ret_type>::value) { \
210011986Sandreas.sandberg@arm.com                static pybind11::detail::overload_caster_t<ret_type> caster; \
210111986Sandreas.sandberg@arm.com                return pybind11::detail::cast_ref<ret_type>(std::move(o), caster); \
210211986Sandreas.sandberg@arm.com            } \
210311986Sandreas.sandberg@arm.com            else return pybind11::detail::cast_safe<ret_type>(std::move(o)); \
210411986Sandreas.sandberg@arm.com        } \
210511986Sandreas.sandberg@arm.com    }
210611986Sandreas.sandberg@arm.com
210714299Sbbruce@ucdavis.edu/** \rst
210814299Sbbruce@ucdavis.edu    Macro to populate the virtual method in the trampoline class. This macro tries to look up a method named 'fn'
210914299Sbbruce@ucdavis.edu    from the Python side, deals with the :ref:`gil` and necessary argument conversions to call this method and return
211014299Sbbruce@ucdavis.edu    the appropriate type. See :ref:`overriding_virtuals` for more information. This macro should be used when the method
211114299Sbbruce@ucdavis.edu    name in C is not the same as the method name in Python. For example with `__str__`.
211214299Sbbruce@ucdavis.edu
211314299Sbbruce@ucdavis.edu    .. code-block:: cpp
211414299Sbbruce@ucdavis.edu
211514299Sbbruce@ucdavis.edu      std::string toString() override {
211614299Sbbruce@ucdavis.edu        PYBIND11_OVERLOAD_NAME(
211714299Sbbruce@ucdavis.edu            std::string, // Return type (ret_type)
211814299Sbbruce@ucdavis.edu            Animal,      // Parent class (cname)
211914299Sbbruce@ucdavis.edu            toString,    // Name of function in C++ (name)
212014299Sbbruce@ucdavis.edu            "__str__",   // Name of method in Python (fn)
212114299Sbbruce@ucdavis.edu        );
212214299Sbbruce@ucdavis.edu      }
212314299Sbbruce@ucdavis.edu\endrst */
212411986Sandreas.sandberg@arm.com#define PYBIND11_OVERLOAD_NAME(ret_type, cname, name, fn, ...) \
212514299Sbbruce@ucdavis.edu    PYBIND11_OVERLOAD_INT(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), name, __VA_ARGS__) \
212611986Sandreas.sandberg@arm.com    return cname::fn(__VA_ARGS__)
212711986Sandreas.sandberg@arm.com
212814299Sbbruce@ucdavis.edu/** \rst
212914299Sbbruce@ucdavis.edu    Macro for pure virtual functions, this function is identical to :c:macro:`PYBIND11_OVERLOAD_NAME`, except that it
213014299Sbbruce@ucdavis.edu    throws if no overload can be found.
213114299Sbbruce@ucdavis.edu\endrst */
213211986Sandreas.sandberg@arm.com#define PYBIND11_OVERLOAD_PURE_NAME(ret_type, cname, name, fn, ...) \
213314299Sbbruce@ucdavis.edu    PYBIND11_OVERLOAD_INT(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), name, __VA_ARGS__) \
213414299Sbbruce@ucdavis.edu    pybind11::pybind11_fail("Tried to call pure virtual function \"" PYBIND11_STRINGIFY(cname) "::" name "\"");
213511986Sandreas.sandberg@arm.com
213614299Sbbruce@ucdavis.edu/** \rst
213714299Sbbruce@ucdavis.edu    Macro to populate the virtual method in the trampoline class. This macro tries to look up the method
213814299Sbbruce@ucdavis.edu    from the Python side, deals with the :ref:`gil` and necessary argument conversions to call this method and return
213914299Sbbruce@ucdavis.edu    the appropriate type. This macro should be used if the method name in C and in Python are identical.
214014299Sbbruce@ucdavis.edu    See :ref:`overriding_virtuals` for more information.
214114299Sbbruce@ucdavis.edu
214214299Sbbruce@ucdavis.edu    .. code-block:: cpp
214314299Sbbruce@ucdavis.edu
214414299Sbbruce@ucdavis.edu      class PyAnimal : public Animal {
214514299Sbbruce@ucdavis.edu      public:
214614299Sbbruce@ucdavis.edu          // Inherit the constructors
214714299Sbbruce@ucdavis.edu          using Animal::Animal;
214814299Sbbruce@ucdavis.edu
214914299Sbbruce@ucdavis.edu          // Trampoline (need one for each virtual function)
215014299Sbbruce@ucdavis.edu          std::string go(int n_times) override {
215114299Sbbruce@ucdavis.edu              PYBIND11_OVERLOAD_PURE(
215214299Sbbruce@ucdavis.edu                  std::string, // Return type (ret_type)
215314299Sbbruce@ucdavis.edu                  Animal,      // Parent class (cname)
215414299Sbbruce@ucdavis.edu                  go,          // Name of function in C++ (must match Python name) (fn)
215514299Sbbruce@ucdavis.edu                  n_times      // Argument(s) (...)
215614299Sbbruce@ucdavis.edu              );
215714299Sbbruce@ucdavis.edu          }
215814299Sbbruce@ucdavis.edu      };
215914299Sbbruce@ucdavis.edu\endrst */
216011986Sandreas.sandberg@arm.com#define PYBIND11_OVERLOAD(ret_type, cname, fn, ...) \
216114299Sbbruce@ucdavis.edu    PYBIND11_OVERLOAD_NAME(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), #fn, fn, __VA_ARGS__)
216211986Sandreas.sandberg@arm.com
216314299Sbbruce@ucdavis.edu/** \rst
216414299Sbbruce@ucdavis.edu    Macro for pure virtual functions, this function is identical to :c:macro:`PYBIND11_OVERLOAD`, except that it throws
216514299Sbbruce@ucdavis.edu    if no overload can be found.
216614299Sbbruce@ucdavis.edu\endrst */
216711986Sandreas.sandberg@arm.com#define PYBIND11_OVERLOAD_PURE(ret_type, cname, fn, ...) \
216814299Sbbruce@ucdavis.edu    PYBIND11_OVERLOAD_PURE_NAME(PYBIND11_TYPE(ret_type), PYBIND11_TYPE(cname), #fn, fn, __VA_ARGS__)
216911986Sandreas.sandberg@arm.com
217012391Sjason@lowepower.comNAMESPACE_END(PYBIND11_NAMESPACE)
217111986Sandreas.sandberg@arm.com
217214299Sbbruce@ucdavis.edu#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
217311986Sandreas.sandberg@arm.com#  pragma warning(pop)
217411986Sandreas.sandberg@arm.com#elif defined(__GNUG__) && !defined(__clang__)
217511986Sandreas.sandberg@arm.com#  pragma GCC diagnostic pop
217611986Sandreas.sandberg@arm.com#endif
2177