pybind11.h 86.2 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
        using namespace detail;
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
167
        static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
        PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
168
169

        /* Register the function with Python from generic (non-templated) code */
170
        initialize_generic(rec, signature.text, types.data(), 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
        /* Generate a proper function signature */
        std::string signature;
220
221
222
        size_t type_index = 0, arg_index = 0;
        for (auto *pc = text; *pc != '\0'; ++pc) {
            const auto c = *pc;
223
224

            if (c == '{') {
225
226
227
228
229
230
231
232
233
234
                // Write arg name for everything except *args and **kwargs.
                if (*(pc + 1) == '*')
                    continue;

                if (arg_index < rec->args.size() && rec->args[arg_index].name) {
                    signature += rec->args[arg_index].name;
                } else if (arg_index == 0 && rec->is_method) {
                    signature += "self";
                } else {
                    signature += "arg" + std::to_string(arg_index - (rec->is_method ? 1 : 0));
235
                }
236
                signature += ": ";
237
            } else if (c == '}') {
238
239
240
241
                // Write default value if available.
                if (arg_index < rec->args.size() && rec->args[arg_index].descr) {
                    signature += "=";
                    signature += rec->args[arg_index].descr;
242
                }
243
                arg_index++;
244
245
            } else if (c == '%') {
                const std::type_info *t = types[type_index++];
246
                if (!t)
247
                    pybind11_fail("Internal error while parsing type signature (1)");
248
                if (auto tinfo = detail::get_type_info(*t)) {
Wenzel Jakob's avatar
Wenzel Jakob committed
249
250
251
252
253
#if defined(PYPY_VERSION)
                    signature += handle((PyObject *) tinfo->type)
                                     .attr("__module__")
                                     .cast<std::string>() + ".";
#endif
254
                    signature += tinfo->type->tp_name;
255
256
257
                } 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.
258
259
260
261
#if defined(PYPY_VERSION)
                    signature += rec->scope.attr("__module__").cast<std::string>() + ".";
#endif
                    signature += ((PyTypeObject *) rec->scope.ptr())->tp_name;
262
263
264
265
266
267
268
269
270
                } else {
                    std::string tname(t->name());
                    detail::clean_type_id(tname);
                    signature += tname;
                }
            } else {
                signature += c;
            }
        }
271
        if (arg_index != args || types[type_index] != nullptr)
272
            pybind11_fail("Internal error while parsing type signature (2)");
273

274
#if PY_MAJOR_VERSION < 3
Wenzel Jakob's avatar
Wenzel Jakob committed
275
276
277
        if (strcmp(rec->name, "__next__") == 0) {
            std::free(rec->name);
            rec->name = strdup("next");
278
279
280
        } else if (strcmp(rec->name, "__bool__") == 0) {
            std::free(rec->name);
            rec->name = strdup("__nonzero__");
281
        }
282
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
283
284
        rec->signature = strdup(signature.c_str());
        rec->args.shrink_to_fit();
285
        rec->nargs = (std::uint16_t) args;
286

287
288
        if (rec->sibling && PYBIND11_INSTANCE_METHOD_CHECK(rec->sibling.ptr()))
            rec->sibling = PYBIND11_INSTANCE_METHOD_GET_FUNCTION(rec->sibling.ptr());
289

Wenzel Jakob's avatar
Wenzel Jakob committed
290
        detail::function_record *chain = nullptr, *chain_start = rec;
291
292
        if (rec->sibling) {
            if (PyCFunction_Check(rec->sibling.ptr())) {
Wenzel Jakob's avatar
Wenzel Jakob committed
293
                auto rec_capsule = reinterpret_borrow<capsule>(PyCFunction_GET_SELF(rec->sibling.ptr()));
294
295
296
                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 */
297
                if (!chain->scope.is(rec->scope))
298
299
300
301
302
303
                    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");
304
305
        }

Wenzel Jakob's avatar
Wenzel Jakob committed
306
        if (!chain) {
307
            /* No existing overload was found, create a new function object */
Wenzel Jakob's avatar
Wenzel Jakob committed
308
            rec->def = new PyMethodDef();
309
            std::memset(rec->def, 0, sizeof(PyMethodDef));
Wenzel Jakob's avatar
Wenzel Jakob committed
310
311
312
            rec->def->ml_name = rec->name;
            rec->def->ml_meth = reinterpret_cast<PyCFunction>(*dispatcher);
            rec->def->ml_flags = METH_VARARGS | METH_KEYWORDS;
313

314
315
            capsule rec_capsule(rec, [](void *ptr) {
                destruct((detail::function_record *) ptr);
316
            });
317
318
319

            object scope_module;
            if (rec->scope) {
320
321
322
323
324
                if (hasattr(rec->scope, "__module__")) {
                    scope_module = rec->scope.attr("__module__");
                } else if (hasattr(rec->scope, "__name__")) {
                    scope_module = rec->scope.attr("__name__");
                }
325
326
327
            }

            m_ptr = PyCFunction_NewEx(rec->def, rec_capsule.ptr(), scope_module.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
328
            if (!m_ptr)
329
                pybind11_fail("cpp_function::cpp_function(): Could not allocate function object");
Wenzel Jakob's avatar
Wenzel Jakob committed
330
        } else {
331
            /* Append at the end of the overload chain */
Wenzel Jakob's avatar
Wenzel Jakob committed
332
            m_ptr = rec->sibling.ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
333
            inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
334
            chain_start = chain;
335
336
337
338
339
340
341
342
343
            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
344
345
346
            while (chain->next)
                chain = chain->next;
            chain->next = rec;
Wenzel Jakob's avatar
Wenzel Jakob committed
347
        }
348

Wenzel Jakob's avatar
Wenzel Jakob committed
349
        std::string signatures;
350
        int index = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
351
        /* Create a nice pydoc rec including all signatures and
352
           docstrings of the functions in the overload chain */
353
        if (chain && options::show_function_signatures()) {
354
355
356
357
358
359
            // First a generic signature
            signatures += rec->name;
            signatures += "(*args, **kwargs)\n";
            signatures += "Overloaded function.\n\n";
        }
        // Then specific overload signatures
360
        bool first_user_def = true;
Wenzel Jakob's avatar
Wenzel Jakob committed
361
        for (auto it = chain_start; it != nullptr; it = it->next) {
362
            if (options::show_function_signatures()) {
363
                if (index > 0) signatures += "\n";
364
365
366
367
                if (chain)
                    signatures += std::to_string(++index) + ". ";
                signatures += rec->name;
                signatures += it->signature;
368
                signatures += "\n";
369
370
            }
            if (it->doc && strlen(it->doc) > 0 && options::show_user_defined_docstrings()) {
371
372
373
374
375
376
                // 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";
                }
377
                if (options::show_function_signatures()) signatures += "\n";
378
                signatures += it->doc;
379
                if (options::show_function_signatures()) signatures += "\n";
380
            }
Wenzel Jakob's avatar
Wenzel Jakob committed
381
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
382
383

        /* Install docstring */
Wenzel Jakob's avatar
Wenzel Jakob committed
384
385
        PyCFunctionObject *func = (PyCFunctionObject *) m_ptr;
        if (func->m_ml->ml_doc)
386
            std::free(const_cast<char *>(func->m_ml->ml_doc));
Wenzel Jakob's avatar
Wenzel Jakob committed
387
        func->m_ml->ml_doc = strdup(signatures.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
388

389
390
        if (rec->is_method) {
            m_ptr = PYBIND11_INSTANCE_METHOD_NEW(m_ptr, rec->scope.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
391
            if (!m_ptr)
392
                pybind11_fail("cpp_function::cpp_function(): Could not allocate instance method object");
Wenzel Jakob's avatar
Wenzel Jakob committed
393
394
395
            Py_DECREF(func);
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
396
397
398
399
400
401

    /// 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)
402
                rec->free_data(rec);
Wenzel Jakob's avatar
Wenzel Jakob committed
403
404
405
406
            std::free((char *) rec->name);
            std::free((char *) rec->doc);
            std::free((char *) rec->signature);
            for (auto &arg: rec->args) {
407
408
                std::free(const_cast<char *>(arg.name));
                std::free(const_cast<char *>(arg.descr));
Wenzel Jakob's avatar
Wenzel Jakob committed
409
410
411
                arg.value.dec_ref();
            }
            if (rec->def) {
412
                std::free(const_cast<char *>(rec->def->ml_doc));
Wenzel Jakob's avatar
Wenzel Jakob committed
413
414
415
416
417
418
419
420
                delete rec->def;
            }
            delete rec;
            rec = next;
        }
    }

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

Wenzel Jakob's avatar
Wenzel Jakob committed
424
        /* Iterator over the list of potentially admissible overloads */
425
426
        function_record *overloads = (function_record *) PyCapsule_GetPointer(self, nullptr),
                        *it = overloads;
Wenzel Jakob's avatar
Wenzel Jakob committed
427
428

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

431
        handle parent = n_args_in > 0 ? PyTuple_GET_ITEM(args_in, 0) : nullptr,
Wenzel Jakob's avatar
Wenzel Jakob committed
432
               result = PYBIND11_TRY_NEXT_OVERLOAD;
433

434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
        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
451
        try {
452
453
454
455
456
457
458
459
460
            // 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
461
            for (; it != nullptr; it = it->next) {
462

Wenzel Jakob's avatar
Wenzel Jakob committed
463
                /* For each overload:
464
465
                   1. Copy all positional arguments we were given, also checking to make sure that
                      named positional arguments weren't *also* specified via kwarg.
466
                   2. If we weren't given enough, try to make up the omitted ones by checking
467
468
469
470
471
472
473
474
475
476
477
478
479
                      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
480
481
                 */

482
483
484
485
                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
486

487
                if (!func.has_args && n_args_in > pos_args)
488
489
                    continue; // Too many arguments for this overload

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

493
                function_call call(func, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
494

495
496
497
                size_t args_to_copy = std::min(pos_args, n_args_in);
                size_t args_copied = 0;

498
499
500
501
502
503
504
                // 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);

505
                    call.init_self = PyTuple_GET_ITEM(args_in, 0);
506
507
508
509
510
                    call.args.push_back(reinterpret_cast<PyObject *>(&self_value_and_holder));
                    call.args_convert.push_back(false);
                    ++args_copied;
                }

511
                // 1. Copy any position arguments given.
512
                bool bad_arg = false;
513
                for (; args_copied < args_to_copy; ++args_copied) {
514
515
516
                    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;
517
                        break;
518
519
                    }

520
521
522
523
524
525
526
                    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);
527
                }
528
                if (bad_arg)
529
                    continue; // Maybe it was meant for another overload (issue #688)
530
531
532
533
534
535
536
537
538

                // 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) {
539
                        const auto &arg = func.args[args_copied];
540
541

                        handle value;
542
                        if (kwargs_in && arg.name)
543
                            value = PyDict_GetItemString(kwargs.ptr(), arg.name);
Wenzel Jakob's avatar
Wenzel Jakob committed
544
545

                        if (value) {
546
547
548
549
550
551
                            // Consume a kwargs value
                            if (!copied_kwargs) {
                                kwargs = reinterpret_steal<dict>(PyDict_Copy(kwargs.ptr()));
                                copied_kwargs = true;
                            }
                            PyDict_DelItemString(kwargs.ptr(), arg.name);
552
                        } else if (arg.value) {
553
554
555
                            value = arg.value;
                        }

556
                        if (value) {
557
                            call.args.push_back(value);
558
559
                            call.args_convert.push_back(arg.convert);
                        }
560
                        else
Wenzel Jakob's avatar
Wenzel Jakob committed
561
                            break;
562
563
564
565
566
567
568
                    }

                    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)
569
                if (kwargs && kwargs.size() > 0 && !func.has_kwargs)
570
571
572
573
                    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;
574
                if (func.has_args) {
575
576
577
578
                    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);
579
                    } else if (args_copied >= n_args_in) {
580
                        extra_args = tuple(0);
581
                    } else {
582
583
584
585
586
                        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
587
588
                        }
                    }
589
                    call.args.push_back(extra_args);
590
                    call.args_convert.push_back(false);
Wenzel Jakob's avatar
Wenzel Jakob committed
591
                }
592

593
                // 4b. If we have a py::kwargs, pass on any remaining kwargs
594
                if (func.has_kwargs) {
595
596
                    if (!kwargs.ptr())
                        kwargs = dict(); // If we didn't get one, send an empty one
597
                    call.args.push_back(kwargs);
598
                    call.args_convert.push_back(false);
599
600
                }

601
602
603
                // 5. Put everything in a vector.  Not technically step 5, we've been building it
                // in `call.args` all along.
                #if !defined(NDEBUG)
604
                if (call.args.size() != func.nargs || call.args_convert.size() != func.nargs)
605
606
                    pybind11_fail("Internal error: function call dispatcher inserted wrong number of arguments!");
                #endif
607

608
609
610
611
612
613
614
615
616
                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);
                }

617
                // 6. Call the function.
618
                try {
619
                    loader_life_support guard{};
620
                    result = func.impl(call);
621
                } catch (reference_cast_error &) {
622
623
                    result = PYBIND11_TRY_NEXT_OVERLOAD;
                }
Wenzel Jakob's avatar
Wenzel Jakob committed
624
625
626

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

628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
                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 {
648
                        loader_life_support guard{};
649
650
651
652
653
654
655
656
                        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
657
            }
658
659
        } catch (error_already_set &e) {
            e.restore();
660
            return nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
661
        } catch (...) {
662
663
664
            /* When an exception is caught, give each registered exception
               translator a chance to translate it to a Python exception
               in reverse order of registration.
665

666
               A translator may choose to do one of the following:
667

668
669
670
671
672
                - 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. */

673
            auto last_exception = std::current_exception();
674
            auto &registered_exception_translators = get_internals().registered_exception_translators;
675
676
677
678
679
680
681
682
683
684
            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
685
686
687
            return nullptr;
        }

688
689
690
691
692
693
694
695
696
697
        auto append_note_if_missing_header_is_suspected = [](std::string &msg) {
            if (msg.find("std::") != std::string::npos) {
                msg += "\n\n"
                       "Did you forget to `#include <pybind11/stl.h>`? Or <pybind11/complex.h>,\n"
                       "<pybind11/functional.h>, <pybind11/chrono.h>, etc. Some automatic\n"
                       "conversions are optional and require extra headers to be included\n"
                       "when compiling your pybind11 module.";
            }
        };

Wenzel Jakob's avatar
Wenzel Jakob committed
698
        if (result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) {
699
700
701
            if (overloads->is_operator)
                return handle(Py_NotImplemented).inc_ref().ptr();

702
703
704
705
            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
706
            int ctr = 0;
707
            for (function_record *it2 = overloads; it2 != nullptr; it2 = it2->next) {
Wenzel Jakob's avatar
Wenzel Jakob committed
708
                msg += "    "+ std::to_string(++ctr) + ". ";
709
710
711

                bool wrote_sig = false;
                if (overloads->is_constructor) {
712
                    // For a constructor, rewrite `(self: Object, arg0, ...) -> NoneType` as `Object(arg0, ...)`
713
                    std::string sig = it2->signature;
714
                    size_t start = sig.find('(') + 7; // skip "(self: "
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
                    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
731
732
                msg += "\n";
            }
733
            msg += "\nInvoked with: ";
734
            auto args_ = reinterpret_borrow<tuple>(args_in);
735
            bool some_args = false;
736
            for (size_t ti = overloads->is_constructor ? 1 : 0; ti < args_.size(); ++ti) {
737
738
                if (!some_args) some_args = true;
                else msg += ", ";
739
                msg += pybind11::repr(args_[ti]);
740
            }
741
742
743
744
745
746
747
748
749
750
751
752
753
754
            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);
                    }
                }
            }

755
            append_note_if_missing_header_is_suspected(msg);
Wenzel Jakob's avatar
Wenzel Jakob committed
756
757
758
759
760
761
            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;
762
            append_note_if_missing_header_is_suspected(msg);
Wenzel Jakob's avatar
Wenzel Jakob committed
763
764
765
            PyErr_SetString(PyExc_TypeError, msg.c_str());
            return nullptr;
        } else {
766
            if (overloads->is_constructor && !self_value_and_holder.holder_constructed()) {
767
                auto *pi = reinterpret_cast<instance *>(parent.ptr());
768
                self_value_and_holder.type->init_instance(pi, nullptr);
Wenzel Jakob's avatar
Wenzel Jakob committed
769
770
771
772
            }
            return result.ptr();
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
773
774
};

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

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

799
800
801
802
803
    /** \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 */
804
    template <typename Func, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
805
    module &def(const char *name_, Func &&f, const Extra& ... extra) {
806
807
        cpp_function func(std::forward<Func>(f), name(name_), scope(*this),
                          sibling(getattr(*this, name_, none())), extra...);
808
809
810
        // 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
811
812
813
        return *this;
    }

814
815
816
817
818
819
820
821
822
823
    /** \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 */
824
    module def_submodule(const char *name, const char *doc = nullptr) {
Wenzel Jakob's avatar
Wenzel Jakob committed
825
826
        std::string full_name = std::string(PyModule_GetName(m_ptr))
            + std::string(".") + std::string(name);
827
        auto result = reinterpret_borrow<module>(PyImport_AddModule(full_name.c_str()));
828
        if (doc && options::show_user_defined_docstrings())
829
            result.attr("__doc__") = pybind11::str(doc);
Wenzel Jakob's avatar
Wenzel Jakob committed
830
831
832
        attr(name) = result;
        return result;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
833

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

842
843
844
845
846
847
848
849
    /// 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);
    }

850
851
852
853
854
    // 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.
855
    PYBIND11_NOINLINE void add_object(const char *name, handle obj, bool overwrite = false) {
856
857
858
859
        if (!overwrite && hasattr(*this, name))
            pybind11_fail("Error during initialization: multiple incompatible definitions with name \"" +
                    std::string(name) + "\"");

860
        PyModule_AddObject(ptr(), name, obj.inc_ref().ptr() /* steals a reference */);
861
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
862
863
};

864
/// \ingroup python_builtins
865
866
867
868
869
870
/// 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());
}
871

Wenzel Jakob's avatar
Wenzel Jakob committed
872
NAMESPACE_BEGIN(detail)
Wenzel Jakob's avatar
Wenzel Jakob committed
873
/// Generic support for creating new Python heap types
874
class generic_type : public object {
875
    template <typename...> friend class class_;
Wenzel Jakob's avatar
Wenzel Jakob committed
876
public:
877
    PYBIND11_OBJECT_DEFAULT(generic_type, object, PyType_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
878
protected:
879
880
881
882
    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");
883

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

888
        m_ptr = make_new_python_type(rec);
889
890

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

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

913
        if (rec.bases.size() > 1 || rec.multiple_inheritance) {
914
            mark_parents_nonsimple(tinfo->type);
915
916
917
918
919
920
            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;
        }
921
922
923
924

        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;
925
            setattr(m_ptr, PYBIND11_MODULE_LOCAL_ID, capsule(tinfo));
926
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
927
928
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
929
930
    /// Helper function which tags all parents of a type using mult. inheritance
    void mark_parents_nonsimple(PyTypeObject *value) {
931
        auto t = reinterpret_borrow<tuple>(value->tp_bases);
Wenzel Jakob's avatar
Wenzel Jakob committed
932
933
934
935
936
937
938
939
        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
940
941
942
    void install_buffer_funcs(
            buffer_info *(*get_buffer)(PyObject *, void *),
            void *get_buffer_data) {
Wenzel Jakob's avatar
Wenzel Jakob committed
943
        PyHeapTypeObject *type = (PyHeapTypeObject*) m_ptr;
944
        auto tinfo = detail::get_type_info(&type->ht_type);
Wenzel Jakob's avatar
Wenzel Jakob committed
945
946
947
948
949
950
951
952

        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!");

953
954
        tinfo->get_buffer = get_buffer;
        tinfo->get_buffer_data = get_buffer_data;
Wenzel Jakob's avatar
Wenzel Jakob committed
955
956
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
957
958
959
    void def_property_static_impl(const char *name,
                                  handle fget, handle fset,
                                  detail::function_record *rec_fget) {
960
961
962
963
964
965
966
967
968
        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
969
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
970
};
971

972
973
974
975
976
977
/// 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(...) { }

978
979
980
981
982
983
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 { };
984
/// Call class-specific delete if it exists or global otherwise. Can also be an overload set.
985
986
987
988
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); }
989

990
inline void call_operator_delete(void *p, size_t) { ::operator delete(p); }
991

Wenzel Jakob's avatar
Wenzel Jakob committed
992
993
NAMESPACE_END(detail)

994
995
996
997
998
999
1000
1001
1002
1003
1004
/// 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; }

1005
template <typename type_, typename... options>
Wenzel Jakob's avatar
Wenzel Jakob committed
1006
class class_ : public detail::generic_type {
1007
    template <typename T> using is_holder = detail::is_holder_type<type_, T>;
1008
1009
    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_>;
1010
1011
1012
    // 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>> {};
1013

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

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

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

1026
    PYBIND11_OBJECT(class_, generic_type, PyType_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
1027

Wenzel Jakob's avatar
Wenzel Jakob committed
1028
1029
    template <typename... Extra>
    class_(handle scope, const char *name, const Extra &... extra) {
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
        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
1041
1042
1043
        record.scope = scope;
        record.name = name;
        record.type = &typeid(type);
1044
        record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
1045
        record.holder_size = sizeof(holder_type);
1046
        record.init_instance = init_instance;
Wenzel Jakob's avatar
Wenzel Jakob committed
1047
        record.dealloc = dealloc;
1048
        record.default_holder = std::is_same<holder_type, std::unique_ptr<type>>::value;
Wenzel Jakob's avatar
Wenzel Jakob committed
1049

1050
1051
        set_operator_new<type>(&record);

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

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

1058
        generic_type::initialize(record);
1059

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

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

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

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

1084
    template <typename Func, typename... Extra> class_ &
1085
1086
1087
    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");
1088
1089
        cpp_function cf(std::forward<Func>(f), name(name_), scope(*this),
                        sibling(getattr(*this, name_, none())), extra...);
1090
        attr(cf.name()) = cf;
Wenzel Jakob's avatar
Wenzel Jakob committed
1091
1092
1093
        return *this;
    }

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

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

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

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

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

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

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

1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
    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)(); });
    }

1152
    template <typename C, typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1153
    class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
1154
1155
1156
        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));
1157
        def_property(name, fget, fset, return_value_policy::reference_internal, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1158
1159
1160
        return *this;
    }

1161
    template <typename C, typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1162
    class_ &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) {
1163
1164
        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));
1165
        def_property_readonly(name, fget, return_value_policy::reference_internal, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1166
1167
1168
        return *this;
    }

1169
    template <typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1170
    class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
1171
1172
1173
        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
1174
1175
1176
        return *this;
    }

1177
    template <typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1178
    class_ &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
1179
1180
        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
1181
1182
1183
        return *this;
    }

1184
1185
1186
    /// 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) {
1187
1188
        return def_property_readonly(name, cpp_function(method_adaptor<type>(fget)),
                                     return_value_policy::reference_internal, extra...);
1189
1190
1191
    }

    /// Uses cpp_function's return_value_policy by default
1192
1193
    template <typename... Extra>
    class_ &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) {
1194
1195
1196
1197
1198
1199
1200
        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
1201
1202
    }

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

    /// Uses return_value_policy::reference_internal by default
1210
1211
1212
1213
    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...);
    }
1214
1215
    template <typename Getter, typename... Extra>
    class_ &def_property(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
1216
1217
        return def_property(name, cpp_function(method_adaptor<type>(fget)), fset,
                            return_value_policy::reference_internal, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1218
1219
    }

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

1226
1227
1228
1229
1230
1231
1232
    /// 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
1233
1234
1235
    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);
1236
        char *doc_prev = rec_fget->doc; /* 'extra' field may include a property-specific documentation string */
1237
        detail::process_attributes<Extra...>::init(extra..., rec_fget);
1238
1239
1240
1241
1242
1243
        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;
1244
            detail::process_attributes<Extra...>::init(extra..., rec_fset);
1245
1246
1247
1248
1249
            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
1250
        def_property_static_impl(name, fget, fset, rec_fget);
Wenzel Jakob's avatar
Wenzel Jakob committed
1251
1252
        return *this;
    }
1253

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

        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();
1271
        }
1272
1273
    }

1274
1275
1276
    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));
1277
1278
    }

1279
1280
1281
    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)));
1282
1283
    }

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

1296
1297
1298
1299
1300
    /// 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) {
1301
        auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
1302
1303
1304
1305
        if (!v_h.instance_registered()) {
            register_instance(inst, v_h.value_ptr(), v_h.type);
            v_h.set_instance_registered();
        }
1306
        init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
1307
1308
    }

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

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

1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
/// 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
1350
}
1351

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

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

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

1365
1366
1367
1368
1369
1370
1371
        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
1372
        });
1373
1374
1375
1376
1377
1378
        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);
1379
        def(init([](Scalar i) { return static_cast<Type>(i); }));
1380
        def("__int__", [](Type value) { return (Scalar) value; });
1381
1382
1383
        #if PY_MAJOR_VERSION < 3
            def("__long__", [](Type value) { return (Scalar) value; });
        #endif
1384
1385
        def("__eq__", [](const Type &value, Type *value2) { return value2 && value == *value2; });
        def("__ne__", [](const Type &value, Type *value2) { return !value2 || value != *value2; });
1386
1387
1388
1389
1390
1391
1392
        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) {
1393
1394
            // 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
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
            // 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; });
            }
1414
        }
1415
        def("__hash__", [](const Type &value) { return (Scalar) value; });
Wenzel Jakob's avatar
Wenzel Jakob committed
1416
        // Pickling and unpickling -- needed for use with the 'multiprocessing' module
1417
1418
        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
1419
1420
1421
    }

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

    /// Add an enumeration entry
    enum_& value(char const* name, Type value) {
1430
1431
1432
        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
1433
1434
        return *this;
    }
1435

Wenzel Jakob's avatar
Wenzel Jakob committed
1436
private:
1437
    dict m_entries;
Wenzel Jakob's avatar
Wenzel Jakob committed
1438
    handle m_parent;
Wenzel Jakob's avatar
Wenzel Jakob committed
1439
1440
1441
};

NAMESPACE_BEGIN(detail)
1442

1443

1444
inline void keep_alive_impl(handle nurse, handle patient) {
1445
    if (!nurse || !patient)
1446
        pybind11_fail("Could not activate keep_alive!");
1447

1448
    if (patient.is_none() || nurse.is_none())
1449
        return; /* Nothing to keep alive or nothing to be kept alive by */
1450

1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
    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(); });
1463

1464
        weakref wr(nurse, disable_lifesupport);
1465

1466
1467
1468
        patient.inc_ref(); /* reference patient and leak the weak reference */
        (void) wr.release();
    }
1469
1470
}

1471
PYBIND11_NOINLINE inline void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret) {
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
    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));
1483
1484
}

1485
1486
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
1487
#ifdef __cpp_lib_unordered_map_try_emplace
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
        .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;
}

1504
template <typename Iterator, typename Sentinel, bool KeyIterator, return_value_policy Policy>
1505
1506
1507
struct iterator_state {
    Iterator it;
    Sentinel end;
1508
    bool first_or_done;
1509
};
1510

Wenzel Jakob's avatar
Wenzel Jakob committed
1511
1512
NAMESPACE_END(detail)

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

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

1538
    return cast(state{first, last, true});
1539
}
1540

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

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

1567
    return cast(state{first, last, true});
1568
}
1569

1570
1571
/// Makes an iterator over values of an stl container or other container supporting
/// `std::begin()`/`std::end()`
1572
1573
1574
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...);
1575
1576
}

1577
1578
/// Makes an iterator over the keys (`.first`) of a stl map-like container supporting
/// `std::begin()`/`std::end()`
1579
1580
1581
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...);
1582
1583
}

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

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

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

1617
1618
/**
 * Wrapper to generate a new Python exception type.
1619
1620
1621
1622
1623
1624
1625
1626
 *
 * 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:
1627
1628
1629
    exception(handle scope, const char *name, PyObject *base = PyExc_Exception) {
        std::string full_name = scope.attr("__name__").cast<std::string>() +
                                std::string(".") + name;
1630
        m_ptr = PyErr_NewException(const_cast<char *>(full_name.c_str()), base, NULL);
1631
1632
1633
1634
        if (hasattr(scope, name))
            pybind11_fail("Error during initialization: multiple incompatible "
                          "definitions with name \"" + std::string(name) + "\"");
        scope.attr(name) = *this;
1635
    }
1636
1637
1638
1639
1640

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

1643
1644
/**
 * Registers a Python exception in `m` of the given `name` and installs an exception translator to
1645
1646
1647
1648
 * 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.
 */
1649
1650
1651
1652
1653
template <typename CppException>
exception<CppException> &register_exception(handle scope,
                                            const char *name,
                                            PyObject *base = PyExc_Exception) {
    static exception<CppException> ex(scope, name, base);
1654
1655
1656
1657
    register_exception_translator([](std::exception_ptr p) {
        if (!p) return;
        try {
            std::rethrow_exception(p);
1658
        } catch (const CppException &e) {
1659
1660
1661
1662
1663
1664
            ex(e.what());
        }
    });
    return ex;
}

Dean Moldovan's avatar
Dean Moldovan committed
1665
1666
1667
1668
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) {
1669
        strings[i] = str(args[i]);
Dean Moldovan's avatar
Dean Moldovan committed
1670
    }
1671
    auto sep = kwargs.contains("sep") ? kwargs["sep"] : cast(" ");
1672
    auto line = sep.attr("join")(strings);
Dean Moldovan's avatar
Dean Moldovan committed
1673

1674
1675
1676
1677
1678
1679
    object file;
    if (kwargs.contains("file")) {
        file = kwargs["file"].cast<object>();
    } else {
        try {
            file = module::import("sys").attr("stdout");
1680
        } catch (const error_already_set &) {
1681
1682
1683
1684
1685
1686
1687
1688
            /* 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;
        }
    }

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

1693
    if (kwargs.contains("flush") && kwargs["flush"].cast<bool>())
1694
        file.attr("flush")();
Dean Moldovan's avatar
Dean Moldovan committed
1695
1696
1697
1698
1699
1700
1701
1702
1703
}
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
1704
#if defined(WITH_THREAD) && !defined(PYPY_VERSION)
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718

/* 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
1719
1720
 *    thread would otherwise constantly construct and destroy thread state data
 *    structures.
1721
1722
1723
1724
1725
 *
 * 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).
1726
 */
Wenzel Jakob's avatar
Wenzel Jakob committed
1727
1728
1729

class gil_scoped_acquire {
public:
1730
    PYBIND11_NOINLINE gil_scoped_acquire() {
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
        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;
1741
1742
1743
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(internals.tstate);
            #endif
1744
1745
            PyThread_set_key_value(internals.tstate, tstate);
        } else {
1746
            release = detail::get_thread_state_unchecked() != tstate;
1747
1748
1749
1750
        }

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

        inc_ref();
    }

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

1768
    PYBIND11_NOINLINE void dec_ref() {
1769
1770
        --tstate->gilstate_counter;
        #if !defined(NDEBUG)
1771
            if (detail::get_thread_state_unchecked() != tstate)
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
                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();
1783
            PyThread_delete_key_value(detail::get_internals().tstate);
1784
1785
1786
1787
            release = false;
        }
    }

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

class gil_scoped_release {
public:
1800
    explicit gil_scoped_release(bool disassoc = false) : disassoc(disassoc) {
1801
1802
1803
1804
        // `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();
1805
        tstate = PyEval_SaveThread();
1806
        if (disassoc) {
1807
            auto key = internals.tstate;
1808
1809
1810
1811
1812
1813
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(key);
            #else
                PyThread_set_key_value(key, nullptr);
            #endif
        }
1814
1815
1816
1817
1818
    }
    ~gil_scoped_release() {
        if (!tstate)
            return;
        PyEval_RestoreThread(tstate);
1819
        if (disassoc) {
1820
            auto key = detail::get_internals().tstate;
1821
1822
1823
1824
1825
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(key);
            #endif
            PyThread_set_key_value(key, tstate);
        }
1826
1827
1828
1829
    }
private:
    PyThreadState *tstate;
    bool disassoc;
Wenzel Jakob's avatar
Wenzel Jakob committed
1830
};
Wenzel Jakob's avatar
Wenzel Jakob committed
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
#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); }
};
1845
1846
1847
#else
class gil_scoped_acquire { };
class gil_scoped_release { };
1848
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
1849

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

1859
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
1860
1861
    handle self = detail::get_object_handle(this_ptr, this_type);
    if (!self)
1862
        return function();
Wenzel Jakob's avatar
Wenzel Jakob committed
1863
    handle type = self.get_type();
1864
1865
    auto key = std::make_pair(type.ptr(), name);

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

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

Wenzel Jakob's avatar
Wenzel Jakob committed
1878
1879
1880
    /* Don't call dispatch code if invoked from overridden function.
       Unfortunately this doesn't work on PyPy. */
#if !defined(PYPY_VERSION)
1881
    PyFrameObject *frame = PyThreadState_Get()->frame;
1882
    if (frame && (std::string) str(frame->f_code->co_name) == name &&
1883
1884
1885
1886
        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
1887
        if (self_caller == self.ptr())
1888
1889
            return function();
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
#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();
1908
    if (d["self"].is_none())
Wenzel Jakob's avatar
Wenzel Jakob committed
1909
1910
1911
1912
        return function();
    Py_DECREF(result);
#endif

1913
1914
1915
    return overload;
}

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

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

1934
#define PYBIND11_OVERLOAD_NAME(ret_type, cname, name, fn, ...) \
1935
    PYBIND11_OVERLOAD_INT(ret_type, cname, name, __VA_ARGS__) \
1936
    return cname::fn(__VA_ARGS__)
1937

1938
#define PYBIND11_OVERLOAD_PURE_NAME(ret_type, cname, name, fn, ...) \
1939
    PYBIND11_OVERLOAD_INT(ret_type, cname, name, __VA_ARGS__) \
1940
1941
1942
1943
1944
1945
1946
    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__)
1947

1948
NAMESPACE_END(PYBIND11_NAMESPACE)
Wenzel Jakob's avatar
Wenzel Jakob committed
1949
1950

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