pybind11.h 85.9 KB
Newer Older
Wenzel Jakob's avatar
Wenzel Jakob committed
1
/*
Wenzel Jakob's avatar
Wenzel Jakob committed
2
3
    pybind11/pybind11.h: Main header file of the C++11 python
    binding generator library
Wenzel Jakob's avatar
Wenzel Jakob committed
4

5
    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
Wenzel Jakob's avatar
Wenzel Jakob committed
6
7
8
9
10

    All rights reserved. Use of this source code is governed by a
    BSD-style license that can be found in the LICENSE file.
*/

11
#pragma once
Wenzel Jakob's avatar
Wenzel Jakob committed
12
13

#if defined(_MSC_VER)
Wenzel Jakob's avatar
Wenzel Jakob committed
14
#  pragma warning(push)
15
#  pragma warning(disable: 4100) // warning C4100: Unreferenced formal parameter
Wenzel Jakob's avatar
Wenzel Jakob committed
16
#  pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
17
#  pragma warning(disable: 4512) // warning C4512: Assignment operator was implicitly defined as deleted
Wenzel Jakob's avatar
Wenzel Jakob committed
18
19
#  pragma warning(disable: 4800) // warning C4800: 'int': forcing value to bool 'true' or 'false' (performance warning)
#  pragma warning(disable: 4996) // warning C4996: The POSIX name for this item is deprecated. Instead, use the ISO C and C++ conformant name
Wenzel Jakob's avatar
Wenzel Jakob committed
20
#  pragma warning(disable: 4702) // warning C4702: unreachable code
21
#  pragma warning(disable: 4522) // warning C4522: multiple assignment operators specified
22
#elif defined(__INTEL_COMPILER)
Ben Pritchard's avatar
Ben Pritchard committed
23
#  pragma warning(push)
24
#  pragma warning(disable: 68)    // integer conversion resulted in a change of sign
25
#  pragma warning(disable: 186)   // pointless comparison of unsigned integer with zero
26
#  pragma warning(disable: 878)   // incompatible exception specifications
27
#  pragma warning(disable: 1334)  // the "template" keyword used for syntactic disambiguation may only be used within a template
28
29
#  pragma warning(disable: 1682)  // implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
#  pragma warning(disable: 1875)  // offsetof applied to non-POD (Plain Old Data) types is nonstandard
30
#  pragma warning(disable: 2196)  // warning #2196: routine is both "inline" and "noinline"
31
#elif defined(__GNUG__) && !defined(__clang__)
Wenzel Jakob's avatar
Wenzel Jakob committed
32
33
34
35
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wunused-but-set-parameter"
#  pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#  pragma GCC diagnostic ignored "-Wmissing-field-initializers"
Wenzel Jakob's avatar
Wenzel Jakob committed
36
37
#  pragma GCC diagnostic ignored "-Wstrict-aliasing"
#  pragma GCC diagnostic ignored "-Wattributes"
38
39
40
#  if __GNUC__ >= 7
#    pragma GCC diagnostic ignored "-Wnoexcept-type"
#  endif
Wenzel Jakob's avatar
Wenzel Jakob committed
41
42
#endif

Wenzel Jakob's avatar
Wenzel Jakob committed
43
#include "attr.h"
44
#include "options.h"
45
#include "detail/class.h"
46
#include "detail/init.h"
Wenzel Jakob's avatar
Wenzel Jakob committed
47

48
NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
Wenzel Jakob's avatar
Wenzel Jakob committed
49

Wenzel Jakob's avatar
Wenzel Jakob committed
50
/// Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object
51
class cpp_function : public function {
Wenzel Jakob's avatar
Wenzel Jakob committed
52
public:
53
    cpp_function() { }
Wenzel Jakob's avatar
Wenzel Jakob committed
54

55
    /// Construct a cpp_function from a vanilla function pointer
56
57
    template <typename Return, typename... Args, typename... Extra>
    cpp_function(Return (*f)(Args...), const Extra&... extra) {
58
        initialize(f, f, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
59
60
    }

61
    /// Construct a cpp_function from a lambda function (possibly with internal state)
62
63
    template <typename Func, typename... Extra,
              typename = detail::enable_if_t<detail::is_lambda<Func>::value>>
64
    cpp_function(Func &&f, const Extra&... extra) {
65
        initialize(std::forward<Func>(f),
66
                   (detail::function_signature_t<Func> *) nullptr, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
67
68
    }

69
    /// Construct a cpp_function from a class method (non-const)
70
71
    template <typename Return, typename Class, typename... Arg, typename... Extra>
    cpp_function(Return (Class::*f)(Arg...), const Extra&... extra) {
72
        initialize([f](Class *c, Arg... args) -> Return { return (c->*f)(args...); },
73
                   (Return (*) (Class *, Arg...)) nullptr, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
74
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
75

76
    /// Construct a cpp_function from a class method (const)
77
78
    template <typename Return, typename Class, typename... Arg, typename... Extra>
    cpp_function(Return (Class::*f)(Arg...) const, const Extra&... extra) {
79
        initialize([f](const Class *c, Arg... args) -> Return { return (c->*f)(args...); },
80
                   (Return (*)(const Class *, Arg ...)) nullptr, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
81
82
    }

83
    /// Return the function name
Wenzel Jakob's avatar
Wenzel Jakob committed
84
    object name() const { return attr("__name__"); }
85

86
protected:
87
88
89
90
91
    /// Space optimization: don't inline this frequently instantiated fragment
    PYBIND11_NOINLINE detail::function_record *make_function_record() {
        return new detail::function_record();
    }

92
    /// Special internal constructor for functors, lambda functions, etc.
93
94
    template <typename Func, typename Return, typename... Args, typename... Extra>
    void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
95

96
        struct capture { detail::remove_reference_t<Func> f; };
Wenzel Jakob's avatar
Wenzel Jakob committed
97

98
        /* Store the function including any extra state it might have (e.g. a lambda capture object) */
99
        auto rec = make_function_record();
100

101
102
        /* Store the capture object directly in the function record if there is enough space */
        if (sizeof(capture) <= sizeof(rec->data)) {
103
104
105
            /* Without these pragmas, GCC warns that there might not be
               enough space to use the placement new operator. However, the
               'if' statement above ensures that this is the case. */
106
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
107
108
109
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wplacement-new"
#endif
110
            new ((capture *) &rec->data) capture { std::forward<Func>(f) };
111
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
112
113
#  pragma GCC diagnostic pop
#endif
114
115
116
117
118
119
            if (!std::is_trivially_destructible<Func>::value)
                rec->free_data = [](detail::function_record *r) { ((capture *) &r->data)->~capture(); };
        } else {
            rec->data[0] = new capture { std::forward<Func>(f) };
            rec->free_data = [](detail::function_record *r) { delete ((capture *) r->data[0]); };
        }
120

121
        /* Type casters for the function arguments and return value */
122
123
124
125
        using cast_in = detail::argument_loader<Args...>;
        using cast_out = detail::make_caster<
            detail::conditional_t<std::is_void<Return>::value, detail::void_type, Return>
        >;
Wenzel Jakob's avatar
Wenzel Jakob committed
126

127
        static_assert(detail::expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
128
                      "The number of argument annotations does not match the number of function arguments");
129

130
        /* Dispatch code which converts function arguments and performs the actual function call */
131
        rec->impl = [](detail::function_call &call) -> handle {
132
            cast_in args_converter;
133
134

            /* Try to cast the function arguments into the C++ domain */
135
            if (!args_converter.load_args(call))
136
137
                return PYBIND11_TRY_NEXT_OVERLOAD;

Wenzel Jakob's avatar
Wenzel Jakob committed
138
            /* Invoke call policy pre-call hook */
139
            detail::process_attributes<Extra...>::precall(call);
140
141

            /* Get a pointer to the capture object */
142
143
144
            auto data = (sizeof(capture) <= sizeof(call.func.data)
                         ? &call.func.data : call.func.data[0]);
            capture *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
145

146
147
            /* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
            const auto policy = detail::return_value_policy_override<Return>::policy(call.func.policy);
148

Dean Moldovan's avatar
Dean Moldovan committed
149
150
151
            /* Function scope guard -- defaults to the compile-to-nothing `void_type` */
            using Guard = detail::extract_guard_t<Extra...>;

152
            /* Perform the function call */
153
154
            handle result = cast_out::cast(
                std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
155
156

            /* Invoke call policy post-call hook */
157
            detail::process_attributes<Extra...>::postcall(call, result);
158

159
            return result;
Wenzel Jakob's avatar
Wenzel Jakob committed
160
161
        };

Wenzel Jakob's avatar
Wenzel Jakob committed
162
163
        /* Process any user-provided function attributes */
        detail::process_attributes<Extra...>::init(extra..., rec);
164
165

        /* Generate a readable signature describing the function's arguments and return value types */
166
        using detail::descr; using detail::_;
167
        PYBIND11_DESCR signature = _("(") + cast_in::arg_names() + _(") -> ") + cast_out::name();
168
169

        /* Register the function with Python from generic (non-templated) code */
170
        initialize_generic(rec, signature.text(), signature.types(), sizeof...(Args));
171
172
173

        if (cast_in::has_args) rec->has_args = true;
        if (cast_in::has_kwargs) rec->has_kwargs = true;
174
175

        /* Stash some additional information used by an important optimization in 'functional.h' */
176
        using FunctionType = Return (*)(Args...);
177
178
179
180
181
        constexpr bool is_function_ptr =
            std::is_convertible<Func, FunctionType>::value &&
            sizeof(capture) == sizeof(void *);
        if (is_function_ptr) {
            rec->is_stateless = true;
182
            rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
183
        }
184
185
    }

186
    /// Register a function call with Python (generic non-templated code goes here)
187
    void initialize_generic(detail::function_record *rec, const char *text,
188
                            const std::type_info *const *types, size_t args) {
Wenzel Jakob's avatar
Wenzel Jakob committed
189

190
        /* Create copies of all referenced C-style strings */
Wenzel Jakob's avatar
Wenzel Jakob committed
191
192
193
        rec->name = strdup(rec->name ? rec->name : "");
        if (rec->doc) rec->doc = strdup(rec->doc);
        for (auto &a: rec->args) {
194
195
196
197
198
            if (a.name)
                a.name = strdup(a.name);
            if (a.descr)
                a.descr = strdup(a.descr);
            else if (a.value)
199
                a.descr = strdup(a.value.attr("__repr__")().cast<std::string>().c_str());
200
        }
201

202
203
        rec->is_constructor = !strcmp(rec->name, "__init__") || !strcmp(rec->name, "__setstate__");

204
205
206
207
208
209
210
211
212
213
214
215
216
217
#if !defined(NDEBUG) && !defined(PYBIND11_DISABLE_NEW_STYLE_INIT_WARNING)
        if (rec->is_constructor && !rec->is_new_style_constructor) {
            const auto class_name = std::string(((PyTypeObject *) rec->scope.ptr())->tp_name);
            const auto func_name = std::string(rec->name);
            PyErr_WarnEx(
                PyExc_FutureWarning,
                ("pybind11-bound class '" + class_name + "' is using an old-style "
                 "placement-new '" + func_name + "' which has been deprecated. See "
                 "the upgrade guide in pybind11's docs. This message is only visible "
                 "when compiled in debug mode.").c_str(), 0
            );
        }
#endif

218
219
220
221
222
223
224
225
226
        /* Generate a proper function signature */
        std::string signature;
        size_t type_depth = 0, char_index = 0, type_index = 0, arg_index = 0;
        while (true) {
            char c = text[char_index++];
            if (c == '\0')
                break;

            if (c == '{') {
227
                // Write arg name for everything except *args, **kwargs and return type.
228
                if (type_depth == 0 && text[char_index] != '*' && arg_index < args) {
229
                    if (!rec->args.empty() && rec->args[arg_index].name) {
230
                        signature += rec->args[arg_index].name;
231
                    } else if (arg_index == 0 && rec->is_method) {
232
233
                        signature += "self";
                    } else {
234
                        signature += "arg" + std::to_string(arg_index - (rec->is_method ? 1 : 0));
235
236
                    }
                    signature += ": ";
237
238
239
240
                }
                ++type_depth;
            } else if (c == '}') {
                --type_depth;
241
                if (type_depth == 0) {
242
243
                    if (arg_index < rec->args.size() && rec->args[arg_index].descr) {
                        signature += "=";
Wenzel Jakob's avatar
Wenzel Jakob committed
244
                        signature += rec->args[arg_index].descr;
245
246
247
248
249
                    }
                    arg_index++;
                }
            } else if (c == '%') {
                const std::type_info *t = types[type_index++];
250
                if (!t)
251
                    pybind11_fail("Internal error while parsing type signature (1)");
252
                if (auto tinfo = detail::get_type_info(*t)) {
Wenzel Jakob's avatar
Wenzel Jakob committed
253
254
255
256
257
#if defined(PYPY_VERSION)
                    signature += handle((PyObject *) tinfo->type)
                                     .attr("__module__")
                                     .cast<std::string>() + ".";
#endif
258
                    signature += tinfo->type->tp_name;
259
260
261
                } else if (rec->is_new_style_constructor && arg_index == 0) {
                    // A new-style `__init__` takes `self` as `value_and_holder`.
                    // Rewrite it to the proper class type.
262
263
264
265
#if defined(PYPY_VERSION)
                    signature += rec->scope.attr("__module__").cast<std::string>() + ".";
#endif
                    signature += ((PyTypeObject *) rec->scope.ptr())->tp_name;
266
267
268
269
270
271
272
273
274
                } else {
                    std::string tname(t->name());
                    detail::clean_type_id(tname);
                    signature += tname;
                }
            } else {
                signature += c;
            }
        }
275
        if (type_depth != 0 || types[type_index] != nullptr)
276
            pybind11_fail("Internal error while parsing type signature (2)");
277

278
        #if !defined(PYBIND11_CONSTEXPR_DESCR)
279
280
281
            delete[] types;
            delete[] text;
        #endif
282

283
#if PY_MAJOR_VERSION < 3
Wenzel Jakob's avatar
Wenzel Jakob committed
284
285
286
        if (strcmp(rec->name, "__next__") == 0) {
            std::free(rec->name);
            rec->name = strdup("next");
287
288
289
        } else if (strcmp(rec->name, "__bool__") == 0) {
            std::free(rec->name);
            rec->name = strdup("__nonzero__");
290
        }
291
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
292
293
        rec->signature = strdup(signature.c_str());
        rec->args.shrink_to_fit();
294
        rec->nargs = (std::uint16_t) args;
295

296
297
        if (rec->sibling && PYBIND11_INSTANCE_METHOD_CHECK(rec->sibling.ptr()))
            rec->sibling = PYBIND11_INSTANCE_METHOD_GET_FUNCTION(rec->sibling.ptr());
298

Wenzel Jakob's avatar
Wenzel Jakob committed
299
        detail::function_record *chain = nullptr, *chain_start = rec;
300
301
        if (rec->sibling) {
            if (PyCFunction_Check(rec->sibling.ptr())) {
Wenzel Jakob's avatar
Wenzel Jakob committed
302
                auto rec_capsule = reinterpret_borrow<capsule>(PyCFunction_GET_SELF(rec->sibling.ptr()));
303
304
305
                chain = (detail::function_record *) rec_capsule;
                /* Never append a method to an overload chain of a parent class;
                   instead, hide the parent's overloads in this case */
306
                if (!chain->scope.is(rec->scope))
307
308
309
310
311
312
                    chain = nullptr;
            }
            // Don't trigger for things like the default __init__, which are wrapper_descriptors that we are intentionally replacing
            else if (!rec->sibling.is_none() && rec->name[0] != '_')
                pybind11_fail("Cannot overload existing non-function object \"" + std::string(rec->name) +
                        "\" with a function of the same name");
313
314
        }

Wenzel Jakob's avatar
Wenzel Jakob committed
315
        if (!chain) {
316
            /* No existing overload was found, create a new function object */
Wenzel Jakob's avatar
Wenzel Jakob committed
317
            rec->def = new PyMethodDef();
318
            std::memset(rec->def, 0, sizeof(PyMethodDef));
Wenzel Jakob's avatar
Wenzel Jakob committed
319
320
321
            rec->def->ml_name = rec->name;
            rec->def->ml_meth = reinterpret_cast<PyCFunction>(*dispatcher);
            rec->def->ml_flags = METH_VARARGS | METH_KEYWORDS;
322

323
324
            capsule rec_capsule(rec, [](void *ptr) {
                destruct((detail::function_record *) ptr);
325
            });
326
327
328

            object scope_module;
            if (rec->scope) {
329
330
331
332
333
                if (hasattr(rec->scope, "__module__")) {
                    scope_module = rec->scope.attr("__module__");
                } else if (hasattr(rec->scope, "__name__")) {
                    scope_module = rec->scope.attr("__name__");
                }
334
335
336
            }

            m_ptr = PyCFunction_NewEx(rec->def, rec_capsule.ptr(), scope_module.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
337
            if (!m_ptr)
338
                pybind11_fail("cpp_function::cpp_function(): Could not allocate function object");
Wenzel Jakob's avatar
Wenzel Jakob committed
339
        } else {
340
            /* Append at the end of the overload chain */
Wenzel Jakob's avatar
Wenzel Jakob committed
341
            m_ptr = rec->sibling.ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
342
            inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
343
            chain_start = chain;
344
345
346
347
348
349
350
351
352
            if (chain->is_method != rec->is_method)
                pybind11_fail("overloading a method with both static and instance methods is not supported; "
                    #if defined(NDEBUG)
                        "compile in debug mode for more details"
                    #else
                        "error while attempting to bind " + std::string(rec->is_method ? "instance" : "static") + " method " +
                        std::string(pybind11::str(rec->scope.attr("__name__"))) + "." + std::string(rec->name) + signature
                    #endif
                );
Wenzel Jakob's avatar
Wenzel Jakob committed
353
354
355
            while (chain->next)
                chain = chain->next;
            chain->next = rec;
Wenzel Jakob's avatar
Wenzel Jakob committed
356
        }
357

Wenzel Jakob's avatar
Wenzel Jakob committed
358
        std::string signatures;
359
        int index = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
360
        /* Create a nice pydoc rec including all signatures and
361
           docstrings of the functions in the overload chain */
362
        if (chain && options::show_function_signatures()) {
363
364
365
366
367
368
            // First a generic signature
            signatures += rec->name;
            signatures += "(*args, **kwargs)\n";
            signatures += "Overloaded function.\n\n";
        }
        // Then specific overload signatures
369
        bool first_user_def = true;
Wenzel Jakob's avatar
Wenzel Jakob committed
370
        for (auto it = chain_start; it != nullptr; it = it->next) {
371
            if (options::show_function_signatures()) {
372
                if (index > 0) signatures += "\n";
373
374
375
376
                if (chain)
                    signatures += std::to_string(++index) + ". ";
                signatures += rec->name;
                signatures += it->signature;
377
                signatures += "\n";
378
379
            }
            if (it->doc && strlen(it->doc) > 0 && options::show_user_defined_docstrings()) {
380
381
382
383
384
385
                // If we're appending another docstring, and aren't printing function signatures, we
                // need to append a newline first:
                if (!options::show_function_signatures()) {
                    if (first_user_def) first_user_def = false;
                    else signatures += "\n";
                }
386
                if (options::show_function_signatures()) signatures += "\n";
387
                signatures += it->doc;
388
                if (options::show_function_signatures()) signatures += "\n";
389
            }
Wenzel Jakob's avatar
Wenzel Jakob committed
390
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
391
392

        /* Install docstring */
Wenzel Jakob's avatar
Wenzel Jakob committed
393
394
        PyCFunctionObject *func = (PyCFunctionObject *) m_ptr;
        if (func->m_ml->ml_doc)
395
            std::free(const_cast<char *>(func->m_ml->ml_doc));
Wenzel Jakob's avatar
Wenzel Jakob committed
396
        func->m_ml->ml_doc = strdup(signatures.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
397

398
399
        if (rec->is_method) {
            m_ptr = PYBIND11_INSTANCE_METHOD_NEW(m_ptr, rec->scope.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
400
            if (!m_ptr)
401
                pybind11_fail("cpp_function::cpp_function(): Could not allocate instance method object");
Wenzel Jakob's avatar
Wenzel Jakob committed
402
403
404
            Py_DECREF(func);
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
405
406
407
408
409
410

    /// When a cpp_function is GCed, release any memory allocated by pybind11
    static void destruct(detail::function_record *rec) {
        while (rec) {
            detail::function_record *next = rec->next;
            if (rec->free_data)
411
                rec->free_data(rec);
Wenzel Jakob's avatar
Wenzel Jakob committed
412
413
414
415
            std::free((char *) rec->name);
            std::free((char *) rec->doc);
            std::free((char *) rec->signature);
            for (auto &arg: rec->args) {
416
417
                std::free(const_cast<char *>(arg.name));
                std::free(const_cast<char *>(arg.descr));
Wenzel Jakob's avatar
Wenzel Jakob committed
418
419
420
                arg.value.dec_ref();
            }
            if (rec->def) {
421
                std::free(const_cast<char *>(rec->def->ml_doc));
Wenzel Jakob's avatar
Wenzel Jakob committed
422
423
424
425
426
427
428
429
                delete rec->def;
            }
            delete rec;
            rec = next;
        }
    }

    /// Main dispatch logic for calls to functions bound using pybind11
430
    static PyObject *dispatcher(PyObject *self, PyObject *args_in, PyObject *kwargs_in) {
431
432
        using namespace detail;

Wenzel Jakob's avatar
Wenzel Jakob committed
433
        /* Iterator over the list of potentially admissible overloads */
434
435
        function_record *overloads = (function_record *) PyCapsule_GetPointer(self, nullptr),
                        *it = overloads;
Wenzel Jakob's avatar
Wenzel Jakob committed
436
437

        /* Need to know how many arguments + keyword arguments there are to pick the right overload */
438
        const size_t n_args_in = (size_t) PyTuple_GET_SIZE(args_in);
Wenzel Jakob's avatar
Wenzel Jakob committed
439

440
        handle parent = n_args_in > 0 ? PyTuple_GET_ITEM(args_in, 0) : nullptr,
Wenzel Jakob's avatar
Wenzel Jakob committed
441
               result = PYBIND11_TRY_NEXT_OVERLOAD;
442

443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
        auto self_value_and_holder = value_and_holder();
        if (overloads->is_constructor) {
            const auto tinfo = get_type_info((PyTypeObject *) overloads->scope.ptr());
            const auto pi = reinterpret_cast<instance *>(parent.ptr());
            self_value_and_holder = pi->get_value_and_holder(tinfo, false);

            if (!self_value_and_holder.type || !self_value_and_holder.inst) {
                PyErr_SetString(PyExc_TypeError, "__init__(self, ...) called with invalid `self` argument");
                return nullptr;
            }

            // If this value is already registered it must mean __init__ is invoked multiple times;
            // we really can't support that in C++, so just ignore the second __init__.
            if (self_value_and_holder.instance_registered())
                return none().release().ptr();
        }

Wenzel Jakob's avatar
Wenzel Jakob committed
460
        try {
461
462
463
464
465
466
467
468
469
            // We do this in two passes: in the first pass, we load arguments with `convert=false`;
            // in the second, we allow conversion (except for arguments with an explicit
            // py::arg().noconvert()).  This lets us prefer calls without conversion, with
            // conversion as a fallback.
            std::vector<function_call> second_pass;

            // However, if there are no overloads, we can just skip the no-convert pass entirely
            const bool overloaded = it != nullptr && it->next != nullptr;

Wenzel Jakob's avatar
Wenzel Jakob committed
470
            for (; it != nullptr; it = it->next) {
471

Wenzel Jakob's avatar
Wenzel Jakob committed
472
                /* For each overload:
473
474
                   1. Copy all positional arguments we were given, also checking to make sure that
                      named positional arguments weren't *also* specified via kwarg.
475
                   2. If we weren't given enough, try to make up the omitted ones by checking
476
477
478
479
480
481
482
483
484
485
486
487
488
                      whether they were provided by a kwarg matching the `py::arg("name")` name.  If
                      so, use it (and remove it from kwargs; if not, see if the function binding
                      provided a default that we can use.
                   3. Ensure that either all keyword arguments were "consumed", or that the function
                      takes a kwargs argument to accept unconsumed kwargs.
                   4. Any positional arguments still left get put into a tuple (for args), and any
                      leftover kwargs get put into a dict.
                   5. Pack everything into a vector; if we have py::args or py::kwargs, they are an
                      extra tuple or dict at the end of the positional arguments.
                   6. Call the function call dispatcher (function_record::impl)

                   If one of these fail, move on to the next overload and keep trying until we get a
                   result other than PYBIND11_TRY_NEXT_OVERLOAD.
Wenzel Jakob's avatar
Wenzel Jakob committed
489
490
                 */

491
492
493
494
                function_record &func = *it;
                size_t pos_args = func.nargs;    // Number of positional arguments that we need
                if (func.has_args) --pos_args;   // (but don't count py::args
                if (func.has_kwargs) --pos_args; //  or py::kwargs)
Wenzel Jakob's avatar
Wenzel Jakob committed
495

496
                if (!func.has_args && n_args_in > pos_args)
497
498
                    continue; // Too many arguments for this overload

499
                if (n_args_in < pos_args && func.args.size() < pos_args)
500
501
                    continue; // Not enough arguments given, and not enough defaults to fill in the blanks

502
                function_call call(func, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
503

504
505
506
                size_t args_to_copy = std::min(pos_args, n_args_in);
                size_t args_copied = 0;

507
508
509
510
511
512
513
                // 0. Inject new-style `self` argument
                if (func.is_new_style_constructor) {
                    // The `value` may have been preallocated by an old-style `__init__`
                    // if it was a preceding candidate for overload resolution.
                    if (self_value_and_holder)
                        self_value_and_holder.type->dealloc(self_value_and_holder);

514
                    call.init_self = PyTuple_GET_ITEM(args_in, 0);
515
516
517
518
519
                    call.args.push_back(reinterpret_cast<PyObject *>(&self_value_and_holder));
                    call.args_convert.push_back(false);
                    ++args_copied;
                }

520
                // 1. Copy any position arguments given.
521
                bool bad_arg = false;
522
                for (; args_copied < args_to_copy; ++args_copied) {
523
524
525
                    argument_record *arg_rec = args_copied < func.args.size() ? &func.args[args_copied] : nullptr;
                    if (kwargs_in && arg_rec && arg_rec->name && PyDict_GetItemString(kwargs_in, arg_rec->name)) {
                        bad_arg = true;
526
                        break;
527
528
                    }

529
530
531
532
533
534
535
                    handle arg(PyTuple_GET_ITEM(args_in, args_copied));
                    if (arg_rec && !arg_rec->none && arg.is_none()) {
                        bad_arg = true;
                        break;
                    }
                    call.args.push_back(arg);
                    call.args_convert.push_back(arg_rec ? arg_rec->convert : true);
536
                }
537
                if (bad_arg)
538
                    continue; // Maybe it was meant for another overload (issue #688)
539
540
541
542
543
544
545
546
547

                // We'll need to copy this if we steal some kwargs for defaults
                dict kwargs = reinterpret_borrow<dict>(kwargs_in);

                // 2. Check kwargs and, failing that, defaults that may help complete the list
                if (args_copied < pos_args) {
                    bool copied_kwargs = false;

                    for (; args_copied < pos_args; ++args_copied) {
548
                        const auto &arg = func.args[args_copied];
549
550

                        handle value;
551
                        if (kwargs_in && arg.name)
552
                            value = PyDict_GetItemString(kwargs.ptr(), arg.name);
Wenzel Jakob's avatar
Wenzel Jakob committed
553
554

                        if (value) {
555
556
557
558
559
560
                            // Consume a kwargs value
                            if (!copied_kwargs) {
                                kwargs = reinterpret_steal<dict>(PyDict_Copy(kwargs.ptr()));
                                copied_kwargs = true;
                            }
                            PyDict_DelItemString(kwargs.ptr(), arg.name);
561
                        } else if (arg.value) {
562
563
564
                            value = arg.value;
                        }

565
                        if (value) {
566
                            call.args.push_back(value);
567
568
                            call.args_convert.push_back(arg.convert);
                        }
569
                        else
Wenzel Jakob's avatar
Wenzel Jakob committed
570
                            break;
571
572
573
574
575
576
577
                    }

                    if (args_copied < pos_args)
                        continue; // Not enough arguments, defaults, or kwargs to fill the positional arguments
                }

                // 3. Check everything was consumed (unless we have a kwargs arg)
578
                if (kwargs && kwargs.size() > 0 && !func.has_kwargs)
579
580
581
582
                    continue; // Unconsumed kwargs, but no py::kwargs argument to accept them

                // 4a. If we have a py::args argument, create a new tuple with leftovers
                tuple extra_args;
583
                if (func.has_args) {
584
585
586
587
                    if (args_to_copy == 0) {
                        // We didn't copy out any position arguments from the args_in tuple, so we
                        // can reuse it directly without copying:
                        extra_args = reinterpret_borrow<tuple>(args_in);
588
                    } else if (args_copied >= n_args_in) {
589
                        extra_args = tuple(0);
590
                    } else {
591
592
593
594
595
                        size_t args_size = n_args_in - args_copied;
                        extra_args = tuple(args_size);
                        for (size_t i = 0; i < args_size; ++i) {
                            handle item = PyTuple_GET_ITEM(args_in, args_copied + i);
                            extra_args[i] = item.inc_ref().ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
596
597
                        }
                    }
598
                    call.args.push_back(extra_args);
599
                    call.args_convert.push_back(false);
Wenzel Jakob's avatar
Wenzel Jakob committed
600
                }
601

602
                // 4b. If we have a py::kwargs, pass on any remaining kwargs
603
                if (func.has_kwargs) {
604
605
                    if (!kwargs.ptr())
                        kwargs = dict(); // If we didn't get one, send an empty one
606
                    call.args.push_back(kwargs);
607
                    call.args_convert.push_back(false);
608
609
                }

610
611
612
                // 5. Put everything in a vector.  Not technically step 5, we've been building it
                // in `call.args` all along.
                #if !defined(NDEBUG)
613
                if (call.args.size() != func.nargs || call.args_convert.size() != func.nargs)
614
615
                    pybind11_fail("Internal error: function call dispatcher inserted wrong number of arguments!");
                #endif
616

617
618
619
620
621
622
623
624
625
                std::vector<bool> second_pass_convert;
                if (overloaded) {
                    // We're in the first no-convert pass, so swap out the conversion flags for a
                    // set of all-false flags.  If the call fails, we'll swap the flags back in for
                    // the conversion-allowed call below.
                    second_pass_convert.resize(func.nargs, false);
                    call.args_convert.swap(second_pass_convert);
                }

626
                // 6. Call the function.
627
                try {
628
                    loader_life_support guard{};
629
                    result = func.impl(call);
630
                } catch (reference_cast_error &) {
631
632
                    result = PYBIND11_TRY_NEXT_OVERLOAD;
                }
Wenzel Jakob's avatar
Wenzel Jakob committed
633
634
635

                if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD)
                    break;
636

637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
                if (overloaded) {
                    // The (overloaded) call failed; if the call has at least one argument that
                    // permits conversion (i.e. it hasn't been explicitly specified `.noconvert()`)
                    // then add this call to the list of second pass overloads to try.
                    for (size_t i = func.is_method ? 1 : 0; i < pos_args; i++) {
                        if (second_pass_convert[i]) {
                            // Found one: swap the converting flags back in and store the call for
                            // the second pass.
                            call.args_convert.swap(second_pass_convert);
                            second_pass.push_back(std::move(call));
                            break;
                        }
                    }
                }
            }

            if (overloaded && !second_pass.empty() && result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) {
                // The no-conversion pass finished without success, try again with conversion allowed
                for (auto &call : second_pass) {
                    try {
657
                        loader_life_support guard{};
658
659
660
661
662
663
664
665
                        result = call.func.impl(call);
                    } catch (reference_cast_error &) {
                        result = PYBIND11_TRY_NEXT_OVERLOAD;
                    }

                    if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD)
                        break;
                }
Wenzel Jakob's avatar
Wenzel Jakob committed
666
            }
667
668
        } catch (error_already_set &e) {
            e.restore();
669
            return nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
670
        } catch (...) {
671
672
673
            /* When an exception is caught, give each registered exception
               translator a chance to translate it to a Python exception
               in reverse order of registration.
674

675
               A translator may choose to do one of the following:
676

677
678
679
680
681
                - catch the exception and call PyErr_SetString or PyErr_SetObject
                  to set a standard (or custom) Python exception, or
                - do nothing and let the exception fall through to the next translator, or
                - delegate translation to the next translator by throwing a new type of exception. */

682
            auto last_exception = std::current_exception();
683
            auto &registered_exception_translators = get_internals().registered_exception_translators;
684
685
686
687
688
689
690
691
692
693
            for (auto& translator : registered_exception_translators) {
                try {
                    translator(last_exception);
                } catch (...) {
                    last_exception = std::current_exception();
                    continue;
                }
                return nullptr;
            }
            PyErr_SetString(PyExc_SystemError, "Exception escaped from default exception translator!");
Wenzel Jakob's avatar
Wenzel Jakob committed
694
695
696
697
            return nullptr;
        }

        if (result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) {
698
699
700
            if (overloads->is_operator)
                return handle(Py_NotImplemented).inc_ref().ptr();

701
702
703
704
            std::string msg = std::string(overloads->name) + "(): incompatible " +
                std::string(overloads->is_constructor ? "constructor" : "function") +
                " arguments. The following argument types are supported:\n";

Wenzel Jakob's avatar
Wenzel Jakob committed
705
            int ctr = 0;
706
            for (function_record *it2 = overloads; it2 != nullptr; it2 = it2->next) {
Wenzel Jakob's avatar
Wenzel Jakob committed
707
                msg += "    "+ std::to_string(++ctr) + ". ";
708
709
710

                bool wrote_sig = false;
                if (overloads->is_constructor) {
711
                    // For a constructor, rewrite `(self: Object, arg0, ...) -> NoneType` as `Object(arg0, ...)`
712
                    std::string sig = it2->signature;
713
                    size_t start = sig.find('(') + 7; // skip "(self: "
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
                    if (start < sig.size()) {
                        // End at the , for the next argument
                        size_t end = sig.find(", "), next = end + 2;
                        size_t ret = sig.rfind(" -> ");
                        // Or the ), if there is no comma:
                        if (end >= sig.size()) next = end = sig.find(')');
                        if (start < end && next < sig.size()) {
                            msg.append(sig, start, end - start);
                            msg += '(';
                            msg.append(sig, next, ret - next);
                            wrote_sig = true;
                        }
                    }
                }
                if (!wrote_sig) msg += it2->signature;

Wenzel Jakob's avatar
Wenzel Jakob committed
730
731
                msg += "\n";
            }
732
            msg += "\nInvoked with: ";
733
            auto args_ = reinterpret_borrow<tuple>(args_in);
734
            bool some_args = false;
735
            for (size_t ti = overloads->is_constructor ? 1 : 0; ti < args_.size(); ++ti) {
736
737
                if (!some_args) some_args = true;
                else msg += ", ";
738
                msg += pybind11::repr(args_[ti]);
739
            }
740
741
742
743
744
745
746
747
748
749
750
751
752
753
            if (kwargs_in) {
                auto kwargs = reinterpret_borrow<dict>(kwargs_in);
                if (kwargs.size() > 0) {
                    if (some_args) msg += "; ";
                    msg += "kwargs: ";
                    bool first = true;
                    for (auto kwarg : kwargs) {
                        if (first) first = false;
                        else msg += ", ";
                        msg += pybind11::str("{}={!r}").format(kwarg.first, kwarg.second);
                    }
                }
            }

Wenzel Jakob's avatar
Wenzel Jakob committed
754
755
756
757
758
759
760
761
762
            PyErr_SetString(PyExc_TypeError, msg.c_str());
            return nullptr;
        } else if (!result) {
            std::string msg = "Unable to convert function return value to a "
                              "Python type! The signature was\n\t";
            msg += it->signature;
            PyErr_SetString(PyExc_TypeError, msg.c_str());
            return nullptr;
        } else {
763
            if (overloads->is_constructor && !self_value_and_holder.holder_constructed()) {
764
                auto *pi = reinterpret_cast<instance *>(parent.ptr());
765
                self_value_and_holder.type->init_instance(pi, nullptr);
Wenzel Jakob's avatar
Wenzel Jakob committed
766
767
768
769
            }
            return result.ptr();
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
770
771
};

772
/// Wrapper for Python extension modules
Wenzel Jakob's avatar
Wenzel Jakob committed
773
774
class module : public object {
public:
775
    PYBIND11_OBJECT_DEFAULT(module, object, PyModule_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
776

777
    /// Create a new top-level Python module with the given name and docstring
778
    explicit module(const char *name, const char *doc = nullptr) {
779
        if (!options::show_user_defined_docstrings()) doc = nullptr;
780
#if PY_MAJOR_VERSION >= 3
Wenzel Jakob's avatar
Wenzel Jakob committed
781
        PyModuleDef *def = new PyModuleDef();
782
        std::memset(def, 0, sizeof(PyModuleDef));
Wenzel Jakob's avatar
Wenzel Jakob committed
783
784
785
786
787
        def->m_name = name;
        def->m_doc = doc;
        def->m_size = -1;
        Py_INCREF(def);
        m_ptr = PyModule_Create(def);
788
789
790
#else
        m_ptr = Py_InitModule3(name, nullptr, doc);
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
791
        if (m_ptr == nullptr)
792
            pybind11_fail("Internal error in module::module()");
Wenzel Jakob's avatar
Wenzel Jakob committed
793
794
795
        inc_ref();
    }

796
797
798
799
800
    /** \rst
        Create Python binding for a new function within the module scope. ``Func``
        can be a plain C++ function, a function pointer, or a lambda function. For
        details on the ``Extra&& ... extra`` argument, see section :ref:`extras`.
    \endrst */
801
    template <typename Func, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
802
    module &def(const char *name_, Func &&f, const Extra& ... extra) {
803
804
        cpp_function func(std::forward<Func>(f), name(name_), scope(*this),
                          sibling(getattr(*this, name_, none())), extra...);
805
806
807
        // NB: allow overwriting here because cpp_function sets up a chain with the intention of
        // overwriting (and has already checked internally that it isn't overwriting non-functions).
        add_object(name_, func, true /* overwrite */);
Wenzel Jakob's avatar
Wenzel Jakob committed
808
809
810
        return *this;
    }

811
812
813
814
815
816
817
818
819
820
    /** \rst
        Create and return a new Python submodule with the given name and docstring.
        This also works recursively, i.e.

        .. code-block:: cpp

            py::module m("example", "pybind11 example plugin");
            py::module m2 = m.def_submodule("sub", "A submodule of 'example'");
            py::module m3 = m2.def_submodule("subsub", "A submodule of 'example.sub'");
    \endrst */
821
    module def_submodule(const char *name, const char *doc = nullptr) {
Wenzel Jakob's avatar
Wenzel Jakob committed
822
823
        std::string full_name = std::string(PyModule_GetName(m_ptr))
            + std::string(".") + std::string(name);
824
        auto result = reinterpret_borrow<module>(PyImport_AddModule(full_name.c_str()));
825
        if (doc && options::show_user_defined_docstrings())
826
            result.attr("__doc__") = pybind11::str(doc);
Wenzel Jakob's avatar
Wenzel Jakob committed
827
828
829
        attr(name) = result;
        return result;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
830

831
    /// Import and return a module or throws `error_already_set`.
Wenzel Jakob's avatar
Wenzel Jakob committed
832
    static module import(const char *name) {
833
834
        PyObject *obj = PyImport_ImportModule(name);
        if (!obj)
835
            throw error_already_set();
836
        return reinterpret_steal<module>(obj);
Wenzel Jakob's avatar
Wenzel Jakob committed
837
    }
838

839
840
841
842
843
844
845
846
    /// Reload the module or throws `error_already_set`.
    void reload() {
        PyObject *obj = PyImport_ReloadModule(ptr());
        if (!obj)
            throw error_already_set();
        *this = reinterpret_steal<module>(obj);
    }

847
848
849
850
851
    // Adds an object to the module using the given name.  Throws if an object with the given name
    // already exists.
    //
    // overwrite should almost always be false: attempting to overwrite objects that pybind11 has
    // established will, in most cases, break things.
852
    PYBIND11_NOINLINE void add_object(const char *name, handle obj, bool overwrite = false) {
853
854
855
856
        if (!overwrite && hasattr(*this, name))
            pybind11_fail("Error during initialization: multiple incompatible definitions with name \"" +
                    std::string(name) + "\"");

857
        PyModule_AddObject(ptr(), name, obj.inc_ref().ptr() /* steals a reference */);
858
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
859
860
};

861
/// \ingroup python_builtins
862
863
864
865
866
867
/// Return a dictionary representing the global variables in the current execution frame,
/// or ``__main__.__dict__`` if there is no frame (usually when the interpreter is embedded).
inline dict globals() {
    PyObject *p = PyEval_GetGlobals();
    return reinterpret_borrow<dict>(p ? p : module::import("__main__").attr("__dict__").ptr());
}
868

Wenzel Jakob's avatar
Wenzel Jakob committed
869
NAMESPACE_BEGIN(detail)
Wenzel Jakob's avatar
Wenzel Jakob committed
870
/// Generic support for creating new Python heap types
871
class generic_type : public object {
872
    template <typename...> friend class class_;
Wenzel Jakob's avatar
Wenzel Jakob committed
873
public:
874
    PYBIND11_OBJECT_DEFAULT(generic_type, object, PyType_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
875
protected:
876
877
878
879
    void initialize(const type_record &rec) {
        if (rec.scope && hasattr(rec.scope, rec.name))
            pybind11_fail("generic_type: cannot initialize type \"" + std::string(rec.name) +
                          "\": an object with that name is already defined");
880

881
        if (rec.module_local ? get_local_type_info(*rec.type) : get_global_type_info(*rec.type))
882
            pybind11_fail("generic_type: type \"" + std::string(rec.name) +
883
884
                          "\" is already registered!");

885
        m_ptr = make_new_python_type(rec);
886
887

        /* Register supplemental type information in C++ dict */
888
889
        auto *tinfo = new detail::type_info();
        tinfo->type = (PyTypeObject *) m_ptr;
890
        tinfo->cpptype = rec.type;
891
        tinfo->type_size = rec.type_size;
892
        tinfo->operator_new = rec.operator_new;
893
        tinfo->holder_size_in_ptrs = size_in_ptrs(rec.holder_size);
894
        tinfo->init_instance = rec.init_instance;
895
        tinfo->dealloc = rec.dealloc;
896
897
        tinfo->simple_type = true;
        tinfo->simple_ancestors = true;
898
899
        tinfo->default_holder = rec.default_holder;
        tinfo->module_local = rec.module_local;
900
901
902

        auto &internals = get_internals();
        auto tindex = std::type_index(*rec.type);
903
        tinfo->direct_conversions = &internals.direct_conversions[tindex];
904
905
906
907
        if (rec.module_local)
            registered_local_types_cpp()[tindex] = tinfo;
        else
            internals.registered_types_cpp[tindex] = tinfo;
908
        internals.registered_types_py[(PyTypeObject *) m_ptr] = { tinfo };
Wenzel Jakob's avatar
Wenzel Jakob committed
909

910
        if (rec.bases.size() > 1 || rec.multiple_inheritance) {
911
            mark_parents_nonsimple(tinfo->type);
912
913
914
915
916
917
            tinfo->simple_ancestors = false;
        }
        else if (rec.bases.size() == 1) {
            auto parent_tinfo = get_type_info((PyTypeObject *) rec.bases[0].ptr());
            tinfo->simple_ancestors = parent_tinfo->simple_ancestors;
        }
918
919
920
921

        if (rec.module_local) {
            // Stash the local typeinfo and loader so that external modules can access it.
            tinfo->module_local_load = &type_caster_generic::local_load;
922
            setattr(m_ptr, PYBIND11_MODULE_LOCAL_ID, capsule(tinfo));
923
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
924
925
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
926
927
    /// Helper function which tags all parents of a type using mult. inheritance
    void mark_parents_nonsimple(PyTypeObject *value) {
928
        auto t = reinterpret_borrow<tuple>(value->tp_bases);
Wenzel Jakob's avatar
Wenzel Jakob committed
929
930
931
932
933
934
935
936
        for (handle h : t) {
            auto tinfo2 = get_type_info((PyTypeObject *) h.ptr());
            if (tinfo2)
                tinfo2->simple_type = false;
            mark_parents_nonsimple((PyTypeObject *) h.ptr());
        }
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
937
938
939
    void install_buffer_funcs(
            buffer_info *(*get_buffer)(PyObject *, void *),
            void *get_buffer_data) {
Wenzel Jakob's avatar
Wenzel Jakob committed
940
        PyHeapTypeObject *type = (PyHeapTypeObject*) m_ptr;
941
        auto tinfo = detail::get_type_info(&type->ht_type);
Wenzel Jakob's avatar
Wenzel Jakob committed
942
943
944
945
946
947
948
949

        if (!type->ht_type.tp_as_buffer)
            pybind11_fail(
                "To be able to register buffer protocol support for the type '" +
                std::string(tinfo->type->tp_name) +
                "' the associated class<>(..) invocation must "
                "include the pybind11::buffer_protocol() annotation!");

950
951
        tinfo->get_buffer = get_buffer;
        tinfo->get_buffer_data = get_buffer_data;
Wenzel Jakob's avatar
Wenzel Jakob committed
952
953
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
954
955
956
    void def_property_static_impl(const char *name,
                                  handle fget, handle fset,
                                  detail::function_record *rec_fget) {
957
958
959
960
961
962
963
964
965
        const auto is_static = !(rec_fget->is_method && rec_fget->scope);
        const auto has_doc = rec_fget->doc && pybind11::options::show_user_defined_docstrings();

        auto property = handle((PyObject *) (is_static ? get_internals().static_property_type
                                                       : &PyProperty_Type));
        attr(name) = property(fget.ptr() ? fget : none(),
                              fset.ptr() ? fset : none(),
                              /*deleter*/none(),
                              pybind11::str(has_doc ? rec_fget->doc : ""));
Wenzel Jakob's avatar
Wenzel Jakob committed
966
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
967
};
968

969
970
971
972
973
974
/// Set the pointer to operator new if it exists. The cast is needed because it can be overloaded.
template <typename T, typename = void_t<decltype(static_cast<void *(*)(size_t)>(T::operator new))>>
void set_operator_new(type_record *r) { r->operator_new = &T::operator new; }

template <typename> void set_operator_new(...) { }

975
976
977
978
979
980
template <typename T, typename SFINAE = void> struct has_operator_delete : std::false_type { };
template <typename T> struct has_operator_delete<T, void_t<decltype(static_cast<void (*)(void *)>(T::operator delete))>>
    : std::true_type { };
template <typename T, typename SFINAE = void> struct has_operator_delete_size : std::false_type { };
template <typename T> struct has_operator_delete_size<T, void_t<decltype(static_cast<void (*)(void *, size_t)>(T::operator delete))>>
    : std::true_type { };
981
/// Call class-specific delete if it exists or global otherwise. Can also be an overload set.
982
983
984
985
template <typename T, enable_if_t<has_operator_delete<T>::value, int> = 0>
void call_operator_delete(T *p, size_t) { T::operator delete(p); }
template <typename T, enable_if_t<!has_operator_delete<T>::value && has_operator_delete_size<T>::value, int> = 0>
void call_operator_delete(T *p, size_t s) { T::operator delete(p, s); }
986

987
inline void call_operator_delete(void *p, size_t) { ::operator delete(p); }
988

Wenzel Jakob's avatar
Wenzel Jakob committed
989
990
NAMESPACE_END(detail)

991
992
993
994
995
996
997
998
999
1000
1001
/// Given a pointer to a member function, cast it to its `Derived` version.
/// Forward everything else unchanged.
template <typename /*Derived*/, typename F>
auto method_adaptor(F &&f) -> decltype(std::forward<F>(f)) { return std::forward<F>(f); }

template <typename Derived, typename Return, typename Class, typename... Args>
auto method_adaptor(Return (Class::*pmf)(Args...)) -> Return (Derived::*)(Args...) { return pmf; }

template <typename Derived, typename Return, typename Class, typename... Args>
auto method_adaptor(Return (Class::*pmf)(Args...) const) -> Return (Derived::*)(Args...) const { return pmf; }

1002
template <typename type_, typename... options>
Wenzel Jakob's avatar
Wenzel Jakob committed
1003
class class_ : public detail::generic_type {
1004
    template <typename T> using is_holder = detail::is_holder_type<type_, T>;
1005
1006
    template <typename T> using is_subtype = detail::is_strict_base_of<type_, T>;
    template <typename T> using is_base = detail::is_strict_base_of<T, type_>;
1007
1008
1009
    // struct instead of using here to help MSVC:
    template <typename T> struct is_valid_class_option :
        detail::any_of<is_holder<T>, is_subtype<T>, is_base<T>> {};
1010

Wenzel Jakob's avatar
Wenzel Jakob committed
1011
public:
1012
    using type = type_;
1013
    using type_alias = detail::exactly_one_t<is_subtype, void, options...>;
1014
    constexpr static bool has_alias = !std::is_void<type_alias>::value;
1015
    using holder_type = detail::exactly_one_t<is_holder, std::unique_ptr<type>, options...>;
1016

1017
    static_assert(detail::all_of<is_valid_class_option<options>...>::value,
1018
            "Unknown/invalid class_ template parameters provided");
Wenzel Jakob's avatar
Wenzel Jakob committed
1019

1020
1021
1022
    static_assert(!has_alias || std::is_polymorphic<type>::value,
            "Cannot use an alias class with a non-polymorphic type");

1023
    PYBIND11_OBJECT(class_, generic_type, PyType_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
1024

Wenzel Jakob's avatar
Wenzel Jakob committed
1025
1026
    template <typename... Extra>
    class_(handle scope, const char *name, const Extra &... extra) {
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
        using namespace detail;

        // MI can only be specified via class_ template options, not constructor parameters
        static_assert(
            none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
            (   constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
                constexpr_sum(is_base<options>::value...)   == 0 && // no template option bases
                none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
            "Error: multiple inheritance bases must be specified via class_ template options");

        type_record record;
Wenzel Jakob's avatar
Wenzel Jakob committed
1038
1039
1040
        record.scope = scope;
        record.name = name;
        record.type = &typeid(type);
1041
        record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
1042
        record.holder_size = sizeof(holder_type);
1043
        record.init_instance = init_instance;
Wenzel Jakob's avatar
Wenzel Jakob committed
1044
        record.dealloc = dealloc;
1045
        record.default_holder = std::is_same<holder_type, std::unique_ptr<type>>::value;
Wenzel Jakob's avatar
Wenzel Jakob committed
1046

1047
1048
        set_operator_new<type>(&record);

Wenzel Jakob's avatar
Wenzel Jakob committed
1049
        /* Register base classes specified via template arguments to class_, if any */
1050
        PYBIND11_EXPAND_SIDE_EFFECTS(add_base<options>(record));
1051

Wenzel Jakob's avatar
Wenzel Jakob committed
1052
        /* Process optional arguments, if any */
1053
        process_attributes<Extra...>::init(extra..., &record);
Wenzel Jakob's avatar
Wenzel Jakob committed
1054

1055
        generic_type::initialize(record);
1056

1057
        if (has_alias) {
1058
            auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp;
1059
1060
            instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
1061
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1062

1063
    template <typename Base, detail::enable_if_t<is_base<Base>::value, int> = 0>
Wenzel Jakob's avatar
Wenzel Jakob committed
1064
    static void add_base(detail::type_record &rec) {
1065
        rec.add_base(typeid(Base), [](void *src) -> void * {
Wenzel Jakob's avatar
Wenzel Jakob committed
1066
1067
1068
1069
            return static_cast<Base *>(reinterpret_cast<type *>(src));
        });
    }

1070
    template <typename Base, detail::enable_if_t<!is_base<Base>::value, int> = 0>
Wenzel Jakob's avatar
Wenzel Jakob committed
1071
1072
    static void add_base(detail::type_record &) { }

1073
    template <typename Func, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1074
    class_ &def(const char *name_, Func&& f, const Extra&... extra) {
1075
        cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
1076
                        sibling(getattr(*this, name_, none())), extra...);
1077
        attr(cf.name()) = cf;
Wenzel Jakob's avatar
Wenzel Jakob committed
1078
1079
1080
        return *this;
    }

1081
    template <typename Func, typename... Extra> class_ &
1082
1083
1084
    def_static(const char *name_, Func &&f, const Extra&... extra) {
        static_assert(!std::is_member_function_pointer<Func>::value,
                "def_static(...) called with a non-static member function pointer");
1085
1086
        cpp_function cf(std::forward<Func>(f), name(name_), scope(*this),
                        sibling(getattr(*this, name_, none())), extra...);
1087
        attr(cf.name()) = cf;
Wenzel Jakob's avatar
Wenzel Jakob committed
1088
1089
1090
        return *this;
    }

1091
    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1092
    class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
1093
        op.execute(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1094
1095
1096
        return *this;
    }

1097
    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1098
    class_ & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
1099
        op.execute_cast(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1100
1101
1102
        return *this;
    }

1103
    template <typename... Args, typename... Extra>
1104
    class_ &def(const detail::initimpl::constructor<Args...> &init, const Extra&... extra) {
1105
        init.execute(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1106
1107
1108
        return *this;
    }

1109
    template <typename... Args, typename... Extra>
1110
    class_ &def(const detail::initimpl::alias_constructor<Args...> &init, const Extra&... extra) {
1111
        init.execute(*this, extra...);
1112
1113
1114
        return *this;
    }

1115
1116
1117
1118
1119
1120
    template <typename... Args, typename... Extra>
    class_ &def(detail::initimpl::factory<Args...> &&init, const Extra&... extra) {
        std::move(init).execute(*this, extra...);
        return *this;
    }

1121
1122
1123
1124
1125
1126
    template <typename... Args, typename... Extra>
    class_ &def(detail::initimpl::pickle_factory<Args...> &&pf, const Extra &...extra) {
        std::move(pf).execute(*this, extra...);
        return *this;
    }

1127
    template <typename Func> class_& def_buffer(Func &&func) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1128
1129
1130
        struct capture { Func func; };
        capture *ptr = new capture { std::forward<Func>(func) };
        install_buffer_funcs([](PyObject *obj, void *ptr) -> buffer_info* {
1131
            detail::make_caster<type> caster;
Wenzel Jakob's avatar
Wenzel Jakob committed
1132
1133
            if (!caster.load(obj, false))
                return nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
1134
1135
            return new buffer_info(((capture *) ptr)->func(caster));
        }, ptr);
Wenzel Jakob's avatar
Wenzel Jakob committed
1136
1137
1138
        return *this;
    }

1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
    template <typename Return, typename Class, typename... Args>
    class_ &def_buffer(Return (Class::*func)(Args...)) {
        return def_buffer([func] (type &obj) { return (obj.*func)(); });
    }

    template <typename Return, typename Class, typename... Args>
    class_ &def_buffer(Return (Class::*func)(Args...) const) {
        return def_buffer([func] (const type &obj) { return (obj.*func)(); });
    }

1149
    template <typename C, typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1150
    class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
1151
1152
1153
        static_assert(std::is_base_of<C, type>::value, "def_readwrite() requires a class member (or base class member)");
        cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this)),
                     fset([pm](type &c, const D &value) { c.*pm = value; }, is_method(*this));
1154
        def_property(name, fget, fset, return_value_policy::reference_internal, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1155
1156
1157
        return *this;
    }

1158
    template <typename C, typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1159
    class_ &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) {
1160
1161
        static_assert(std::is_base_of<C, type>::value, "def_readonly() requires a class member (or base class member)");
        cpp_function fget([pm](const type &c) -> const D &{ return c.*pm; }, is_method(*this));
1162
        def_property_readonly(name, fget, return_value_policy::reference_internal, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1163
1164
1165
        return *this;
    }

1166
    template <typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1167
    class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
1168
1169
1170
        cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this)),
                     fset([pm](object, const D &value) { *pm = value; }, scope(*this));
        def_property_static(name, fget, fset, return_value_policy::reference, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1171
1172
1173
        return *this;
    }

1174
    template <typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1175
    class_ &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
1176
1177
        cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this));
        def_property_readonly_static(name, fget, return_value_policy::reference, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1178
1179
1180
        return *this;
    }

1181
1182
1183
    /// Uses return_value_policy::reference_internal by default
    template <typename Getter, typename... Extra>
    class_ &def_property_readonly(const char *name, const Getter &fget, const Extra& ...extra) {
1184
1185
        return def_property_readonly(name, cpp_function(method_adaptor<type>(fget)),
                                     return_value_policy::reference_internal, extra...);
1186
1187
1188
    }

    /// Uses cpp_function's return_value_policy by default
1189
1190
    template <typename... Extra>
    class_ &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) {
1191
1192
1193
1194
1195
1196
1197
        return def_property(name, fget, cpp_function(), extra...);
    }

    /// Uses return_value_policy::reference by default
    template <typename Getter, typename... Extra>
    class_ &def_property_readonly_static(const char *name, const Getter &fget, const Extra& ...extra) {
        return def_property_readonly_static(name, cpp_function(fget), return_value_policy::reference, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1198
1199
    }

1200
    /// Uses cpp_function's return_value_policy by default
1201
1202
    template <typename... Extra>
    class_ &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) {
1203
1204
1205
1206
        return def_property_static(name, fget, cpp_function(), extra...);
    }

    /// Uses return_value_policy::reference_internal by default
1207
1208
1209
1210
    template <typename Getter, typename Setter, typename... Extra>
    class_ &def_property(const char *name, const Getter &fget, const Setter &fset, const Extra& ...extra) {
        return def_property(name, fget, cpp_function(method_adaptor<type>(fset)), extra...);
    }
1211
1212
    template <typename Getter, typename... Extra>
    class_ &def_property(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
1213
1214
        return def_property(name, cpp_function(method_adaptor<type>(fget)), fset,
                            return_value_policy::reference_internal, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1215
1216
    }

1217
    /// Uses cpp_function's return_value_policy by default
1218
1219
    template <typename... Extra>
    class_ &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
1220
        return def_property_static(name, fget, fset, is_method(*this), extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1221
1222
    }

1223
1224
1225
1226
1227
1228
1229
    /// Uses return_value_policy::reference by default
    template <typename Getter, typename... Extra>
    class_ &def_property_static(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
        return def_property_static(name, cpp_function(fget), fset, return_value_policy::reference, extra...);
    }

    /// Uses cpp_function's return_value_policy by default
1230
1231
1232
    template <typename... Extra>
    class_ &def_property_static(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
        auto rec_fget = get_function_record(fget), rec_fset = get_function_record(fset);
1233
        char *doc_prev = rec_fget->doc; /* 'extra' field may include a property-specific documentation string */
1234
        detail::process_attributes<Extra...>::init(extra..., rec_fget);
1235
1236
1237
1238
1239
1240
        if (rec_fget->doc && rec_fget->doc != doc_prev) {
            free(doc_prev);
            rec_fget->doc = strdup(rec_fget->doc);
        }
        if (rec_fset) {
            doc_prev = rec_fset->doc;
1241
            detail::process_attributes<Extra...>::init(extra..., rec_fset);
1242
1243
1244
1245
1246
            if (rec_fset->doc && rec_fset->doc != doc_prev) {
                free(doc_prev);
                rec_fset->doc = strdup(rec_fset->doc);
            }
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
1247
        def_property_static_impl(name, fget, fset, rec_fget);
Wenzel Jakob's avatar
Wenzel Jakob committed
1248
1249
        return *this;
    }
1250

Wenzel Jakob's avatar
Wenzel Jakob committed
1251
private:
1252
1253
    /// Initialize holder object, variant 1: object derives from enable_shared_from_this
    template <typename T>
1254
    static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
1255
            const holder_type * /* unused */, const std::enable_shared_from_this<T> * /* dummy */) {
1256
        try {
1257
1258
            auto sh = std::dynamic_pointer_cast<typename holder_type::element_type>(
                    v_h.value_ptr<type>()->shared_from_this());
1259
            if (sh) {
1260
1261
                new (&v_h.holder<holder_type>()) holder_type(std::move(sh));
                v_h.set_holder_constructed();
1262
            }
1263
        } catch (const std::bad_weak_ptr &) {}
1264
1265
1266
1267

        if (!v_h.holder_constructed() && inst->owned) {
            new (&v_h.holder<holder_type>()) holder_type(v_h.value_ptr<type>());
            v_h.set_holder_constructed();
1268
        }
1269
1270
    }

1271
1272
1273
    static void init_holder_from_existing(const detail::value_and_holder &v_h,
            const holder_type *holder_ptr, std::true_type /*is_copy_constructible*/) {
        new (&v_h.holder<holder_type>()) holder_type(*reinterpret_cast<const holder_type *>(holder_ptr));
1274
1275
    }

1276
1277
1278
    static void init_holder_from_existing(const detail::value_and_holder &v_h,
            const holder_type *holder_ptr, std::false_type /*is_copy_constructible*/) {
        new (&v_h.holder<holder_type>()) holder_type(std::move(*const_cast<holder_type *>(holder_ptr)));
1279
1280
    }

1281
    /// Initialize holder object, variant 2: try to construct from existing holder object, if possible
1282
    static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
1283
            const holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) {
1284
        if (holder_ptr) {
1285
1286
            init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible<holder_type>());
            v_h.set_holder_constructed();
1287
        } else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
1288
1289
            new (&v_h.holder<holder_type>()) holder_type(v_h.value_ptr<type>());
            v_h.set_holder_constructed();
1290
        }
1291
1292
    }

1293
1294
1295
1296
1297
    /// Performs instance initialization including constructing a holder and registering the known
    /// instance.  Should be called as soon as the `type` value_ptr is set for an instance.  Takes an
    /// optional pointer to an existing holder to use; if not specified and the instance is
    /// `.owned`, a new holder will be constructed to manage the value pointer.
    static void init_instance(detail::instance *inst, const void *holder_ptr) {
1298
        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
1299
1300
1301
1302
        if (!v_h.instance_registered()) {
            register_instance(inst, v_h.value_ptr(), v_h.type);
            v_h.set_instance_registered();
        }
1303
        init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
1304
1305
    }

1306
    /// Deallocates an instance; via holder, if constructed; otherwise via operator delete.
1307
1308
    static void dealloc(detail::value_and_holder &v_h) {
        if (v_h.holder_constructed()) {
1309
            v_h.holder<holder_type>().~holder_type();
1310
1311
1312
            v_h.set_holder_constructed(false);
        }
        else {
1313
            detail::call_operator_delete(v_h.value_ptr<type>(), v_h.type->type_size);
1314
1315
        }
        v_h.value_ptr() = nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
1316
    }
1317
1318
1319

    static detail::function_record *get_function_record(handle h) {
        h = detail::get_function(h);
Wenzel Jakob's avatar
Wenzel Jakob committed
1320
        return h ? (detail::function_record *) reinterpret_borrow<capsule>(PyCFunction_GET_SELF(h.ptr()))
1321
                 : nullptr;
1322
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1323
1324
};

1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
/// Binds an existing constructor taking arguments Args...
template <typename... Args> detail::initimpl::constructor<Args...> init() { return {}; }
/// Like `init<Args...>()`, but the instance is always constructed through the alias class (even
/// when not inheriting on the Python side).
template <typename... Args> detail::initimpl::alias_constructor<Args...> init_alias() { return {}; }

/// Binds a factory function as a constructor
template <typename Func, typename Ret = detail::initimpl::factory<Func>>
Ret init(Func &&f) { return {std::forward<Func>(f)}; }

/// Dual-argument factory function: the first function is called when no alias is needed, the second
/// when an alias is needed (i.e. due to python-side inheritance).  Arguments must be identical.
template <typename CFunc, typename AFunc, typename Ret = detail::initimpl::factory<CFunc, AFunc>>
Ret init(CFunc &&c, AFunc &&a) {
    return {std::forward<CFunc>(c), std::forward<AFunc>(a)};
}

/// Binds pickling functions `__getstate__` and `__setstate__` and ensures that the type
/// returned by `__getstate__` is the same as the argument accepted by `__setstate__`.
template <typename GetState, typename SetState>
detail::initimpl::pickle_factory<GetState, SetState> pickle(GetState &&g, SetState &&s) {
    return {std::forward<GetState>(g), std::forward<SetState>(s)};
Marcin Wojdyr's avatar
Marcin Wojdyr committed
1347
}
1348

Wenzel Jakob's avatar
Wenzel Jakob committed
1349
1350
1351
/// Binds C++ enumerations and enumeration classes to Python
template <typename Type> class enum_ : public class_<Type> {
public:
1352
    using class_<Type>::def;
1353
    using class_<Type>::def_property_readonly_static;
1354
1355
    using Scalar = typename std::underlying_type<Type>::type;

Wenzel Jakob's avatar
Wenzel Jakob committed
1356
1357
    template <typename... Extra>
    enum_(const handle &scope, const char *name, const Extra&... extra)
1358
      : class_<Type>(scope, name, extra...), m_entries(), m_parent(scope) {
1359

1360
        constexpr bool is_arithmetic = detail::any_of<std::is_same<arithmetic, Extra>...>::value;
1361

1362
1363
1364
1365
1366
1367
1368
        auto m_entries_ptr = m_entries.inc_ref().ptr();
        def("__repr__", [name, m_entries_ptr](Type value) -> pybind11::str {
            for (const auto &kv : reinterpret_borrow<dict>(m_entries_ptr)) {
                if (pybind11::cast<Type>(kv.second) == value)
                    return pybind11::str("{}.{}").format(name, kv.first);
            }
            return pybind11::str("{}.???").format(name);
Wenzel Jakob's avatar
Wenzel Jakob committed
1369
        });
1370
1371
1372
1373
1374
1375
        def_property_readonly_static("__members__", [m_entries_ptr](object /* self */) {
            dict m;
            for (const auto &kv : reinterpret_borrow<dict>(m_entries_ptr))
                m[kv.first] = kv.second;
            return m;
        }, return_value_policy::copy);
1376
        def(init([](Scalar i) { return static_cast<Type>(i); }));
1377
        def("__int__", [](Type value) { return (Scalar) value; });
1378
1379
1380
        #if PY_MAJOR_VERSION < 3
            def("__long__", [](Type value) { return (Scalar) value; });
        #endif
1381
1382
        def("__eq__", [](const Type &value, Type *value2) { return value2 && value == *value2; });
        def("__ne__", [](const Type &value, Type *value2) { return !value2 || value != *value2; });
1383
1384
1385
1386
1387
1388
1389
        if (is_arithmetic) {
            def("__lt__", [](const Type &value, Type *value2) { return value2 && value < *value2; });
            def("__gt__", [](const Type &value, Type *value2) { return value2 && value > *value2; });
            def("__le__", [](const Type &value, Type *value2) { return value2 && value <= *value2; });
            def("__ge__", [](const Type &value, Type *value2) { return value2 && value >= *value2; });
        }
        if (std::is_convertible<Type, Scalar>::value) {
1390
1391
            // Don't provide comparison with the underlying type if the enum isn't convertible,
            // i.e. if Type is a scoped enum, mirroring the C++ behaviour.  (NB: we explicitly
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
            // convert Type to Scalar below anyway because this needs to compile).
            def("__eq__", [](const Type &value, Scalar value2) { return (Scalar) value == value2; });
            def("__ne__", [](const Type &value, Scalar value2) { return (Scalar) value != value2; });
            if (is_arithmetic) {
                def("__lt__", [](const Type &value, Scalar value2) { return (Scalar) value < value2; });
                def("__gt__", [](const Type &value, Scalar value2) { return (Scalar) value > value2; });
                def("__le__", [](const Type &value, Scalar value2) { return (Scalar) value <= value2; });
                def("__ge__", [](const Type &value, Scalar value2) { return (Scalar) value >= value2; });
                def("__invert__", [](const Type &value) { return ~((Scalar) value); });
                def("__and__", [](const Type &value, Scalar value2) { return (Scalar) value & value2; });
                def("__or__", [](const Type &value, Scalar value2) { return (Scalar) value | value2; });
                def("__xor__", [](const Type &value, Scalar value2) { return (Scalar) value ^ value2; });
                def("__rand__", [](const Type &value, Scalar value2) { return (Scalar) value & value2; });
                def("__ror__", [](const Type &value, Scalar value2) { return (Scalar) value | value2; });
                def("__rxor__", [](const Type &value, Scalar value2) { return (Scalar) value ^ value2; });
                def("__and__", [](const Type &value, const Type &value2) { return (Scalar) value & (Scalar) value2; });
                def("__or__", [](const Type &value, const Type &value2) { return (Scalar) value | (Scalar) value2; });
                def("__xor__", [](const Type &value, const Type &value2) { return (Scalar) value ^ (Scalar) value2; });
            }
1411
        }
1412
        def("__hash__", [](const Type &value) { return (Scalar) value; });
Wenzel Jakob's avatar
Wenzel Jakob committed
1413
        // Pickling and unpickling -- needed for use with the 'multiprocessing' module
1414
1415
        def(pickle([](const Type &value) { return pybind11::make_tuple((Scalar) value); },
                   [](tuple t) { return static_cast<Type>(t[0].cast<Scalar>()); }));
Wenzel Jakob's avatar
Wenzel Jakob committed
1416
1417
1418
    }

    /// Export enumeration entries into the parent scope
1419
1420
1421
    enum_& export_values() {
        for (const auto &kv : m_entries)
            m_parent.attr(kv.first) = kv.second;
1422
        return *this;
Wenzel Jakob's avatar
Wenzel Jakob committed
1423
1424
1425
1426
    }

    /// Add an enumeration entry
    enum_& value(char const* name, Type value) {
1427
1428
1429
        auto v = pybind11::cast(value, return_value_policy::copy);
        this->attr(name) = v;
        m_entries[pybind11::str(name)] = v;
Wenzel Jakob's avatar
Wenzel Jakob committed
1430
1431
        return *this;
    }
1432

Wenzel Jakob's avatar
Wenzel Jakob committed
1433
private:
1434
    dict m_entries;
Wenzel Jakob's avatar
Wenzel Jakob committed
1435
    handle m_parent;
Wenzel Jakob's avatar
Wenzel Jakob committed
1436
1437
1438
};

NAMESPACE_BEGIN(detail)
1439

1440

1441
inline void keep_alive_impl(handle nurse, handle patient) {
1442
    if (!nurse || !patient)
1443
        pybind11_fail("Could not activate keep_alive!");
1444

1445
    if (patient.is_none() || nurse.is_none())
1446
        return; /* Nothing to keep alive or nothing to be kept alive by */
1447

1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
    auto tinfo = all_type_info(Py_TYPE(nurse.ptr()));
    if (!tinfo.empty()) {
        /* It's a pybind-registered type, so we can store the patient in the
         * internal list. */
        add_patient(nurse.ptr(), patient.ptr());
    }
    else {
        /* Fall back to clever approach based on weak references taken from
         * Boost.Python. This is not used for pybind-registered types because
         * the objects can be destroyed out-of-order in a GC pass. */
        cpp_function disable_lifesupport(
            [patient](handle weakref) { patient.dec_ref(); weakref.dec_ref(); });
1460

1461
        weakref wr(nurse, disable_lifesupport);
1462

1463
1464
1465
        patient.inc_ref(); /* reference patient and leak the weak reference */
        (void) wr.release();
    }
1466
1467
}

1468
PYBIND11_NOINLINE inline void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret) {
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
    auto get_arg = [&](size_t n) {
        if (n == 0)
            return ret;
        else if (n == 1 && call.init_self)
            return call.init_self;
        else if (n <= call.args.size())
            return call.args[n - 1];
        return handle();
    };

    keep_alive_impl(get_arg(Nurse), get_arg(Patient));
1480
1481
}

1482
1483
inline std::pair<decltype(internals::registered_types_py)::iterator, bool> all_type_info_get_cache(PyTypeObject *type) {
    auto res = get_internals().registered_types_py
Jason Rhinelander's avatar
Jason Rhinelander committed
1484
#ifdef __cpp_lib_unordered_map_try_emplace
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
        .try_emplace(type);
#else
        .emplace(type, std::vector<detail::type_info *>());
#endif
    if (res.second) {
        // New cache entry created; set up a weak reference to automatically remove it if the type
        // gets destroyed:
        weakref((PyObject *) type, cpp_function([type](handle wr) {
            get_internals().registered_types_py.erase(type);
            wr.dec_ref();
        })).release();
    }

    return res;
}

1501
template <typename Iterator, typename Sentinel, bool KeyIterator, return_value_policy Policy>
1502
1503
1504
struct iterator_state {
    Iterator it;
    Sentinel end;
1505
    bool first_or_done;
1506
};
1507

Wenzel Jakob's avatar
Wenzel Jakob committed
1508
1509
NAMESPACE_END(detail)

1510
/// Makes a python iterator from a first and past-the-end C++ InputIterator.
1511
1512
template <return_value_policy Policy = return_value_policy::reference_internal,
          typename Iterator,
1513
          typename Sentinel,
1514
1515
          typename ValueType = decltype(*std::declval<Iterator>()),
          typename... Extra>
1516
iterator make_iterator(Iterator first, Sentinel last, Extra &&... extra) {
1517
    typedef detail::iterator_state<Iterator, Sentinel, false, Policy> state;
1518

Wenzel Jakob's avatar
Wenzel Jakob committed
1519
    if (!detail::get_type_info(typeid(state), false)) {
1520
        class_<state>(handle(), "iterator", pybind11::module_local())
1521
            .def("__iter__", [](state &s) -> state& { return s; })
1522
            .def("__next__", [](state &s) -> ValueType {
1523
                if (!s.first_or_done)
1524
1525
                    ++s.it;
                else
1526
1527
1528
                    s.first_or_done = false;
                if (s.it == s.end) {
                    s.first_or_done = true;
1529
                    throw stop_iteration();
1530
                }
1531
                return *s.it;
1532
            }, std::forward<Extra>(extra)..., Policy);
1533
1534
    }

1535
    return cast(state{first, last, true});
1536
}
1537

1538
1539
/// Makes an python iterator over the keys (`.first`) of a iterator over pairs from a
/// first and past-the-end InputIterator.
1540
1541
template <return_value_policy Policy = return_value_policy::reference_internal,
          typename Iterator,
1542
          typename Sentinel,
1543
          typename KeyType = decltype((*std::declval<Iterator>()).first),
1544
          typename... Extra>
1545
iterator make_key_iterator(Iterator first, Sentinel last, Extra &&... extra) {
1546
    typedef detail::iterator_state<Iterator, Sentinel, true, Policy> state;
1547

Wenzel Jakob's avatar
Wenzel Jakob committed
1548
    if (!detail::get_type_info(typeid(state), false)) {
1549
        class_<state>(handle(), "iterator", pybind11::module_local())
1550
1551
            .def("__iter__", [](state &s) -> state& { return s; })
            .def("__next__", [](state &s) -> KeyType {
1552
                if (!s.first_or_done)
1553
1554
                    ++s.it;
                else
1555
1556
1557
                    s.first_or_done = false;
                if (s.it == s.end) {
                    s.first_or_done = true;
1558
                    throw stop_iteration();
1559
                }
1560
                return (*s.it).first;
1561
            }, std::forward<Extra>(extra)..., Policy);
1562
1563
    }

1564
    return cast(state{first, last, true});
1565
}
1566

1567
1568
/// Makes an iterator over values of an stl container or other container supporting
/// `std::begin()`/`std::end()`
1569
1570
1571
template <return_value_policy Policy = return_value_policy::reference_internal,
          typename Type, typename... Extra> iterator make_iterator(Type &value, Extra&&... extra) {
    return make_iterator<Policy>(std::begin(value), std::end(value), extra...);
1572
1573
}

1574
1575
/// Makes an iterator over the keys (`.first`) of a stl map-like container supporting
/// `std::begin()`/`std::end()`
1576
1577
1578
template <return_value_policy Policy = return_value_policy::reference_internal,
          typename Type, typename... Extra> iterator make_key_iterator(Type &value, Extra&&... extra) {
    return make_key_iterator<Policy>(std::begin(value), std::end(value), extra...);
1579
1580
}

Wenzel Jakob's avatar
Wenzel Jakob committed
1581
template <typename InputType, typename OutputType> void implicitly_convertible() {
1582
1583
1584
1585
1586
    struct set_flag {
        bool &flag;
        set_flag(bool &flag) : flag(flag) { flag = true; }
        ~set_flag() { flag = false; }
    };
1587
    auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject * {
1588
1589
1590
1591
        static bool currently_used = false;
        if (currently_used) // implicit conversions are non-reentrant
            return nullptr;
        set_flag flag_helper(currently_used);
1592
        if (!detail::make_caster<InputType>().load(obj, false))
Wenzel Jakob's avatar
Wenzel Jakob committed
1593
1594
1595
1596
1597
1598
1599
1600
            return nullptr;
        tuple args(1);
        args[0] = obj;
        PyObject *result = PyObject_Call((PyObject *) type, args.ptr(), nullptr);
        if (result == nullptr)
            PyErr_Clear();
        return result;
    };
1601
1602
1603
1604

    if (auto tinfo = detail::get_type_info(typeid(OutputType)))
        tinfo->implicit_conversions.push_back(implicit_caster);
    else
1605
        pybind11_fail("implicitly_convertible: Unable to find type " + type_id<OutputType>());
Wenzel Jakob's avatar
Wenzel Jakob committed
1606
1607
}

1608
1609
1610
1611
1612
1613
template <typename ExceptionTranslator>
void register_exception_translator(ExceptionTranslator&& translator) {
    detail::get_internals().registered_exception_translators.push_front(
        std::forward<ExceptionTranslator>(translator));
}

1614
1615
/**
 * Wrapper to generate a new Python exception type.
1616
1617
1618
1619
1620
1621
1622
1623
 *
 * This should only be used with PyErr_SetString for now.
 * It is not (yet) possible to use as a py::base.
 * Template type argument is reserved for future use.
 */
template <typename type>
class exception : public object {
public:
1624
1625
1626
    exception(handle scope, const char *name, PyObject *base = PyExc_Exception) {
        std::string full_name = scope.attr("__name__").cast<std::string>() +
                                std::string(".") + name;
1627
        m_ptr = PyErr_NewException(const_cast<char *>(full_name.c_str()), base, NULL);
1628
1629
1630
1631
        if (hasattr(scope, name))
            pybind11_fail("Error during initialization: multiple incompatible "
                          "definitions with name \"" + std::string(name) + "\"");
        scope.attr(name) = *this;
1632
    }
1633
1634
1635
1636
1637

    // Sets the current python exception to this exception object with the given message
    void operator()(const char *message) {
        PyErr_SetString(m_ptr, message);
    }
1638
1639
};

1640
1641
/**
 * Registers a Python exception in `m` of the given `name` and installs an exception translator to
1642
1643
1644
1645
 * translate the C++ exception to the created Python exception using the exceptions what() method.
 * This is intended for simple exception translations; for more complex translation, register the
 * exception object and translator directly.
 */
1646
1647
1648
1649
1650
template <typename CppException>
exception<CppException> &register_exception(handle scope,
                                            const char *name,
                                            PyObject *base = PyExc_Exception) {
    static exception<CppException> ex(scope, name, base);
1651
1652
1653
1654
    register_exception_translator([](std::exception_ptr p) {
        if (!p) return;
        try {
            std::rethrow_exception(p);
1655
        } catch (const CppException &e) {
1656
1657
1658
1659
1660
1661
            ex(e.what());
        }
    });
    return ex;
}

Dean Moldovan's avatar
Dean Moldovan committed
1662
1663
1664
1665
NAMESPACE_BEGIN(detail)
PYBIND11_NOINLINE inline void print(tuple args, dict kwargs) {
    auto strings = tuple(args.size());
    for (size_t i = 0; i < args.size(); ++i) {
1666
        strings[i] = str(args[i]);
Dean Moldovan's avatar
Dean Moldovan committed
1667
    }
1668
    auto sep = kwargs.contains("sep") ? kwargs["sep"] : cast(" ");
1669
    auto line = sep.attr("join")(strings);
Dean Moldovan's avatar
Dean Moldovan committed
1670

1671
1672
1673
1674
1675
1676
    object file;
    if (kwargs.contains("file")) {
        file = kwargs["file"].cast<object>();
    } else {
        try {
            file = module::import("sys").attr("stdout");
1677
        } catch (const error_already_set &) {
1678
1679
1680
1681
1682
1683
1684
1685
            /* If print() is called from code that is executed as
               part of garbage collection during interpreter shutdown,
               importing 'sys' can fail. Give up rather than crashing the
               interpreter in this case. */
            return;
        }
    }

1686
    auto write = file.attr("write");
Dean Moldovan's avatar
Dean Moldovan committed
1687
    write(line);
1688
    write(kwargs.contains("end") ? kwargs["end"] : cast("\n"));
Dean Moldovan's avatar
Dean Moldovan committed
1689

1690
    if (kwargs.contains("flush") && kwargs["flush"].cast<bool>())
1691
        file.attr("flush")();
Dean Moldovan's avatar
Dean Moldovan committed
1692
1693
1694
1695
1696
1697
1698
1699
1700
}
NAMESPACE_END(detail)

template <return_value_policy policy = return_value_policy::automatic_reference, typename... Args>
void print(Args &&...args) {
    auto c = detail::collect_arguments<policy>(std::forward<Args>(args)...);
    detail::print(c.args(), c.kwargs());
}

Wenzel Jakob's avatar
Wenzel Jakob committed
1701
#if defined(WITH_THREAD) && !defined(PYPY_VERSION)
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715

/* The functions below essentially reproduce the PyGILState_* API using a RAII
 * pattern, but there are a few important differences:
 *
 * 1. When acquiring the GIL from an non-main thread during the finalization
 *    phase, the GILState API blindly terminates the calling thread, which
 *    is often not what is wanted. This API does not do this.
 *
 * 2. The gil_scoped_release function can optionally cut the relationship
 *    of a PyThreadState and its associated thread, which allows moving it to
 *    another thread (this is a fairly rare/advanced use case).
 *
 * 3. The reference count of an acquired thread state can be controlled. This
 *    can be handy to prevent cases where callbacks issued from an external
1716
1717
 *    thread would otherwise constantly construct and destroy thread state data
 *    structures.
1718
1719
1720
1721
1722
 *
 * See the Python bindings of NanoGUI (http://github.com/wjakob/nanogui) for an
 * example which uses features 2 and 3 to migrate the Python thread of
 * execution to another thread (to run the event loop on the original thread,
 * in this case).
1723
 */
Wenzel Jakob's avatar
Wenzel Jakob committed
1724
1725
1726

class gil_scoped_acquire {
public:
1727
    PYBIND11_NOINLINE gil_scoped_acquire() {
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
        auto const &internals = detail::get_internals();
        tstate = (PyThreadState *) PyThread_get_key_value(internals.tstate);

        if (!tstate) {
            tstate = PyThreadState_New(internals.istate);
            #if !defined(NDEBUG)
                if (!tstate)
                    pybind11_fail("scoped_acquire: could not create thread state!");
            #endif
            tstate->gilstate_counter = 0;
1738
1739
1740
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(internals.tstate);
            #endif
1741
1742
            PyThread_set_key_value(internals.tstate, tstate);
        } else {
1743
            release = detail::get_thread_state_unchecked() != tstate;
1744
1745
1746
1747
        }

        if (release) {
            /* Work around an annoying assertion in PyThreadState_Swap */
1748
1749
1750
1751
            #if defined(Py_DEBUG)
                PyInterpreterState *interp = tstate->interp;
                tstate->interp = nullptr;
            #endif
1752
            PyEval_AcquireThread(tstate);
1753
1754
1755
            #if defined(Py_DEBUG)
                tstate->interp = interp;
            #endif
1756
1757
1758
1759
1760
1761
1762
1763
1764
        }

        inc_ref();
    }

    void inc_ref() {
        ++tstate->gilstate_counter;
    }

1765
    PYBIND11_NOINLINE void dec_ref() {
1766
1767
        --tstate->gilstate_counter;
        #if !defined(NDEBUG)
1768
            if (detail::get_thread_state_unchecked() != tstate)
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
                pybind11_fail("scoped_acquire::dec_ref(): thread state must be current!");
            if (tstate->gilstate_counter < 0)
                pybind11_fail("scoped_acquire::dec_ref(): reference count underflow!");
        #endif
        if (tstate->gilstate_counter == 0) {
            #if !defined(NDEBUG)
                if (!release)
                    pybind11_fail("scoped_acquire::dec_ref(): internal error!");
            #endif
            PyThreadState_Clear(tstate);
            PyThreadState_DeleteCurrent();
1780
            PyThread_delete_key_value(detail::get_internals().tstate);
1781
1782
1783
1784
            release = false;
        }
    }

1785
    PYBIND11_NOINLINE ~gil_scoped_acquire() {
1786
1787
1788
1789
1790
1791
1792
        dec_ref();
        if (release)
           PyEval_SaveThread();
    }
private:
    PyThreadState *tstate = nullptr;
    bool release = true;
Wenzel Jakob's avatar
Wenzel Jakob committed
1793
1794
1795
1796
};

class gil_scoped_release {
public:
1797
    explicit gil_scoped_release(bool disassoc = false) : disassoc(disassoc) {
1798
1799
1800
1801
        // `get_internals()` must be called here unconditionally in order to initialize
        // `internals.tstate` for subsequent `gil_scoped_acquire` calls. Otherwise, an
        // initialization race could occur as multiple threads try `gil_scoped_acquire`.
        const auto &internals = detail::get_internals();
1802
        tstate = PyEval_SaveThread();
1803
        if (disassoc) {
1804
            auto key = internals.tstate;
1805
1806
1807
1808
1809
1810
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(key);
            #else
                PyThread_set_key_value(key, nullptr);
            #endif
        }
1811
1812
1813
1814
1815
    }
    ~gil_scoped_release() {
        if (!tstate)
            return;
        PyEval_RestoreThread(tstate);
1816
        if (disassoc) {
1817
            auto key = detail::get_internals().tstate;
1818
1819
1820
1821
1822
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(key);
            #endif
            PyThread_set_key_value(key, tstate);
        }
1823
1824
1825
1826
    }
private:
    PyThreadState *tstate;
    bool disassoc;
Wenzel Jakob's avatar
Wenzel Jakob committed
1827
};
Wenzel Jakob's avatar
Wenzel Jakob committed
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
#elif defined(PYPY_VERSION)
class gil_scoped_acquire {
    PyGILState_STATE state;
public:
    gil_scoped_acquire() { state = PyGILState_Ensure(); }
    ~gil_scoped_acquire() { PyGILState_Release(state); }
};

class gil_scoped_release {
    PyThreadState *state;
public:
    gil_scoped_release() { state = PyEval_SaveThread(); }
    ~gil_scoped_release() { PyEval_RestoreThread(state); }
};
1842
1843
1844
#else
class gil_scoped_acquire { };
class gil_scoped_release { };
1845
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
1846

1847
error_already_set::~error_already_set() {
Jason Rhinelander's avatar
Jason Rhinelander committed
1848
    if (type) {
1849
        gil_scoped_acquire gil;
Jason Rhinelander's avatar
Jason Rhinelander committed
1850
1851
1852
        type.release().dec_ref();
        value.release().dec_ref();
        trace.release().dec_ref();
1853
1854
1855
    }
}

1856
inline function get_type_overload(const void *this_ptr, const detail::type_info *this_type, const char *name)  {
Wenzel Jakob's avatar
Wenzel Jakob committed
1857
1858
    handle self = detail::get_object_handle(this_ptr, this_type);
    if (!self)
1859
        return function();
Wenzel Jakob's avatar
Wenzel Jakob committed
1860
    handle type = self.get_type();
1861
1862
    auto key = std::make_pair(type.ptr(), name);

1863
1864
    /* Cache functions that aren't overloaded in Python to avoid
       many costly Python dictionary lookups below */
1865
1866
1867
1868
    auto &cache = detail::get_internals().inactive_overload_cache;
    if (cache.find(key) != cache.end())
        return function();

Wenzel Jakob's avatar
Wenzel Jakob committed
1869
    function overload = getattr(self, name, function());
1870
1871
1872
1873
    if (overload.is_cpp_function()) {
        cache.insert(key);
        return function();
    }
1874

Wenzel Jakob's avatar
Wenzel Jakob committed
1875
1876
1877
    /* Don't call dispatch code if invoked from overridden function.
       Unfortunately this doesn't work on PyPy. */
#if !defined(PYPY_VERSION)
1878
    PyFrameObject *frame = PyThreadState_Get()->frame;
1879
    if (frame && (std::string) str(frame->f_code->co_name) == name &&
1880
1881
1882
1883
        frame->f_code->co_argcount > 0) {
        PyFrame_FastToLocals(frame);
        PyObject *self_caller = PyDict_GetItem(
            frame->f_locals, PyTuple_GET_ITEM(frame->f_code->co_varnames, 0));
Wenzel Jakob's avatar
Wenzel Jakob committed
1884
        if (self_caller == self.ptr())
1885
1886
            return function();
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
#else
    /* PyPy currently doesn't provide a detailed cpyext emulation of
       frame objects, so we have to emulate this using Python. This
       is going to be slow..*/
    dict d; d["self"] = self; d["name"] = pybind11::str(name);
    PyObject *result = PyRun_String(
        "import inspect\n"
        "frame = inspect.currentframe()\n"
        "if frame is not None:\n"
        "    frame = frame.f_back\n"
        "    if frame is not None and str(frame.f_code.co_name) == name and "
        "frame.f_code.co_argcount > 0:\n"
        "        self_caller = frame.f_locals[frame.f_code.co_varnames[0]]\n"
        "        if self_caller == self:\n"
        "            self = None\n",
        Py_file_input, d.ptr(), d.ptr());
    if (result == nullptr)
        throw error_already_set();
1905
    if (d["self"].is_none())
Wenzel Jakob's avatar
Wenzel Jakob committed
1906
1907
1908
1909
        return function();
    Py_DECREF(result);
#endif

1910
1911
1912
    return overload;
}

1913
template <class T> function get_overload(const T *this_ptr, const char *name) {
1914
1915
    auto tinfo = detail::get_type_info(typeid(T));
    return tinfo ? get_type_overload(this_ptr, tinfo, name) : function();
1916
1917
}

1918
#define PYBIND11_OVERLOAD_INT(ret_type, cname, name, ...) { \
1919
        pybind11::gil_scoped_acquire gil; \
1920
        pybind11::function overload = pybind11::get_overload(static_cast<const cname *>(this), name); \
1921
        if (overload) { \
1922
            auto o = overload(__VA_ARGS__); \
1923
            if (pybind11::detail::cast_is_temporary_value_reference<ret_type>::value) { \
1924
1925
                static pybind11::detail::overload_caster_t<ret_type> caster; \
                return pybind11::detail::cast_ref<ret_type>(std::move(o), caster); \
1926
1927
1928
1929
            } \
            else return pybind11::detail::cast_safe<ret_type>(std::move(o)); \
        } \
    }
1930

1931
#define PYBIND11_OVERLOAD_NAME(ret_type, cname, name, fn, ...) \
1932
    PYBIND11_OVERLOAD_INT(ret_type, cname, name, __VA_ARGS__) \
1933
    return cname::fn(__VA_ARGS__)
1934

1935
#define PYBIND11_OVERLOAD_PURE_NAME(ret_type, cname, name, fn, ...) \
1936
    PYBIND11_OVERLOAD_INT(ret_type, cname, name, __VA_ARGS__) \
1937
1938
1939
1940
1941
1942
1943
    pybind11::pybind11_fail("Tried to call pure virtual function \"" #cname "::" name "\"");

#define PYBIND11_OVERLOAD(ret_type, cname, fn, ...) \
    PYBIND11_OVERLOAD_NAME(ret_type, cname, #fn, fn, __VA_ARGS__)

#define PYBIND11_OVERLOAD_PURE(ret_type, cname, fn, ...) \
    PYBIND11_OVERLOAD_PURE_NAME(ret_type, cname, #fn, fn, __VA_ARGS__)
1944

1945
NAMESPACE_END(PYBIND11_NAMESPACE)
Wenzel Jakob's avatar
Wenzel Jakob committed
1946
1947

#if defined(_MSC_VER)
Wenzel Jakob's avatar
Wenzel Jakob committed
1948
#  pragma warning(pop)
1949
1950
#elif defined(__INTEL_COMPILER)
/* Leave ignored warnings on */
1951
#elif defined(__GNUG__) && !defined(__clang__)
Wenzel Jakob's avatar
Wenzel Jakob committed
1952
#  pragma GCC diagnostic pop
Wenzel Jakob's avatar
Wenzel Jakob committed
1953
#endif