pybind11.h 82.3 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
25
26
#  pragma warning(disable: 186)   // pointless comparison of unsigned integer with zero
#  pragma warning(disable: 1334)  // the "template" keyword used for syntactic disambiguation may only be used within a template
#  pragma warning(disable: 2196)  // warning #2196: routine is both "inline" and "noinline"
27
#elif defined(__GNUG__) && !defined(__clang__)
Wenzel Jakob's avatar
Wenzel Jakob committed
28
29
30
31
#  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
32
33
#  pragma GCC diagnostic ignored "-Wstrict-aliasing"
#  pragma GCC diagnostic ignored "-Wattributes"
Wenzel Jakob's avatar
Wenzel Jakob committed
34
35
#endif

Wenzel Jakob's avatar
Wenzel Jakob committed
36
#include "attr.h"
37
#include "options.h"
Wenzel Jakob's avatar
Wenzel Jakob committed
38

39
NAMESPACE_BEGIN(pybind11)
Wenzel Jakob's avatar
Wenzel Jakob committed
40

Wenzel Jakob's avatar
Wenzel Jakob committed
41
/// Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object
42
class cpp_function : public function {
Wenzel Jakob's avatar
Wenzel Jakob committed
43
public:
44
    cpp_function() { }
Wenzel Jakob's avatar
Wenzel Jakob committed
45

46
    /// Construct a cpp_function from a vanilla function pointer
47
48
    template <typename Return, typename... Args, typename... Extra /*,*/ PYBIND11_NOEXCEPT_TPL_ARG>
    cpp_function(Return (*f)(Args...) PYBIND11_NOEXCEPT_SPECIFIER, const Extra&... extra) {
49
        initialize(f, f, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
50
51
    }

52
    /// Construct a cpp_function from a lambda function (possibly with internal state)
53
    template <typename Func, typename... Extra> cpp_function(Func &&f, const Extra&... extra) {
54
        initialize(std::forward<Func>(f),
Wenzel Jakob's avatar
Wenzel Jakob committed
55
                   (typename detail::remove_class<decltype(
Wenzel Jakob's avatar
Wenzel Jakob committed
56
                       &std::remove_reference<Func>::type::operator())>::type *) nullptr, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
57
58
    }

59
    /// Construct a cpp_function from a class method (non-const)
60
61
    template <typename Return, typename Class, typename... Arg, typename... Extra /*,*/ PYBIND11_NOEXCEPT_TPL_ARG>
    cpp_function(Return (Class::*f)(Arg...) PYBIND11_NOEXCEPT_SPECIFIER, const Extra&... extra) {
62
        initialize([f](Class *c, Arg... args) -> Return { return (c->*f)(args...); },
63
                   (Return (*) (Class *, Arg...) PYBIND11_NOEXCEPT_SPECIFIER) nullptr, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
64
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
65

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

73
    /// Return the function name
Wenzel Jakob's avatar
Wenzel Jakob committed
74
    object name() const { return attr("__name__"); }
75

76
protected:
77
78
79
80
81
    /// Space optimization: don't inline this frequently instantiated fragment
    PYBIND11_NOINLINE detail::function_record *make_function_record() {
        return new detail::function_record();
    }

82
    /// Special internal constructor for functors, lambda functions, etc.
83
84
    template <typename Func, typename Return, typename... Args, typename... Extra /*,*/ PYBIND11_NOEXCEPT_TPL_ARG>
    void initialize(Func &&f, Return (*)(Args...) PYBIND11_NOEXCEPT_SPECIFIER, const Extra&... extra) {
85

86
        struct capture { typename std::remove_reference<Func>::type f; };
Wenzel Jakob's avatar
Wenzel Jakob committed
87

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

91
92
        /* Store the capture object directly in the function record if there is enough space */
        if (sizeof(capture) <= sizeof(rec->data)) {
93
94
95
            /* 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. */
96
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
97
98
99
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wplacement-new"
#endif
100
            new ((capture *) &rec->data) capture { std::forward<Func>(f) };
101
#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
102
103
#  pragma GCC diagnostic pop
#endif
104
105
106
107
108
109
            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]); };
        }
110

111
        /* Type casters for the function arguments and return value */
112
113
114
115
        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
116

117
118
119
        static_assert(detail::expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
                      "The number of named arguments does not match the function signature");

120
        /* Dispatch code which converts function arguments and performs the actual function call */
121
        rec->impl = [](detail::function_call &call) -> handle {
122
            cast_in args_converter;
123
124

            /* Try to cast the function arguments into the C++ domain */
125
            if (!args_converter.load_args(call.args))
126
127
                return PYBIND11_TRY_NEXT_OVERLOAD;

Wenzel Jakob's avatar
Wenzel Jakob committed
128
            /* Invoke call policy pre-call hook */
129
            detail::process_attributes<Extra...>::precall(call);
130
131

            /* Get a pointer to the capture object */
132
133
            capture *cap = (capture *) (sizeof(capture) <= sizeof(call.func.data)
                                        ? &call.func.data : call.func.data[0]);
134

135
136
137
            /* Override policy for rvalues -- always move */
            constexpr auto is_rvalue = !std::is_pointer<Return>::value
                                       && !std::is_lvalue_reference<Return>::value;
138
            const auto policy = is_rvalue ? return_value_policy::move : call.func.policy;
139

140
            /* Perform the function call */
141
            handle result = cast_out::cast(args_converter.template call<Return>(cap->f),
142
                                           policy, call.parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
143
144

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

147
            return result;
Wenzel Jakob's avatar
Wenzel Jakob committed
148
149
        };

Wenzel Jakob's avatar
Wenzel Jakob committed
150
151
        /* Process any user-provided function attributes */
        detail::process_attributes<Extra...>::init(extra..., rec);
152
153

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

        /* Register the function with Python from generic (non-templated) code */
158
        initialize_generic(rec, signature.text(), signature.types(), sizeof...(Args));
159
160
161

        if (cast_in::has_args) rec->has_args = true;
        if (cast_in::has_kwargs) rec->has_kwargs = true;
162
163

        /* Stash some additional information used by an important optimization in 'functional.h' */
164
        using FunctionType = Return (*)(Args...) PYBIND11_NOEXCEPT_SPECIFIER;
165
166
167
168
169
170
171
        constexpr bool is_function_ptr =
            std::is_convertible<Func, FunctionType>::value &&
            sizeof(capture) == sizeof(void *);
        if (is_function_ptr) {
            rec->is_stateless = true;
            rec->data[1] = (void *) &typeid(FunctionType);
        }
172
173
    }

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

178
        /* Create copies of all referenced C-style strings */
Wenzel Jakob's avatar
Wenzel Jakob committed
179
180
181
        rec->name = strdup(rec->name ? rec->name : "");
        if (rec->doc) rec->doc = strdup(rec->doc);
        for (auto &a: rec->args) {
182
183
184
185
186
            if (a.name)
                a.name = strdup(a.name);
            if (a.descr)
                a.descr = strdup(a.descr);
            else if (a.value)
187
                a.descr = strdup(a.value.attr("__repr__")().cast<std::string>().c_str());
188
        }
189

190
191
192
193
194
195
196
197
198
        /* Generate a proper function signature */
        std::string signature;
        size_t type_depth = 0, char_index = 0, type_index = 0, arg_index = 0;
        while (true) {
            char c = text[char_index++];
            if (c == '\0')
                break;

            if (c == '{') {
199
                // Write arg name for everything except *args, **kwargs and return type.
200
                if (type_depth == 0 && text[char_index] != '*' && arg_index < args) {
201
202
                    if (!rec->args.empty()) {
                        signature += rec->args[arg_index].name;
203
                    } else if (arg_index == 0 && rec->is_method) {
204
205
                        signature += "self";
                    } else {
206
                        signature += "arg" + std::to_string(arg_index - (rec->is_method ? 1 : 0));
207
208
                    }
                    signature += ": ";
209
210
211
212
                }
                ++type_depth;
            } else if (c == '}') {
                --type_depth;
213
                if (type_depth == 0) {
214
215
                    if (arg_index < rec->args.size() && rec->args[arg_index].descr) {
                        signature += "=";
Wenzel Jakob's avatar
Wenzel Jakob committed
216
                        signature += rec->args[arg_index].descr;
217
218
219
220
221
                    }
                    arg_index++;
                }
            } else if (c == '%') {
                const std::type_info *t = types[type_index++];
222
                if (!t)
223
                    pybind11_fail("Internal error while parsing type signature (1)");
224
                if (auto tinfo = detail::get_type_info(*t)) {
Wenzel Jakob's avatar
Wenzel Jakob committed
225
226
227
228
229
#if defined(PYPY_VERSION)
                    signature += handle((PyObject *) tinfo->type)
                                     .attr("__module__")
                                     .cast<std::string>() + ".";
#endif
230
                    signature += tinfo->type->tp_name;
231
232
233
234
235
236
237
238
239
                } else {
                    std::string tname(t->name());
                    detail::clean_type_id(tname);
                    signature += tname;
                }
            } else {
                signature += c;
            }
        }
240
        if (type_depth != 0 || types[type_index] != nullptr)
241
            pybind11_fail("Internal error while parsing type signature (2)");
242
243
244
245
246

        #if !defined(PYBIND11_CPP14)
            delete[] types;
            delete[] text;
        #endif
247

248
#if PY_MAJOR_VERSION < 3
Wenzel Jakob's avatar
Wenzel Jakob committed
249
250
251
        if (strcmp(rec->name, "__next__") == 0) {
            std::free(rec->name);
            rec->name = strdup("next");
252
253
254
        } else if (strcmp(rec->name, "__bool__") == 0) {
            std::free(rec->name);
            rec->name = strdup("__nonzero__");
255
        }
256
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
257
258
        rec->signature = strdup(signature.c_str());
        rec->args.shrink_to_fit();
259
        rec->is_constructor = !strcmp(rec->name, "__init__") || !strcmp(rec->name, "__setstate__");
260
        rec->nargs = (uint16_t) args;
261
262

#if PY_MAJOR_VERSION < 3
Wenzel Jakob's avatar
Wenzel Jakob committed
263
264
        if (rec->sibling && PyMethod_Check(rec->sibling.ptr()))
            rec->sibling = PyMethod_GET_FUNCTION(rec->sibling.ptr());
265
#endif
266

Wenzel Jakob's avatar
Wenzel Jakob committed
267
        detail::function_record *chain = nullptr, *chain_start = rec;
268
269
        if (rec->sibling) {
            if (PyCFunction_Check(rec->sibling.ptr())) {
Wenzel Jakob's avatar
Wenzel Jakob committed
270
                auto rec_capsule = reinterpret_borrow<capsule>(PyCFunction_GET_SELF(rec->sibling.ptr()));
271
272
273
                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 */
274
                if (chain->scope != rec->scope)
275
276
277
278
279
280
                    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");
281
282
        }

Wenzel Jakob's avatar
Wenzel Jakob committed
283
        if (!chain) {
284
            /* No existing overload was found, create a new function object */
Wenzel Jakob's avatar
Wenzel Jakob committed
285
286
287
288
289
            rec->def = new PyMethodDef();
            memset(rec->def, 0, sizeof(PyMethodDef));
            rec->def->ml_name = rec->name;
            rec->def->ml_meth = reinterpret_cast<PyCFunction>(*dispatcher);
            rec->def->ml_flags = METH_VARARGS | METH_KEYWORDS;
290

Wenzel Jakob's avatar
Wenzel Jakob committed
291
292
            capsule rec_capsule(rec, [](PyObject *o) {
                destruct((detail::function_record *) PyCapsule_GetPointer(o, nullptr));
293
            });
294
295
296

            object scope_module;
            if (rec->scope) {
297
298
299
300
301
                if (hasattr(rec->scope, "__module__")) {
                    scope_module = rec->scope.attr("__module__");
                } else if (hasattr(rec->scope, "__name__")) {
                    scope_module = rec->scope.attr("__name__");
                }
302
303
304
            }

            m_ptr = PyCFunction_NewEx(rec->def, rec_capsule.ptr(), scope_module.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
305
            if (!m_ptr)
306
                pybind11_fail("cpp_function::cpp_function(): Could not allocate function object");
Wenzel Jakob's avatar
Wenzel Jakob committed
307
        } else {
308
            /* Append at the end of the overload chain */
Wenzel Jakob's avatar
Wenzel Jakob committed
309
            m_ptr = rec->sibling.ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
310
            inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
311
312
313
314
            chain_start = chain;
            while (chain->next)
                chain = chain->next;
            chain->next = rec;
Wenzel Jakob's avatar
Wenzel Jakob committed
315
        }
316

Wenzel Jakob's avatar
Wenzel Jakob committed
317
        std::string signatures;
318
        int index = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
319
        /* Create a nice pydoc rec including all signatures and
320
           docstrings of the functions in the overload chain */
321
        if (chain && options::show_function_signatures()) {
322
323
324
325
326
327
            // First a generic signature
            signatures += rec->name;
            signatures += "(*args, **kwargs)\n";
            signatures += "Overloaded function.\n\n";
        }
        // Then specific overload signatures
Wenzel Jakob's avatar
Wenzel Jakob committed
328
        for (auto it = chain_start; it != nullptr; it = it->next) {
329
330
331
332
333
            if (options::show_function_signatures()) {
                if (chain)
                    signatures += std::to_string(++index) + ". ";
                signatures += rec->name;
                signatures += it->signature;
334
                signatures += "\n";
335
336
337
            }
            if (it->doc && strlen(it->doc) > 0 && options::show_user_defined_docstrings()) {
                if (options::show_function_signatures()) signatures += "\n";
338
                signatures += it->doc;
339
                if (options::show_function_signatures()) signatures += "\n";
340
            }
341
            if (it->next)
Wenzel Jakob's avatar
Wenzel Jakob committed
342
343
                signatures += "\n";
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
344
345

        /* Install docstring */
Wenzel Jakob's avatar
Wenzel Jakob committed
346
347
        PyCFunctionObject *func = (PyCFunctionObject *) m_ptr;
        if (func->m_ml->ml_doc)
348
            std::free((char *) func->m_ml->ml_doc);
Wenzel Jakob's avatar
Wenzel Jakob committed
349
        func->m_ml->ml_doc = strdup(signatures.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
350

351
352
        if (rec->is_method) {
            m_ptr = PYBIND11_INSTANCE_METHOD_NEW(m_ptr, rec->scope.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
353
            if (!m_ptr)
354
                pybind11_fail("cpp_function::cpp_function(): Could not allocate instance method object");
Wenzel Jakob's avatar
Wenzel Jakob committed
355
356
357
            Py_DECREF(func);
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
358
359
360
361
362
363

    /// 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)
364
                rec->free_data(rec);
Wenzel Jakob's avatar
Wenzel Jakob committed
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
            std::free((char *) rec->name);
            std::free((char *) rec->doc);
            std::free((char *) rec->signature);
            for (auto &arg: rec->args) {
                std::free((char *) arg.name);
                std::free((char *) arg.descr);
                arg.value.dec_ref();
            }
            if (rec->def) {
                std::free((char *) rec->def->ml_doc);
                delete rec->def;
            }
            delete rec;
            rec = next;
        }
    }

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

Wenzel Jakob's avatar
Wenzel Jakob committed
386
        /* Iterator over the list of potentially admissible overloads */
387
388
        function_record *overloads = (function_record *) PyCapsule_GetPointer(self, nullptr),
                        *it = overloads;
Wenzel Jakob's avatar
Wenzel Jakob committed
389
390

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

393
        handle parent = n_args_in > 0 ? PyTuple_GET_ITEM(args_in, 0) : nullptr,
Wenzel Jakob's avatar
Wenzel Jakob committed
394
395
396
397
               result = PYBIND11_TRY_NEXT_OVERLOAD;
        try {
            for (; it != nullptr; it = it->next) {
                /* For each overload:
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
                   1. Copy all positional arguments we were given, also checking to make sure that
                      named positional arguments weren't *also* specified via kwarg.
                   2. If we weren't given enough, try to make up the ommitted ones by checking
                      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
414
415
                 */

416
417
418
419
                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
420

421
                if (!func.has_args && n_args_in > pos_args)
422
423
                    continue; // Too many arguments for this overload

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

427
                function_call call(func, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
428

429
430
431
432
433
434
435
436
437
438
439
                size_t args_to_copy = std::min(pos_args, n_args_in);
                size_t args_copied = 0;

                // 1. Copy any position arguments given.
                for (; args_copied < args_to_copy; ++args_copied) {
                    // If we find a given positional argument that also has a named kwargs argument,
                    // raise a TypeError like Python does.  (We could also continue with the next
                    // overload, but this seems highly likely to be a caller mistake rather than a
                    // legitimate overload).
                    if (kwargs_in && args_copied < it->args.size()) {
                        handle value = PyDict_GetItemString(kwargs_in, it->args[args_copied].name);
Wenzel Jakob's avatar
Wenzel Jakob committed
440
                        if (value)
441
442
443
444
                            throw type_error(std::string(it->name) + "(): got multiple values for argument '" +
                                    std::string(it->args[args_copied].name) + "'");
                    }

445
                    call.args.push_back(PyTuple_GET_ITEM(args_in, args_copied));
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
                }

                // 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) {
                        const auto &arg = it->args[args_copied];

                        handle value;
                        if (kwargs_in)
                            value = PyDict_GetItemString(kwargs.ptr(), arg.name);
Wenzel Jakob's avatar
Wenzel Jakob committed
461
462

                        if (value) {
463
464
465
466
467
468
469
470
471
472
473
474
                            // Consume a kwargs value
                            if (!copied_kwargs) {
                                kwargs = reinterpret_steal<dict>(PyDict_Copy(kwargs.ptr()));
                                copied_kwargs = true;
                            }
                            PyDict_DelItemString(kwargs.ptr(), arg.name);
                        }
                        else if (arg.value) {
                            value = arg.value;
                        }

                        if (value)
475
                            call.args.push_back(value);
476
                        else
Wenzel Jakob's avatar
Wenzel Jakob committed
477
                            break;
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
                    }

                    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)
                if (kwargs && kwargs.size() > 0 && !it->has_kwargs)
                    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;
                if (it->has_args) {
                    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);
                    }
                    else if (args_copied >= n_args_in) {
                        extra_args = tuple(0);
                    }
                    else {
                        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
505
506
                        }
                    }
507
                    call.args.push_back(extra_args);
Wenzel Jakob's avatar
Wenzel Jakob committed
508
                }
509

510
511
512
513
                // 4b. If we have a py::kwargs, pass on any remaining kwargs
                if (it->has_kwargs) {
                    if (!kwargs.ptr())
                        kwargs = dict(); // If we didn't get one, send an empty one
514
                    call.args.push_back(kwargs);
515
516
                }

517
518
519
520
521
522
                // 5. Put everything in a vector.  Not technically step 5, we've been building it
                // in `call.args` all along.
                #if !defined(NDEBUG)
                if (call.args.size() != call.func.nargs)
                    pybind11_fail("Internal error: function call dispatcher inserted wrong number of arguments!");
                #endif
523
524

                // 6. Call the function.
525
                try {
526
                    result = it->impl(call);
527
                } catch (reference_cast_error &) {
528
529
                    result = PYBIND11_TRY_NEXT_OVERLOAD;
                }
Wenzel Jakob's avatar
Wenzel Jakob committed
530
531
532
533

                if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD)
                    break;
            }
534
535
        } catch (error_already_set &e) {
            e.restore();
536
            return nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
537
        } catch (...) {
538
539
540
            /* When an exception is caught, give each registered exception
               translator a chance to translate it to a Python exception
               in reverse order of registration.
541

542
               A translator may choose to do one of the following:
543

544
545
546
547
548
                - 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. */

549
            auto last_exception = std::current_exception();
550
            auto &registered_exception_translators = get_internals().registered_exception_translators;
551
552
553
554
555
556
557
558
559
560
            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
561
562
563
564
            return nullptr;
        }

        if (result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) {
565
566
567
            if (overloads->is_operator)
                return handle(Py_NotImplemented).inc_ref().ptr();

568
569
570
571
            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
572
            int ctr = 0;
573
            for (function_record *it2 = overloads; it2 != nullptr; it2 = it2->next) {
Wenzel Jakob's avatar
Wenzel Jakob committed
574
                msg += "    "+ std::to_string(++ctr) + ". ";
575
576
577

                bool wrote_sig = false;
                if (overloads->is_constructor) {
578
                    // For a constructor, rewrite `(self: Object, arg0, ...) -> NoneType` as `Object(arg0, ...)`
579
                    std::string sig = it2->signature;
580
                    size_t start = sig.find('(') + 7; // skip "(self: "
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
                    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
597
598
                msg += "\n";
            }
599
            msg += "\nInvoked with: ";
600
            auto args_ = reinterpret_borrow<tuple>(args_in);
601
            for (size_t ti = overloads->is_constructor ? 1 : 0; ti < args_.size(); ++ti) {
602
                msg += pybind11::repr(args_[ti]);
603
604
605
                if ((ti + 1) != args_.size() )
                    msg += ", ";
            }
Wenzel Jakob's avatar
Wenzel Jakob committed
606
607
608
609
610
611
612
613
614
615
            PyErr_SetString(PyExc_TypeError, msg.c_str());
            return nullptr;
        } else if (!result) {
            std::string msg = "Unable to convert function return value to a "
                              "Python type! The signature was\n\t";
            msg += it->signature;
            PyErr_SetString(PyExc_TypeError, msg.c_str());
            return nullptr;
        } else {
            if (overloads->is_constructor) {
616
                /* When a constructor ran successfully, the corresponding
Wenzel Jakob's avatar
Wenzel Jakob committed
617
                   holder type (e.g. std::unique_ptr) must still be initialized. */
618
                auto tinfo = get_type_info(Py_TYPE(parent.ptr()));
619
                tinfo->init_holder(parent.ptr(), nullptr);
Wenzel Jakob's avatar
Wenzel Jakob committed
620
621
622
623
            }
            return result.ptr();
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
624
625
};

626
/// Wrapper for Python extension modules
Wenzel Jakob's avatar
Wenzel Jakob committed
627
628
class module : public object {
public:
629
    PYBIND11_OBJECT_DEFAULT(module, object, PyModule_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
630

631
    /// Create a new top-level Python module with the given name and docstring
632
    explicit module(const char *name, const char *doc = nullptr) {
633
        if (!options::show_user_defined_docstrings()) doc = nullptr;
634
#if PY_MAJOR_VERSION >= 3
Wenzel Jakob's avatar
Wenzel Jakob committed
635
636
637
638
639
640
641
        PyModuleDef *def = new PyModuleDef();
        memset(def, 0, sizeof(PyModuleDef));
        def->m_name = name;
        def->m_doc = doc;
        def->m_size = -1;
        Py_INCREF(def);
        m_ptr = PyModule_Create(def);
642
643
644
#else
        m_ptr = Py_InitModule3(name, nullptr, doc);
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
645
        if (m_ptr == nullptr)
646
            pybind11_fail("Internal error in module::module()");
Wenzel Jakob's avatar
Wenzel Jakob committed
647
648
649
        inc_ref();
    }

650
651
652
653
654
    /** \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 */
655
    template <typename Func, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
656
    module &def(const char *name_, Func &&f, const Extra& ... extra) {
657
658
        cpp_function func(std::forward<Func>(f), name(name_), scope(*this),
                          sibling(getattr(*this, name_, none())), extra...);
659
660
661
        // 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
662
663
664
        return *this;
    }

665
666
667
668
669
670
671
672
673
674
    /** \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 */
675
    module def_submodule(const char *name, const char *doc = nullptr) {
Wenzel Jakob's avatar
Wenzel Jakob committed
676
677
        std::string full_name = std::string(PyModule_GetName(m_ptr))
            + std::string(".") + std::string(name);
678
        auto result = reinterpret_borrow<module>(PyImport_AddModule(full_name.c_str()));
679
        if (doc && options::show_user_defined_docstrings())
680
            result.attr("__doc__") = pybind11::str(doc);
Wenzel Jakob's avatar
Wenzel Jakob committed
681
682
683
        attr(name) = result;
        return result;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
684

685
    /// Import and return a module or throws `error_already_set`.
Wenzel Jakob's avatar
Wenzel Jakob committed
686
    static module import(const char *name) {
687
688
        PyObject *obj = PyImport_ImportModule(name);
        if (!obj)
689
            throw error_already_set();
690
        return reinterpret_steal<module>(obj);
Wenzel Jakob's avatar
Wenzel Jakob committed
691
    }
692
693
694
695
696
697
698
699
700
701
702
703
704
705

    // 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.
    PYBIND11_NOINLINE void add_object(const char *name, object &obj, bool overwrite = false) {
        if (!overwrite && hasattr(*this, name))
            pybind11_fail("Error during initialization: multiple incompatible definitions with name \"" +
                    std::string(name) + "\"");

        obj.inc_ref(); // PyModule_AddObject() steals a reference
        PyModule_AddObject(ptr(), name, obj.ptr());
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
706
707
708
};

NAMESPACE_BEGIN(detail)
Dean Moldovan's avatar
Dean Moldovan committed
709
extern "C" inline PyObject *get_dict(PyObject *op, void *) {
710
    PyObject *&dict = *_PyObject_GetDictPtr(op);
Wenzel Jakob's avatar
Wenzel Jakob committed
711
    if (!dict)
712
713
714
        dict = PyDict_New();
    Py_XINCREF(dict);
    return dict;
Dean Moldovan's avatar
Dean Moldovan committed
715
716
}

717
718
extern "C" inline int set_dict(PyObject *op, PyObject *new_dict, void *) {
    if (!PyDict_Check(new_dict)) {
Dean Moldovan's avatar
Dean Moldovan committed
719
        PyErr_Format(PyExc_TypeError, "__dict__ must be set to a dictionary, not a '%.200s'",
720
                     Py_TYPE(new_dict)->tp_name);
Dean Moldovan's avatar
Dean Moldovan committed
721
722
        return -1;
    }
723
724
725
726
    PyObject *&dict = *_PyObject_GetDictPtr(op);
    Py_INCREF(new_dict);
    Py_CLEAR(dict);
    dict = new_dict;
Dean Moldovan's avatar
Dean Moldovan committed
727
728
729
730
731
732
733
734
    return 0;
}

static PyGetSetDef generic_getset[] = {
    {const_cast<char*>("__dict__"), get_dict, set_dict, nullptr, nullptr},
    {nullptr, nullptr, nullptr, nullptr, nullptr}
};

Wenzel Jakob's avatar
Wenzel Jakob committed
735
/// Generic support for creating new Python heap types
736
class generic_type : public object {
737
    template <typename...> friend class class_;
Wenzel Jakob's avatar
Wenzel Jakob committed
738
public:
739
    PYBIND11_OBJECT_DEFAULT(generic_type, object, PyType_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
740
741
protected:
    void initialize(type_record *rec) {
742
743
744
        auto &internals = get_internals();
        auto tindex = std::type_index(*(rec->type));

745
        if (get_type_info(*(rec->type)))
746
747
748
            pybind11_fail("generic_type: type \"" + std::string(rec->name) +
                          "\" is already registered!");

749
        auto name = reinterpret_steal<object>(PYBIND11_FROM_STRING(rec->name));
750
751
        object scope_module;
        if (rec->scope) {
752
753
754
755
            if (hasattr(rec->scope, rec->name))
                pybind11_fail("generic_type: cannot initialize type \"" + std::string(rec->name) +
                        "\": an object with that name is already defined");

756
757
758
759
760
            if (hasattr(rec->scope, "__module__")) {
                scope_module = rec->scope.attr("__module__");
            } else if (hasattr(rec->scope, "__name__")) {
                scope_module = rec->scope.attr("__name__");
            }
761
762
763
764
765
        }

#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
        /* Qualified names for Python >= 3.3 */
        object scope_qualname;
766
767
        if (rec->scope && hasattr(rec->scope, "__qualname__"))
            scope_qualname = rec->scope.attr("__qualname__");
Wenzel Jakob's avatar
Wenzel Jakob committed
768
769
        object ht_qualname, ht_qualname_meta;
        if (scope_qualname)
770
771
            ht_qualname = reinterpret_steal<object>(PyUnicode_FromFormat(
                "%U.%U", scope_qualname.ptr(), name.ptr()));
Wenzel Jakob's avatar
Wenzel Jakob committed
772
        else
773
            ht_qualname = name;
Wenzel Jakob's avatar
Wenzel Jakob committed
774
775
776
        if (rec->metaclass)
            ht_qualname_meta = reinterpret_steal<object>(
                PyUnicode_FromFormat("%U__Meta", ht_qualname.ptr()));
777
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
778

Wenzel Jakob's avatar
Wenzel Jakob committed
779
#if !defined(PYPY_VERSION)
780
        std::string full_name = (scope_module ? ((std::string) pybind11::str(scope_module) + "." + rec->name)
781
                                              : std::string(rec->name));
Wenzel Jakob's avatar
Wenzel Jakob committed
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
#else
        std::string full_name = std::string(rec->name);
#endif

        /* Create a custom metaclass if requested (used for static properties) */
        object metaclass;
        if (rec->metaclass) {
            std::string meta_name_ = full_name + "__Meta";
            object meta_name = reinterpret_steal<object>(PYBIND11_FROM_STRING(meta_name_.c_str()));
            metaclass = reinterpret_steal<object>(PyType_Type.tp_alloc(&PyType_Type, 0));
            if (!metaclass || !name)
                pybind11_fail("generic_type::generic_type(): unable to create metaclass!");

            /* Danger zone: from now (and until PyType_Ready), make sure to
               issue no Python C API calls which could potentially invoke the
               garbage collector (the GC will call type_traverse(), which will in
               turn find the newly constructed type in an invalid state) */

            auto type = (PyHeapTypeObject*) metaclass.ptr();
            type->ht_name = meta_name.release().ptr();

#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
            /* Qualified names for Python >= 3.3 */
805
            type->ht_qualname = ht_qualname_meta.release().ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
806
807
808
809
810
811
812
813
814
815
816
817
#endif
            type->ht_type.tp_name = strdup(meta_name_.c_str());
            type->ht_type.tp_base = &PyType_Type;
            type->ht_type.tp_flags |= (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE) &
                                      ~Py_TPFLAGS_HAVE_GC;

            if (PyType_Ready(&type->ht_type) < 0)
                pybind11_fail("generic_type::generic_type(): failure in PyType_Ready() for metaclass!");
        }

        size_t num_bases = rec->bases.size();
        auto bases = tuple(rec->bases);
818
819

        char *tp_doc = nullptr;
820
        if (rec->doc && options::show_user_defined_docstrings()) {
821
822
823
824
825
826
827
            /* Allocate memory for docstring (using PyObject_MALLOC, since
               Python will free this later on) */
            size_t size = strlen(rec->doc) + 1;
            tp_doc = (char *) PyObject_MALLOC(size);
            memcpy((void *) tp_doc, rec->doc, size);
        }

Wenzel Jakob's avatar
Wenzel Jakob committed
828
829
830
831
832
        /* Danger zone: from now (and until PyType_Ready), make sure to
           issue no Python C API calls which could potentially invoke the
           garbage collector (the GC will call type_traverse(), which will in
           turn find the newly constructed type in an invalid state) */

833
        auto type_holder = reinterpret_steal<object>(PyType_Type.tp_alloc(&PyType_Type, 0));
834
835
836
        auto type = (PyHeapTypeObject*) type_holder.ptr();

        if (!type_holder || !name)
837
            pybind11_fail(std::string(rec->name) + ": Unable to create type object!");
838
839
840
841

        /* Register supplemental type information in C++ dict */
        detail::type_info *tinfo = new detail::type_info();
        tinfo->type = (PyTypeObject *) type;
Wenzel Jakob's avatar
Wenzel Jakob committed
842
843
        tinfo->type_size = rec->type_size;
        tinfo->init_holder = rec->init_holder;
844
        tinfo->direct_conversions = &internals.direct_conversions[tindex];
845
        tinfo->default_holder = rec->default_holder;
846
        internals.registered_types_cpp[tindex] = tinfo;
847
848
849
850
        internals.registered_types_py[type] = tinfo;

        /* Basic type attributes */
        type->ht_type.tp_name = strdup(full_name.c_str());
851
        type->ht_type.tp_basicsize = (ssize_t) rec->instance_size;
Wenzel Jakob's avatar
Wenzel Jakob committed
852
853
854
855
856
857

        if (num_bases > 0) {
            type->ht_type.tp_base = (PyTypeObject *) ((object) bases[0]).inc_ref().ptr();
            type->ht_type.tp_bases = bases.release().ptr();
            rec->multiple_inheritance |= num_bases > 1;
        }
858

859
860
        type->ht_name = name.release().ptr();

861
#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
862
        type->ht_qualname = ht_qualname.release().ptr();
863
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
864

Wenzel Jakob's avatar
Wenzel Jakob committed
865
866
867
        /* Metaclass */
        PYBIND11_OB_TYPE(type->ht_type) = (PyTypeObject *) metaclass.release().ptr();

868
869
870
871
        /* Supported protocols */
        type->ht_type.tp_as_number = &type->as_number;
        type->ht_type.tp_as_sequence = &type->as_sequence;
        type->ht_type.tp_as_mapping = &type->as_mapping;
Wenzel Jakob's avatar
Wenzel Jakob committed
872

873
        /* Supported elementary operations */
Wenzel Jakob's avatar
Wenzel Jakob committed
874
875
        type->ht_type.tp_init = (initproc) init;
        type->ht_type.tp_new = (newfunc) new_instance;
Wenzel Jakob's avatar
Wenzel Jakob committed
876
        type->ht_type.tp_dealloc = rec->dealloc;
877
878

        /* Support weak references (needed for the keep_alive feature) */
879
        type->ht_type.tp_weaklistoffset = offsetof(instance_essentials<void>, weakrefs);
880
881
882

        /* Flags */
        type->ht_type.tp_flags |= Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
883
884
885
#if PY_MAJOR_VERSION < 3
        type->ht_type.tp_flags |= Py_TPFLAGS_CHECKTYPES;
#endif
886
        type->ht_type.tp_flags &= ~Py_TPFLAGS_HAVE_GC;
887

Dean Moldovan's avatar
Dean Moldovan committed
888
889
        /* Support dynamic attributes */
        if (rec->dynamic_attr) {
890
891
892
893
894
            #if defined(PYPY_VERSION)
                pybind11_fail(std::string(rec->name) + ": dynamic attributes are "
                                                       "currently not supported in "
                                                       "conunction with PyPy!");
            #endif
Dean Moldovan's avatar
Dean Moldovan committed
895
            type->ht_type.tp_flags |= Py_TPFLAGS_HAVE_GC;
896
897
            type->ht_type.tp_dictoffset = type->ht_type.tp_basicsize; // place the dict at the end
            type->ht_type.tp_basicsize += sizeof(PyObject *); // and allocate enough space for it
Dean Moldovan's avatar
Dean Moldovan committed
898
899
900
901
902
            type->ht_type.tp_getset = generic_getset;
            type->ht_type.tp_traverse = traverse;
            type->ht_type.tp_clear = clear;
        }

Wenzel Jakob's avatar
Wenzel Jakob committed
903
904
905
906
907
908
909
910
911
        if (rec->buffer_protocol) {
            type->ht_type.tp_as_buffer = &type->as_buffer;
#if PY_MAJOR_VERSION < 3
            type->ht_type.tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER;
#endif
            type->as_buffer.bf_getbuffer = getbuffer;
            type->as_buffer.bf_releasebuffer = releasebuffer;
        }

912
        type->ht_type.tp_doc = tp_doc;
Wenzel Jakob's avatar
Wenzel Jakob committed
913

Wenzel Jakob's avatar
Wenzel Jakob committed
914
915
        m_ptr = type_holder.ptr();

Wenzel Jakob's avatar
Wenzel Jakob committed
916
        if (PyType_Ready(&type->ht_type) < 0)
917
918
            pybind11_fail(std::string(rec->name) + ": PyType_Ready failed (" +
                          detail::error_string() + ")!");
919
920

        if (scope_module) // Needed by pydoc
Wenzel Jakob's avatar
Wenzel Jakob committed
921
            attr("__module__") = scope_module;
Wenzel Jakob's avatar
Wenzel Jakob committed
922

923
        /* Register type with the parent scope */
924
925
        if (rec->scope)
            rec->scope.attr(handle(type->ht_name)) = *this;
Wenzel Jakob's avatar
Wenzel Jakob committed
926

Wenzel Jakob's avatar
Wenzel Jakob committed
927
928
929
        if (rec->multiple_inheritance)
            mark_parents_nonsimple(&type->ht_type);

930
        type_holder.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
931
932
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
933
934
    /// Helper function which tags all parents of a type using mult. inheritance
    void mark_parents_nonsimple(PyTypeObject *value) {
935
        auto t = reinterpret_borrow<tuple>(value->tp_bases);
Wenzel Jakob's avatar
Wenzel Jakob committed
936
937
938
939
940
941
942
943
        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
944
    static int init(void *self, PyObject *, PyObject *) {
Wenzel Jakob's avatar
Wenzel Jakob committed
945
946
947
948
949
950
951
        PyTypeObject *type = Py_TYPE(self);
        std::string msg;
#if defined(PYPY_VERSION)
        msg += handle((PyObject *) type).attr("__module__").cast<std::string>() + ".";
#endif
        msg += type->tp_name;
        msg += ": No constructor defined!";
Wenzel Jakob's avatar
Wenzel Jakob committed
952
953
954
955
956
        PyErr_SetString(PyExc_TypeError, msg.c_str());
        return -1;
    }

    static PyObject *new_instance(PyTypeObject *type, PyObject *, PyObject *) {
957
958
959
        instance<void> *self = (instance<void> *) PyType_GenericAlloc((PyTypeObject *) type, 0);
        auto tinfo = detail::get_type_info(type);
        self->value = ::operator new(tinfo->type_size);
Wenzel Jakob's avatar
Wenzel Jakob committed
960
        self->owned = true;
961
        self->holder_constructed = false;
962
        detail::get_internals().registered_instances.emplace(self->value, (PyObject *) self);
Wenzel Jakob's avatar
Wenzel Jakob committed
963
964
965
966
967
        return (PyObject *) self;
    }

    static void dealloc(instance<void> *self) {
        if (self->value) {
968
969
970
971
972
973
974
975
976
977
            auto instance_type = Py_TYPE(self);
            auto &registered_instances = detail::get_internals().registered_instances;
            auto range = registered_instances.equal_range(self->value);
            bool found = false;
            for (auto it = range.first; it != range.second; ++it) {
                if (instance_type == Py_TYPE(it->second)) {
                    registered_instances.erase(it);
                    found = true;
                    break;
                }
Wenzel Jakob's avatar
Wenzel Jakob committed
978
            }
979
980
981
            if (!found)
                pybind11_fail("generic_type::dealloc(): Tried to deallocate unregistered instance!");

982
983
            if (self->weakrefs)
                PyObject_ClearWeakRefs((PyObject *) self);
Dean Moldovan's avatar
Dean Moldovan committed
984

985
            PyObject **dict_ptr = _PyObject_GetDictPtr((PyObject *) self);
Wenzel Jakob's avatar
Wenzel Jakob committed
986
            if (dict_ptr)
987
                Py_CLEAR(*dict_ptr);
Wenzel Jakob's avatar
Wenzel Jakob committed
988
989
990
991
        }
        Py_TYPE(self)->tp_free((PyObject*) self);
    }

Dean Moldovan's avatar
Dean Moldovan committed
992
    static int traverse(PyObject *op, visitproc visit, void *arg) {
993
994
        PyObject *&dict = *_PyObject_GetDictPtr(op);
        Py_VISIT(dict);
Dean Moldovan's avatar
Dean Moldovan committed
995
996
997
998
        return 0;
    }

    static int clear(PyObject *op) {
999
1000
        PyObject *&dict = *_PyObject_GetDictPtr(op);
        Py_CLEAR(dict);
Dean Moldovan's avatar
Dean Moldovan committed
1001
1002
1003
        return 0;
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
1004
1005
1006
    void install_buffer_funcs(
            buffer_info *(*get_buffer)(PyObject *, void *),
            void *get_buffer_data) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1007
        PyHeapTypeObject *type = (PyHeapTypeObject*) m_ptr;
1008
        auto tinfo = detail::get_type_info(&type->ht_type);
Wenzel Jakob's avatar
Wenzel Jakob committed
1009
1010
1011
1012
1013
1014
1015
1016

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

1017
1018
        tinfo->get_buffer = get_buffer;
        tinfo->get_buffer_data = get_buffer_data;
Wenzel Jakob's avatar
Wenzel Jakob committed
1019
1020
1021
    }

    static int getbuffer(PyObject *obj, Py_buffer *view, int flags) {
1022
1023
        auto tinfo = detail::get_type_info(Py_TYPE(obj));
        if (view == nullptr || obj == nullptr || !tinfo || !tinfo->get_buffer) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1024
1025
            if (view)
                view->obj = nullptr;
1026
            PyErr_SetString(PyExc_BufferError, "generic_type::getbuffer(): Internal error");
Wenzel Jakob's avatar
Wenzel Jakob committed
1027
1028
1029
            return -1;
        }
        memset(view, 0, sizeof(Py_buffer));
1030
        buffer_info *info = tinfo->get_buffer(obj, tinfo->get_buffer_data);
Wenzel Jakob's avatar
Wenzel Jakob committed
1031
1032
1033
1034
        view->obj = obj;
        view->ndim = 1;
        view->internal = info;
        view->buf = info->ptr;
1035
        view->itemsize = (ssize_t) info->itemsize;
Wenzel Jakob's avatar
Wenzel Jakob committed
1036
1037
1038
1039
1040
1041
        view->len = view->itemsize;
        for (auto s : info->shape)
            view->len *= s;
        if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)
            view->format = const_cast<char *>(info->format.c_str());
        if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) {
1042
            view->ndim = (int) info->ndim;
1043
1044
            view->strides = (ssize_t *) &info->strides[0];
            view->shape = (ssize_t *) &info->shape[0];
Wenzel Jakob's avatar
Wenzel Jakob committed
1045
1046
1047
1048
1049
1050
        }
        Py_INCREF(view->obj);
        return 0;
    }

    static void releasebuffer(PyObject *, Py_buffer *view) { delete (buffer_info *) view->internal; }
Wenzel Jakob's avatar
Wenzel Jakob committed
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075

    void def_property_static_impl(const char *name,
                                  handle fget, handle fset,
                                  detail::function_record *rec_fget) {
        pybind11::str doc_obj = pybind11::str(
            (rec_fget->doc && pybind11::options::show_user_defined_docstrings())
                ? rec_fget->doc : "");
        const auto property = reinterpret_steal<object>(
            PyObject_CallFunctionObjArgs((PyObject *) &PyProperty_Type, fget.ptr() ? fget.ptr() : Py_None,
                                         fset.ptr() ? fset.ptr() : Py_None, Py_None, doc_obj.ptr(), nullptr));
        if (rec_fget->is_method && rec_fget->scope) {
            attr(name) = property;
        } else {
            auto mclass = handle((PyObject *) PYBIND11_OB_TYPE(*((PyTypeObject *) m_ptr)));

            if ((PyTypeObject *) mclass.ptr() == &PyType_Type)
                pybind11_fail(
                    "Adding static properties to the type '" +
                    std::string(((PyTypeObject *) m_ptr)->tp_name) +
                    "' requires the type to have a custom metaclass. Please "
                    "ensure that one is created by supplying the pybind11::metaclass() "
                    "annotation to the associated class_<>(..) invocation.");
            mclass.attr(name) = property;
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1076
};
1077

Wenzel Jakob's avatar
Wenzel Jakob committed
1078
1079
NAMESPACE_END(detail)

1080
template <typename type_, typename... options>
Wenzel Jakob's avatar
Wenzel Jakob committed
1081
class class_ : public detail::generic_type {
1082
1083
    template <typename T> using is_holder = detail::is_holder_type<type_, T>;
    template <typename T> using is_subtype = detail::bool_constant<std::is_base_of<type_, T>::value && !std::is_same<T, type_>::value>;
Wenzel Jakob's avatar
Wenzel Jakob committed
1084
    template <typename T> using is_base = detail::bool_constant<std::is_base_of<T, type_>::value && !std::is_same<T, type_>::value>;
1085
1086
1087
    // 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>> {};
1088

Wenzel Jakob's avatar
Wenzel Jakob committed
1089
public:
1090
    using type = type_;
1091
    using type_alias = detail::first_of_t<is_subtype, void, options...>;
1092
    constexpr static bool has_alias = !std::is_void<type_alias>::value;
1093
    using holder_type = detail::first_of_t<is_holder, std::unique_ptr<type>, options...>;
1094
1095
    using instance_type = detail::instance<type, holder_type>;

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

1099
    PYBIND11_OBJECT(class_, generic_type, PyType_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
1100

Wenzel Jakob's avatar
Wenzel Jakob committed
1101
1102
1103
1104
1105
1106
    template <typename... Extra>
    class_(handle scope, const char *name, const Extra &... extra) {
        detail::type_record record;
        record.scope = scope;
        record.name = name;
        record.type = &typeid(type);
1107
        record.type_size = sizeof(detail::conditional_t<has_alias, type_alias, type>);
Wenzel Jakob's avatar
Wenzel Jakob committed
1108
1109
1110
        record.instance_size = sizeof(instance_type);
        record.init_holder = init_holder;
        record.dealloc = dealloc;
1111
        record.default_holder = std::is_same<holder_type, std::unique_ptr<type>>::value;
Wenzel Jakob's avatar
Wenzel Jakob committed
1112

Wenzel Jakob's avatar
Wenzel Jakob committed
1113
        /* Register base classes specified via template arguments to class_, if any */
1114
        bool unused[] = { (add_base<options>(record), false)..., false };
Wenzel Jakob's avatar
Wenzel Jakob committed
1115
        (void) unused;
1116

Wenzel Jakob's avatar
Wenzel Jakob committed
1117
1118
1119
1120
        /* Process optional arguments, if any */
        detail::process_attributes<Extra...>::init(extra..., &record);

        detail::generic_type::initialize(&record);
1121

1122
        if (has_alias) {
1123
1124
1125
            auto &instances = pybind11::detail::get_internals().registered_types_cpp;
            instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
1126
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1127

1128
    template <typename Base, detail::enable_if_t<is_base<Base>::value, int> = 0>
Wenzel Jakob's avatar
Wenzel Jakob committed
1129
1130
1131
1132
1133
1134
    static void add_base(detail::type_record &rec) {
        rec.add_base(&typeid(Base), [](void *src) -> void * {
            return static_cast<Base *>(reinterpret_cast<type *>(src));
        });
    }

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

1138
    template <typename Func, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1139
    class_ &def(const char *name_, Func&& f, const Extra&... extra) {
1140
1141
        cpp_function cf(std::forward<Func>(f), name(name_), is_method(*this),
                        sibling(getattr(*this, name_, none())), extra...);
1142
        attr(cf.name()) = cf;
Wenzel Jakob's avatar
Wenzel Jakob committed
1143
1144
1145
        return *this;
    }

1146
    template <typename Func, typename... Extra> class_ &
Wenzel Jakob's avatar
Wenzel Jakob committed
1147
    def_static(const char *name_, Func f, const Extra&... extra) {
1148
1149
        cpp_function cf(std::forward<Func>(f), name(name_), scope(*this),
                        sibling(getattr(*this, name_, none())), extra...);
1150
        attr(cf.name()) = cf;
Wenzel Jakob's avatar
Wenzel Jakob committed
1151
1152
1153
        return *this;
    }

1154
    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1155
    class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
1156
        op.execute(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1157
1158
1159
        return *this;
    }

1160
    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1161
    class_ & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
1162
        op.execute_cast(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1163
1164
1165
        return *this;
    }

1166
    template <typename... Args, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1167
    class_ &def(const detail::init<Args...> &init, const Extra&... extra) {
1168
        init.execute(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1169
1170
1171
        return *this;
    }

1172
1173
    template <typename... Args, typename... Extra>
    class_ &def(const detail::init_alias<Args...> &init, const Extra&... extra) {
1174
        init.execute(*this, extra...);
1175
1176
1177
        return *this;
    }

1178
    template <typename Func> class_& def_buffer(Func &&func) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1179
1180
1181
        struct capture { Func func; };
        capture *ptr = new capture { std::forward<Func>(func) };
        install_buffer_funcs([](PyObject *obj, void *ptr) -> buffer_info* {
1182
            detail::make_caster<type> caster;
Wenzel Jakob's avatar
Wenzel Jakob committed
1183
1184
            if (!caster.load(obj, false))
                return nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
1185
1186
            return new buffer_info(((capture *) ptr)->func(caster));
        }, ptr);
Wenzel Jakob's avatar
Wenzel Jakob committed
1187
1188
1189
        return *this;
    }

1190
    template <typename C, typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1191
    class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
1192
1193
1194
        cpp_function fget([pm](const C &c) -> const D &{ return c.*pm; }, is_method(*this)),
                     fset([pm](C &c, const D &value) { c.*pm = value; }, is_method(*this));
        def_property(name, fget, fset, return_value_policy::reference_internal, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1195
1196
1197
        return *this;
    }

1198
    template <typename C, typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1199
    class_ &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) {
1200
1201
        cpp_function fget([pm](const C &c) -> const D &{ return c.*pm; }, is_method(*this));
        def_property_readonly(name, fget, return_value_policy::reference_internal, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1202
1203
1204
        return *this;
    }

1205
    template <typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1206
    class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
1207
1208
1209
        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
1210
1211
1212
        return *this;
    }

1213
    template <typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1214
    class_ &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
1215
1216
        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
1217
1218
1219
        return *this;
    }

1220
1221
1222
1223
1224
1225
1226
    /// 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) {
        return def_property_readonly(name, cpp_function(fget), return_value_policy::reference_internal, extra...);
    }

    /// Uses cpp_function's return_value_policy by default
1227
1228
    template <typename... Extra>
    class_ &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) {
1229
1230
1231
1232
1233
1234
1235
        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
1236
1237
    }

1238
    /// Uses cpp_function's return_value_policy by default
1239
1240
    template <typename... Extra>
    class_ &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) {
1241
1242
1243
1244
1245
1246
1247
        return def_property_static(name, fget, cpp_function(), extra...);
    }

    /// Uses return_value_policy::reference_internal by default
    template <typename Getter, typename... Extra>
    class_ &def_property(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
        return def_property(name, cpp_function(fget), fset, return_value_policy::reference_internal, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1248
1249
    }

1250
    /// Uses cpp_function's return_value_policy by default
1251
1252
    template <typename... Extra>
    class_ &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
1253
        return def_property_static(name, fget, fset, is_method(*this), extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1254
1255
    }

1256
1257
1258
1259
1260
1261
1262
    /// 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
1263
1264
1265
    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);
1266
        char *doc_prev = rec_fget->doc; /* 'extra' field may include a property-specific documentation string */
1267
        detail::process_attributes<Extra...>::init(extra..., rec_fget);
1268
1269
1270
1271
1272
1273
        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;
1274
            detail::process_attributes<Extra...>::init(extra..., rec_fset);
1275
1276
1277
1278
1279
            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
1280
        def_property_static_impl(name, fget, fset, rec_fget);
Wenzel Jakob's avatar
Wenzel Jakob committed
1281
1282
        return *this;
    }
1283

Wenzel Jakob's avatar
Wenzel Jakob committed
1284
private:
1285
1286
1287
    /// Initialize holder object, variant 1: object derives from enable_shared_from_this
    template <typename T>
    static void init_holder_helper(instance_type *inst, const holder_type * /* unused */, const std::enable_shared_from_this<T> * /* dummy */) {
1288
        try {
1289
            new (&inst->holder) holder_type(std::static_pointer_cast<typename holder_type::element_type>(inst->value->shared_from_this()));
1290
            inst->holder_constructed = true;
1291
        } catch (const std::bad_weak_ptr &) {
1292
1293
1294
1295
            if (inst->owned) {
                new (&inst->holder) holder_type(inst->value);
                inst->holder_constructed = true;
            }
1296
        }
1297
1298
    }

1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
    static void init_holder_from_existing(instance_type *inst, const holder_type *holder_ptr,
                                          std::true_type /*is_copy_constructible*/) {
        new (&inst->holder) holder_type(*holder_ptr);
    }

    static void init_holder_from_existing(instance_type *inst, const holder_type *holder_ptr,
                                          std::false_type /*is_copy_constructible*/) {
        new (&inst->holder) holder_type(std::move(*const_cast<holder_type *>(holder_ptr)));
    }

1309
1310
    /// Initialize holder object, variant 2: try to construct from existing holder object, if possible
    static void init_holder_helper(instance_type *inst, const holder_type *holder_ptr, const void * /* dummy */) {
1311
        if (holder_ptr) {
1312
            init_holder_from_existing(inst, holder_ptr, std::is_copy_constructible<holder_type>());
1313
            inst->holder_constructed = true;
1314
        } else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
1315
            new (&inst->holder) holder_type(inst->value);
1316
1317
            inst->holder_constructed = true;
        }
1318
1319
1320
1321
1322
1323
    }

    /// Initialize holder object of an instance, possibly given a pointer to an existing holder
    static void init_holder(PyObject *inst_, const void *holder_ptr) {
        auto inst = (instance_type *) inst_;
        init_holder_helper(inst, (const holder_type *) holder_ptr, inst->value);
1324
1325
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
1326
1327
    static void dealloc(PyObject *inst_) {
        instance_type *inst = (instance_type *) inst_;
1328
1329
1330
1331
1332
        if (inst->holder_constructed)
            inst->holder.~holder_type();
        else if (inst->owned)
            ::operator delete(inst->value);

1333
        generic_type::dealloc((detail::instance<void> *) inst);
Wenzel Jakob's avatar
Wenzel Jakob committed
1334
    }
1335
1336
1337

    static detail::function_record *get_function_record(handle h) {
        h = detail::get_function(h);
Wenzel Jakob's avatar
Wenzel Jakob committed
1338
        return h ? (detail::function_record *) reinterpret_borrow<capsule>(PyCFunction_GET_SELF(h.ptr()))
1339
                 : nullptr;
1340
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1341
1342
1343
1344
1345
};

/// Binds C++ enumerations and enumeration classes to Python
template <typename Type> class enum_ : public class_<Type> {
public:
1346
    using class_<Type>::def;
1347
1348
1349
    using Scalar = typename std::underlying_type<Type>::type;
    template <typename T> using arithmetic_tag = std::is_same<T, arithmetic>;

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

        constexpr bool is_arithmetic =
            !std::is_same<detail::first_of_t<arithmetic_tag, void, Extra...>,
                          void>::value;

        auto entries = new std::unordered_map<Scalar, const char *>();
1359
        def("__repr__", [name, entries](Type value) -> std::string {
1360
            auto it = entries->find((Scalar) value);
Wenzel Jakob's avatar
Wenzel Jakob committed
1361
1362
1363
1364
            return std::string(name) + "." +
                ((it == entries->end()) ? std::string("???")
                                        : std::string(it->second));
        });
1365
1366
1367
        def("__init__", [](Type& value, Scalar i) { value = (Type)i; });
        def("__init__", [](Type& value, Scalar i) { new (&value) Type((Type) i); });
        def("__int__", [](Type value) { return (Scalar) value; });
1368
1369
        def("__eq__", [](const Type &value, Type *value2) { return value2 && value == *value2; });
        def("__ne__", [](const Type &value, Type *value2) { return !value2 || value != *value2; });
1370
1371
1372
1373
1374
1375
1376
        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) {
1377
1378
            // 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
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
            // 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; });
            }
1398
        }
1399
        def("__hash__", [](const Type &value) { return (Scalar) value; });
Wenzel Jakob's avatar
Wenzel Jakob committed
1400
        // Pickling and unpickling -- needed for use with the 'multiprocessing' module
1401
1402
        def("__getstate__", [](const Type &value) { return pybind11::make_tuple((Scalar) value); });
        def("__setstate__", [](Type &p, tuple t) { new (&p) Type((Type) t[0].cast<Scalar>()); });
Wenzel Jakob's avatar
Wenzel Jakob committed
1403
1404
1405
1406
        m_entries = entries;
    }

    /// Export enumeration entries into the parent scope
1407
    enum_ &export_values() {
Wenzel Jakob's avatar
Wenzel Jakob committed
1408
#if !defined(PYPY_VERSION)
Wenzel Jakob's avatar
Wenzel Jakob committed
1409
1410
        PyObject *dict = ((PyTypeObject *) this->m_ptr)->tp_dict;
        PyObject *key, *value;
1411
        ssize_t pos = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
1412
1413

        while (PyDict_Next(dict, &pos, &key, &value)) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1414
1415
            if (PyObject_IsInstance(value, this->m_ptr))
                m_parent.attr(key) = value;
Wenzel Jakob's avatar
Wenzel Jakob committed
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
        }
#else
        /* PyPy's cpyext still has difficulties with the above
           CPython API calls; emulate using Python code. */
        dict d; d["t"] = *this; d["p"] = m_parent;
        PyObject *result = PyRun_String(
            "for k, v in t.__dict__.items():\n"
            "    if isinstance(v, t):\n"
            "        setattr(p, k, v)\n",
            Py_file_input, d.ptr(), d.ptr());
        if (result == nullptr)
            throw error_already_set();
        Py_DECREF(result);
#endif

1431
        return *this;
Wenzel Jakob's avatar
Wenzel Jakob committed
1432
1433
1434
1435
    }

    /// Add an enumeration entry
    enum_& value(char const* name, Type value) {
1436
        this->attr(name) = pybind11::cast(value, return_value_policy::copy);
1437
        (*m_entries)[(Scalar) value] = name;
Wenzel Jakob's avatar
Wenzel Jakob committed
1438
1439
1440
        return *this;
    }
private:
1441
    std::unordered_map<Scalar, const char *> *m_entries;
Wenzel Jakob's avatar
Wenzel Jakob committed
1442
    handle m_parent;
Wenzel Jakob's avatar
Wenzel Jakob committed
1443
1444
1445
};

NAMESPACE_BEGIN(detail)
1446
template <typename... Args> struct init {
1447
1448
    template <typename Class, typename... Extra, enable_if_t<!Class::has_alias, int> = 0>
    static void execute(Class &cl, const Extra&... extra) {
1449
        using Base = typename Class::type;
Wenzel Jakob's avatar
Wenzel Jakob committed
1450
        /// Function which calls a specific C++ in-place constructor
1451
        cl.def("__init__", [](Base *self_, Args... args) { new (self_) Base(args...); }, extra...);
1452
1453
    }

1454
    template <typename Class, typename... Extra,
1455
1456
1457
              enable_if_t<Class::has_alias &&
                          std::is_constructible<typename Class::type, Args...>::value, int> = 0>
    static void execute(Class &cl, const Extra&... extra) {
1458
1459
1460
1461
        using Base = typename Class::type;
        using Alias = typename Class::type_alias;
        handle cl_type = cl;
        cl.def("__init__", [cl_type](handle self_, Args... args) {
1462
1463
                if (self_.get_type() == cl_type)
                    new (self_.cast<Base *>()) Base(args...);
1464
                else
1465
                    new (self_.cast<Alias *>()) Alias(args...);
1466
1467
1468
            }, extra...);
    }

1469
    template <typename Class, typename... Extra,
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
              enable_if_t<Class::has_alias &&
                          !std::is_constructible<typename Class::type, Args...>::value, int> = 0>
    static void execute(Class &cl, const Extra&... extra) {
        init_alias<Args...>::execute(cl, extra...);
    }
};
template <typename... Args> struct init_alias {
    template <typename Class, typename... Extra,
              enable_if_t<Class::has_alias && std::is_constructible<typename Class::type_alias, Args...>::value, int> = 0>
    static void execute(Class &cl, const Extra&... extra) {
1480
1481
        using Alias = typename Class::type_alias;
        cl.def("__init__", [](Alias *self_, Args... args) { new (self_) Alias(args...); }, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1482
1483
    }
};
1484

1485

1486
inline void keep_alive_impl(handle nurse, handle patient) {
1487
    /* Clever approach based on weak references taken from Boost.Python */
1488
    if (!nurse || !patient)
1489
        pybind11_fail("Could not activate keep_alive!");
1490

1491
    if (patient.is_none() || nurse.is_none())
1492
        return; /* Nothing to keep alive or nothing to be kept alive by */
1493

1494
    cpp_function disable_lifesupport(
1495
        [patient](handle weakref) { patient.dec_ref(); weakref.dec_ref(); });
1496

1497
    weakref wr(nurse, disable_lifesupport);
1498

1499
1500
    patient.inc_ref(); /* reference patient and leak the weak reference */
    (void) wr.release();
1501
1502
}

1503
PYBIND11_NOINLINE inline void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret) {
1504
    keep_alive_impl(
1505
1506
        Nurse   == 0 ? ret : Nurse   <= call.args.size() ? call.args[Nurse   - 1] : handle(),
        Patient == 0 ? ret : Patient <= call.args.size() ? call.args[Patient - 1] : handle()
1507
    );
1508
1509
}

1510
template <typename Iterator, typename Sentinel, bool KeyIterator, return_value_policy Policy>
1511
1512
1513
struct iterator_state {
    Iterator it;
    Sentinel end;
1514
1515
    bool first;
};
1516

Wenzel Jakob's avatar
Wenzel Jakob committed
1517
1518
NAMESPACE_END(detail)

1519
template <typename... Args> detail::init<Args...> init() { return detail::init<Args...>(); }
1520
template <typename... Args> detail::init_alias<Args...> init_alias() { return detail::init_alias<Args...>(); }
Wenzel Jakob's avatar
Wenzel Jakob committed
1521

1522
1523
template <return_value_policy Policy = return_value_policy::reference_internal,
          typename Iterator,
1524
          typename Sentinel,
1525
1526
          typename ValueType = decltype(*std::declval<Iterator>()),
          typename... Extra>
1527
iterator make_iterator(Iterator first, Sentinel last, Extra &&... extra) {
1528
    typedef detail::iterator_state<Iterator, Sentinel, false, Policy> state;
1529

Wenzel Jakob's avatar
Wenzel Jakob committed
1530
    if (!detail::get_type_info(typeid(state), false)) {
1531
        class_<state>(handle(), "iterator")
1532
            .def("__iter__", [](state &s) -> state& { return s; })
1533
            .def("__next__", [](state &s) -> ValueType {
1534
1535
1536
1537
                if (!s.first)
                    ++s.it;
                else
                    s.first = false;
1538
1539
                if (s.it == s.end)
                    throw stop_iteration();
1540
                return *s.it;
1541
            }, std::forward<Extra>(extra)..., Policy);
1542
1543
    }

1544
    return (iterator) cast(state { first, last, true });
1545
}
1546

1547
1548
template <return_value_policy Policy = return_value_policy::reference_internal,
          typename Iterator,
1549
          typename Sentinel,
1550
          typename KeyType = decltype((*std::declval<Iterator>()).first),
1551
          typename... Extra>
1552
iterator make_key_iterator(Iterator first, Sentinel last, Extra &&... extra) {
1553
    typedef detail::iterator_state<Iterator, Sentinel, true, Policy> state;
1554

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

    return (iterator) cast(state { first, last, true });
}
1571

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
1579
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...);
1580
1581
}

Wenzel Jakob's avatar
Wenzel Jakob committed
1582
template <typename InputType, typename OutputType> void implicitly_convertible() {
1583
    auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject * {
1584
        if (!detail::make_caster<InputType>().load(obj, false))
Wenzel Jakob's avatar
Wenzel Jakob committed
1585
1586
1587
1588
1589
1590
1591
1592
            return nullptr;
        tuple args(1);
        args[0] = obj;
        PyObject *result = PyObject_Call((PyObject *) type, args.ptr(), nullptr);
        if (result == nullptr)
            PyErr_Clear();
        return result;
    };
1593
1594
1595
1596

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

1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
template <typename ExceptionTranslator>
void register_exception_translator(ExceptionTranslator&& translator) {
    detail::get_internals().registered_exception_translators.push_front(
        std::forward<ExceptionTranslator>(translator));
}

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

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

1631
1632
1633
1634
1635
/** Registers a Python exception in `m` of the given `name` and installs an exception translator to
 * 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.
 */
1636
1637
1638
1639
1640
template <typename CppException>
exception<CppException> &register_exception(handle scope,
                                            const char *name,
                                            PyObject *base = PyExc_Exception) {
    static exception<CppException> ex(scope, name, base);
1641
1642
1643
1644
    register_exception_translator([](std::exception_ptr p) {
        if (!p) return;
        try {
            std::rethrow_exception(p);
1645
        } catch (const CppException &e) {
1646
1647
1648
1649
1650
1651
            ex(e.what());
        }
    });
    return ex;
}

Dean Moldovan's avatar
Dean Moldovan committed
1652
1653
1654
1655
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) {
1656
        strings[i] = str(args[i]);
Dean Moldovan's avatar
Dean Moldovan committed
1657
    }
1658
    auto sep = kwargs.contains("sep") ? kwargs["sep"] : cast(" ");
1659
    auto line = sep.attr("join")(strings);
Dean Moldovan's avatar
Dean Moldovan committed
1660

1661
1662
1663
1664
1665
1666
    object file;
    if (kwargs.contains("file")) {
        file = kwargs["file"].cast<object>();
    } else {
        try {
            file = module::import("sys").attr("stdout");
1667
        } catch (const error_already_set &) {
1668
1669
1670
1671
1672
1673
1674
1675
            /* 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;
        }
    }

1676
    auto write = file.attr("write");
Dean Moldovan's avatar
Dean Moldovan committed
1677
    write(line);
1678
    write(kwargs.contains("end") ? kwargs["end"] : cast("\n"));
Dean Moldovan's avatar
Dean Moldovan committed
1679

1680
    if (kwargs.contains("flush") && kwargs["flush"].cast<bool>())
1681
        file.attr("flush")();
Dean Moldovan's avatar
Dean Moldovan committed
1682
1683
1684
1685
1686
1687
1688
1689
1690
}
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
1691
#if defined(WITH_THREAD) && !defined(PYPY_VERSION)
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705

/* 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
1706
1707
 *    thread would otherwise constantly construct and destroy thread state data
 *    structures.
1708
1709
1710
1711
1712
 *
 * 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).
1713
 */
Wenzel Jakob's avatar
Wenzel Jakob committed
1714
1715
1716

class gil_scoped_acquire {
public:
1717
    PYBIND11_NOINLINE gil_scoped_acquire() {
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
        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;
1728
1729
1730
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(internals.tstate);
            #endif
1731
1732
            PyThread_set_key_value(internals.tstate, tstate);
        } else {
1733
            release = detail::get_thread_state_unchecked() != tstate;
1734
1735
1736
1737
        }

        if (release) {
            /* Work around an annoying assertion in PyThreadState_Swap */
1738
1739
1740
1741
            #if defined(Py_DEBUG)
                PyInterpreterState *interp = tstate->interp;
                tstate->interp = nullptr;
            #endif
1742
            PyEval_AcquireThread(tstate);
1743
1744
1745
            #if defined(Py_DEBUG)
                tstate->interp = interp;
            #endif
1746
1747
1748
1749
1750
1751
1752
1753
1754
        }

        inc_ref();
    }

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

1755
    PYBIND11_NOINLINE void dec_ref() {
1756
1757
        --tstate->gilstate_counter;
        #if !defined(NDEBUG)
1758
            if (detail::get_thread_state_unchecked() != tstate)
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
                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();
1770
            PyThread_delete_key_value(detail::get_internals().tstate);
1771
1772
1773
1774
            release = false;
        }
    }

1775
    PYBIND11_NOINLINE ~gil_scoped_acquire() {
1776
1777
1778
1779
1780
1781
1782
        dec_ref();
        if (release)
           PyEval_SaveThread();
    }
private:
    PyThreadState *tstate = nullptr;
    bool release = true;
Wenzel Jakob's avatar
Wenzel Jakob committed
1783
1784
1785
1786
};

class gil_scoped_release {
public:
1787
    explicit gil_scoped_release(bool disassoc = false) : disassoc(disassoc) {
1788
        tstate = PyEval_SaveThread();
1789
        if (disassoc) {
1790
            auto key = detail::get_internals().tstate;
1791
1792
1793
1794
1795
1796
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(key);
            #else
                PyThread_set_key_value(key, nullptr);
            #endif
        }
1797
1798
1799
1800
1801
    }
    ~gil_scoped_release() {
        if (!tstate)
            return;
        PyEval_RestoreThread(tstate);
1802
        if (disassoc) {
1803
            auto key = detail::get_internals().tstate;
1804
1805
1806
1807
1808
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(key);
            #endif
            PyThread_set_key_value(key, tstate);
        }
1809
1810
1811
1812
    }
private:
    PyThreadState *tstate;
    bool disassoc;
Wenzel Jakob's avatar
Wenzel Jakob committed
1813
};
Wenzel Jakob's avatar
Wenzel Jakob committed
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
#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); }
};
1828
1829
1830
#else
class gil_scoped_acquire { };
class gil_scoped_release { };
1831
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
1832

1833
1834
1835
1836
1837
1838
1839
1840
error_already_set::~error_already_set() {
    if (value) {
        gil_scoped_acquire gil;
        PyErr_Restore(type, value, trace);
        PyErr_Clear();
    }
}

1841
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
1842
1843
    handle self = detail::get_object_handle(this_ptr, this_type);
    if (!self)
1844
        return function();
Wenzel Jakob's avatar
Wenzel Jakob committed
1845
    handle type = self.get_type();
1846
1847
    auto key = std::make_pair(type.ptr(), name);

1848
1849
    /* Cache functions that aren't overloaded in Python to avoid
       many costly Python dictionary lookups below */
1850
1851
1852
1853
    auto &cache = detail::get_internals().inactive_overload_cache;
    if (cache.find(key) != cache.end())
        return function();

Wenzel Jakob's avatar
Wenzel Jakob committed
1854
    function overload = getattr(self, name, function());
1855
1856
1857
1858
    if (overload.is_cpp_function()) {
        cache.insert(key);
        return function();
    }
1859

Wenzel Jakob's avatar
Wenzel Jakob committed
1860
1861
1862
    /* Don't call dispatch code if invoked from overridden function.
       Unfortunately this doesn't work on PyPy. */
#if !defined(PYPY_VERSION)
1863
    PyFrameObject *frame = PyThreadState_Get()->frame;
1864
    if (frame && (std::string) str(frame->f_code->co_name) == name &&
1865
1866
1867
1868
        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
1869
        if (self_caller == self.ptr())
1870
1871
            return function();
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
#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();
    if ((handle) d["self"] == Py_None)
        return function();
    Py_DECREF(result);
#endif

1895
1896
1897
    return overload;
}

1898
template <class T> function get_overload(const T *this_ptr, const char *name) {
1899
1900
    auto tinfo = detail::get_type_info(typeid(T));
    return tinfo ? get_type_overload(this_ptr, tinfo, name) : function();
1901
1902
}

1903
#define PYBIND11_OVERLOAD_INT(ret_type, cname, name, ...) { \
1904
        pybind11::gil_scoped_acquire gil; \
1905
        pybind11::function overload = pybind11::get_overload(static_cast<const cname *>(this), name); \
1906
        if (overload) { \
1907
            auto o = overload(__VA_ARGS__); \
1908
            if (pybind11::detail::cast_is_temporary_value_reference<ret_type>::value) { \
1909
1910
                static pybind11::detail::overload_caster_t<ret_type> caster; \
                return pybind11::detail::cast_ref<ret_type>(std::move(o), caster); \
1911
1912
1913
1914
            } \
            else return pybind11::detail::cast_safe<ret_type>(std::move(o)); \
        } \
    }
1915

1916
#define PYBIND11_OVERLOAD_NAME(ret_type, cname, name, fn, ...) \
1917
    PYBIND11_OVERLOAD_INT(ret_type, cname, name, __VA_ARGS__) \
1918
    return cname::fn(__VA_ARGS__)
1919

1920
#define PYBIND11_OVERLOAD_PURE_NAME(ret_type, cname, name, fn, ...) \
1921
    PYBIND11_OVERLOAD_INT(ret_type, cname, name, __VA_ARGS__) \
1922
1923
1924
1925
1926
1927
1928
    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__)
1929

1930
NAMESPACE_END(pybind11)
Wenzel Jakob's avatar
Wenzel Jakob committed
1931
1932

#if defined(_MSC_VER)
Wenzel Jakob's avatar
Wenzel Jakob committed
1933
#  pragma warning(pop)
1934
1935
#elif defined(__INTEL_COMPILER)
/* Leave ignored warnings on */
1936
#elif defined(__GNUG__) && !defined(__clang__)
Wenzel Jakob's avatar
Wenzel Jakob committed
1937
#  pragma GCC diagnostic pop
Wenzel Jakob's avatar
Wenzel Jakob committed
1938
#endif