pybind11.h 61.5 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
20
#elif defined(__INTEL_COMPILER)
Ben Pritchard's avatar
Ben Pritchard committed
21
#  pragma warning(push)
22
23
24
#  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"
25
#elif defined(__GNUG__) && !defined(__clang__)
Wenzel Jakob's avatar
Wenzel Jakob committed
26
27
28
29
#  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
30
31
#  pragma GCC diagnostic ignored "-Wstrict-aliasing"
#  pragma GCC diagnostic ignored "-Wattributes"
Wenzel Jakob's avatar
Wenzel Jakob committed
32
33
#endif

Wenzel Jakob's avatar
Wenzel Jakob committed
34
#include "attr.h"
Wenzel Jakob's avatar
Wenzel Jakob committed
35

36
NAMESPACE_BEGIN(pybind11)
Wenzel Jakob's avatar
Wenzel Jakob committed
37

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

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

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

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

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

70
    /// Return the function name
Wenzel Jakob's avatar
Wenzel Jakob committed
71
    object name() const { return attr("__name__"); }
72

73
74
protected:
    /// Special internal constructor for functors, lambda functions, etc.
75
    template <typename Func, typename Return, typename... Args, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
76
    void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
77
78
79
        static_assert(detail::expected_num_args<Extra...>(sizeof...(Args)),
                      "The number of named arguments does not match the function signature");

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

82
        /* Store the function including any extra state it might have (e.g. a lambda capture object) */
Wenzel Jakob's avatar
Wenzel Jakob committed
83
        auto rec = new detail::function_record();
84

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

105
106
107
108
109
        /* Type casters for the function arguments and return value */
        typedef detail::type_caster<typename std::tuple<Args...>> cast_in;
        typedef detail::type_caster<typename std::conditional<
            std::is_void<Return>::value, detail::void_type,
            typename detail::intrinsic_type<Return>::type>::type> cast_out;
Wenzel Jakob's avatar
Wenzel Jakob committed
110

111
        /* Dispatch code which converts function arguments and performs the actual function call */
112
        rec->impl = [](detail::function_record *rec, handle args, handle kwargs, handle parent) -> handle {
113
            cast_in args_converter;
114
115

            /* Try to cast the function arguments into the C++ domain */
116
            if (!args_converter.load_args(args, kwargs, true))
117
118
                return PYBIND11_TRY_NEXT_OVERLOAD;

Wenzel Jakob's avatar
Wenzel Jakob committed
119
            /* Invoke call policy pre-call hook */
120
121
122
123
124
            detail::process_attributes<Extra...>::precall(args);

            /* Get a pointer to the capture object */
            capture *cap = (capture *) (sizeof(capture) <= sizeof(rec->data)
                                        ? &rec->data : rec->data[0]);
125

126
            /* Perform the function call */
127
128
            handle result = cast_out::cast(args_converter.template call<Return>(cap->f),
                                           rec->policy, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
129
130

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

133
            return result;
Wenzel Jakob's avatar
Wenzel Jakob committed
134
135
        };

Wenzel Jakob's avatar
Wenzel Jakob committed
136
137
        /* Process any user-provided function attributes */
        detail::process_attributes<Extra...>::init(extra..., rec);
138
139

        /* Generate a readable signature describing the function's arguments and return value types */
140
141
        using detail::descr; using detail::_;
        PYBIND11_DESCR signature = _("(") + cast_in::element_names() + _(") -> ") + cast_out::name();
142
143

        /* Register the function with Python from generic (non-templated) code */
144
        initialize_generic(rec, signature.text(), signature.types(), sizeof...(Args));
145
146
147

        if (cast_in::has_args) rec->has_args = true;
        if (cast_in::has_kwargs) rec->has_kwargs = true;
148
149
150
151
152
153
154
155
156
157

        /* Stash some additional information used by an important optimization in 'functional.h' */
        using FunctionType = Return (*)(Args...);
        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);
        }
158
159
    }

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

164
        /* Create copies of all referenced C-style strings */
Wenzel Jakob's avatar
Wenzel Jakob committed
165
166
167
        rec->name = strdup(rec->name ? rec->name : "");
        if (rec->doc) rec->doc = strdup(rec->doc);
        for (auto &a: rec->args) {
168
169
170
171
172
            if (a.name)
                a.name = strdup(a.name);
            if (a.descr)
                a.descr = strdup(a.descr);
            else if (a.value)
173
                a.descr = strdup(((std::string) ((object) handle(a.value).attr("__repr__"))().str()).c_str());
174
        }
175

176
        auto const &registered_types = detail::get_internals().registered_types_cpp;
177
178
179
180
181
182
183
184
185
186

        /* 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 == '{') {
187
                // Write arg name for everything except *args, **kwargs and return type.
188
                if (type_depth == 0 && text[char_index] != '*' && arg_index < args) {
189
190
191
192
193
194
195
196
                    if (!rec->args.empty()) {
                        signature += rec->args[arg_index].name;
                    } else if (arg_index == 0 && rec->class_) {
                        signature += "self";
                    } else {
                        signature += "arg" + std::to_string(arg_index - (rec->class_ ? 1 : 0));
                    }
                    signature += ": ";
197
198
199
200
                }
                ++type_depth;
            } else if (c == '}') {
                --type_depth;
201
                if (type_depth == 0) {
202
203
                    if (arg_index < rec->args.size() && rec->args[arg_index].descr) {
                        signature += "=";
Wenzel Jakob's avatar
Wenzel Jakob committed
204
                        signature += rec->args[arg_index].descr;
205
206
207
208
209
                    }
                    arg_index++;
                }
            } else if (c == '%') {
                const std::type_info *t = types[type_index++];
210
                if (!t)
211
                    pybind11_fail("Internal error while parsing type signature (1)");
212
                auto it = registered_types.find(std::type_index(*t));
213
                if (it != registered_types.end()) {
214
                    signature += ((const detail::type_info *) it->second)->type->tp_name;
215
216
217
218
219
220
221
222
223
                } else {
                    std::string tname(t->name());
                    detail::clean_type_id(tname);
                    signature += tname;
                }
            } else {
                signature += c;
            }
        }
224
        if (type_depth != 0 || types[type_index] != nullptr)
225
            pybind11_fail("Internal error while parsing type signature (2)");
226
227
228
229
230

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

232
#if PY_MAJOR_VERSION < 3
Wenzel Jakob's avatar
Wenzel Jakob committed
233
234
235
        if (strcmp(rec->name, "__next__") == 0) {
            std::free(rec->name);
            rec->name = strdup("next");
236
237
238
        } else if (strcmp(rec->name, "__bool__") == 0) {
            std::free(rec->name);
            rec->name = strdup("__nonzero__");
239
        }
240
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
241
242
        rec->signature = strdup(signature.c_str());
        rec->args.shrink_to_fit();
243
        rec->is_constructor = !strcmp(rec->name, "__init__") || !strcmp(rec->name, "__setstate__");
244
        rec->is_stateless = false;
245
246
        rec->has_args = false;
        rec->has_kwargs = false;
247
        rec->nargs = (uint16_t) args;
248
249

#if PY_MAJOR_VERSION < 3
Wenzel Jakob's avatar
Wenzel Jakob committed
250
251
        if (rec->sibling && PyMethod_Check(rec->sibling.ptr()))
            rec->sibling = PyMethod_GET_FUNCTION(rec->sibling.ptr());
252
#endif
253

Wenzel Jakob's avatar
Wenzel Jakob committed
254
255
256
257
        detail::function_record *chain = nullptr, *chain_start = rec;
        if (rec->sibling && PyCFunction_Check(rec->sibling.ptr())) {
            capsule rec_capsule(PyCFunction_GetSelf(rec->sibling.ptr()), true);
            chain = (detail::function_record *) rec_capsule;
258
259
            /* Never append a method to an overload chain of a parent class;
               instead, hide the parent's overloads in this case */
Wenzel Jakob's avatar
Wenzel Jakob committed
260
261
            if (chain->class_ != rec->class_)
                chain = nullptr;
262
263
        }

Wenzel Jakob's avatar
Wenzel Jakob committed
264
        if (!chain) {
265
            /* No existing overload was found, create a new function object */
Wenzel Jakob's avatar
Wenzel Jakob committed
266
267
268
269
270
            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;
271

Wenzel Jakob's avatar
Wenzel Jakob committed
272
273
            capsule rec_capsule(rec, [](PyObject *o) {
                destruct((detail::function_record *) PyCapsule_GetPointer(o, nullptr));
274
            });
275
276
277
278
279
280
281
282
283

            object scope_module;
            if (rec->scope) {
                scope_module = (object) rec->scope.attr("__module__");
                if (!scope_module)
                    scope_module = (object) rec->scope.attr("__name__");
            }

            m_ptr = PyCFunction_NewEx(rec->def, rec_capsule.ptr(), scope_module.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
284
            if (!m_ptr)
285
                pybind11_fail("cpp_function::cpp_function(): Could not allocate function object");
Wenzel Jakob's avatar
Wenzel Jakob committed
286
        } else {
287
            /* Append at the end of the overload chain */
Wenzel Jakob's avatar
Wenzel Jakob committed
288
            m_ptr = rec->sibling.ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
289
            inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
290
291
292
293
            chain_start = chain;
            while (chain->next)
                chain = chain->next;
            chain->next = rec;
Wenzel Jakob's avatar
Wenzel Jakob committed
294
        }
295

Wenzel Jakob's avatar
Wenzel Jakob committed
296
        std::string signatures;
297
        int index = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
298
        /* Create a nice pydoc rec including all signatures and
299
           docstrings of the functions in the overload chain */
300
301
302
303
304
305
306
        if (chain) {
            // 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
307
308
        for (auto it = chain_start; it != nullptr; it = it->next) {
            if (chain)
309
                signatures += std::to_string(++index) + ". ";
310
            signatures += rec->name;
311
312
313
314
            signatures += it->signature;
            signatures += "\n";
            if (it->doc && strlen(it->doc) > 0) {
                signatures += "\n";
315
                signatures += it->doc;
316
317
                signatures += "\n";
            }
318
            if (it->next)
Wenzel Jakob's avatar
Wenzel Jakob committed
319
320
                signatures += "\n";
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
321
322

        /* Install docstring */
Wenzel Jakob's avatar
Wenzel Jakob committed
323
324
        PyCFunctionObject *func = (PyCFunctionObject *) m_ptr;
        if (func->m_ml->ml_doc)
325
            std::free((char *) func->m_ml->ml_doc);
Wenzel Jakob's avatar
Wenzel Jakob committed
326
        func->m_ml->ml_doc = strdup(signatures.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
327
328
329

        if (rec->class_) {
            m_ptr = PYBIND11_INSTANCE_METHOD_NEW(m_ptr, rec->class_.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
330
            if (!m_ptr)
331
                pybind11_fail("cpp_function::cpp_function(): Could not allocate instance method object");
Wenzel Jakob's avatar
Wenzel Jakob committed
332
333
334
            Py_DECREF(func);
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
335
336
337
338
339
340

    /// 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)
341
                rec->free_data(rec);
Wenzel Jakob's avatar
Wenzel Jakob committed
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
            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
    static PyObject *dispatcher(PyObject *self, PyObject *args, PyObject *kwargs) {
        /* Iterator over the list of potentially admissible overloads */
        detail::function_record *overloads = (detail::function_record *) PyCapsule_GetPointer(self, nullptr),
                                *it = overloads;

        /* Need to know how many arguments + keyword arguments there are to pick the right overload */
366
367
        size_t nargs = (size_t) PyTuple_GET_SIZE(args),
               nkwargs = kwargs ? (size_t) PyDict_Size(kwargs) : 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
368

369
        handle parent = nargs > 0 ? PyTuple_GET_ITEM(args, 0) : nullptr,
Wenzel Jakob's avatar
Wenzel Jakob committed
370
371
372
373
               result = PYBIND11_TRY_NEXT_OVERLOAD;
        try {
            for (; it != nullptr; it = it->next) {
                tuple args_(args, true);
374
                size_t kwargs_consumed = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
375
376
377
378
379
380
381
382

                /* For each overload:
                   1. If the required list of arguments is longer than the
                      actually provided amount, create a copy of the argument
                      list and fill in any available keyword/default arguments.
                   2. Ensure that all keyword arguments were "consumed"
                   3. Call the function call dispatcher (function_record::impl)
                 */
383
384
385
386
387
                size_t nargs_ = nargs;
                if (nargs < it->args.size()) {
                    nargs_ = it->args.size();
                    args_ = tuple(nargs_);
                    for (size_t i = 0; i < nargs; ++i) {
Wenzel Jakob's avatar
Wenzel Jakob committed
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
                        handle item = PyTuple_GET_ITEM(args, i);
                        PyTuple_SET_ITEM(args_.ptr(), i, item.inc_ref().ptr());
                    }

                    int arg_ctr = 0;
                    for (auto const &it2 : it->args) {
                        int index = arg_ctr++;
                        if (PyTuple_GET_ITEM(args_.ptr(), index))
                            continue;

                        handle value;
                        if (kwargs)
                            value = PyDict_GetItemString(kwargs, it2.name);

                        if (value)
                            kwargs_consumed++;
                        else if (it2.value)
                            value = it2.value;

                        if (value) {
                            PyTuple_SET_ITEM(args_.ptr(), index, value.inc_ref().ptr());
                        } else {
410
                            kwargs_consumed = (size_t) -1; /* definite failure */
Wenzel Jakob's avatar
Wenzel Jakob committed
411
412
413
414
                            break;
                        }
                    }
                }
415
416

                try {
417
418
419
                    if ((kwargs_consumed == nkwargs || it->has_kwargs) &&
                        (nargs_ == it->nargs || it->has_args))
                        result = it->impl(it, args_, kwargs, parent);
420
                } catch (reference_cast_error &) {
421
422
                    result = PYBIND11_TRY_NEXT_OVERLOAD;
                }
Wenzel Jakob's avatar
Wenzel Jakob committed
423
424
425
426

                if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD)
                    break;
            }
427
428
        } catch (const error_already_set &) {
            return nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
429
        } catch (...) {
430
431
432
            /* When an exception is caught, give each registered exception
               translator a chance to translate it to a Python exception
               in reverse order of registration.
433

434
               A translator may choose to do one of the following:
435

436
437
438
439
440
                - 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. */

441
            auto last_exception = std::current_exception();
442
443
444
445
446
447
448
449
450
451
452
            auto &registered_exception_translators = pybind11::detail::get_internals().registered_exception_translators;
            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
453
454
455
456
            return nullptr;
        }

        if (result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) {
457
458
            std::string msg = "Incompatible " + std::string(overloads->is_constructor ? "constructor" : "function") +
                              " arguments. The following argument types are supported:\n";
Wenzel Jakob's avatar
Wenzel Jakob committed
459
460
461
            int ctr = 0;
            for (detail::function_record *it2 = overloads; it2 != nullptr; it2 = it2->next) {
                msg += "    "+ std::to_string(++ctr) + ". ";
462
463
464

                bool wrote_sig = false;
                if (overloads->is_constructor) {
465
                    // For a constructor, rewrite `(self: Object, arg0, ...) -> NoneType` as `Object(arg0, ...)`
466
                    std::string sig = it2->signature;
467
                    size_t start = sig.find('(') + 7; // skip "(self: "
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
                    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
484
485
                msg += "\n";
            }
486
487
            msg += "    Invoked with: ";
            tuple args_(args, true);
488
            for (size_t ti = overloads->is_constructor ? 1 : 0; ti < args_.size(); ++ti) {
489
490
491
492
                msg += static_cast<std::string>(static_cast<object>(args_[ti]).str());
                if ((ti + 1) != args_.size() )
                    msg += ", ";
            }
Wenzel Jakob's avatar
Wenzel Jakob committed
493
494
495
496
497
498
499
500
501
502
            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) {
503
                /* When a constructor ran successfully, the corresponding
Wenzel Jakob's avatar
Wenzel Jakob committed
504
                   holder type (e.g. std::unique_ptr) must still be initialized. */
505
                PyObject *inst = PyTuple_GET_ITEM(args, 0);
Wenzel Jakob's avatar
Wenzel Jakob committed
506
507
508
509
510
511
                auto tinfo = detail::get_type_info(Py_TYPE(inst));
                tinfo->init_holder(inst, nullptr);
            }
            return result.ptr();
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
512
513
};

514
/// Wrapper for Python extension modules
Wenzel Jakob's avatar
Wenzel Jakob committed
515
516
class module : public object {
public:
517
    PYBIND11_OBJECT_DEFAULT(module, object, PyModule_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
518
519

    module(const char *name, const char *doc = nullptr) {
520
#if PY_MAJOR_VERSION >= 3
Wenzel Jakob's avatar
Wenzel Jakob committed
521
522
523
524
525
526
527
        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);
528
529
530
#else
        m_ptr = Py_InitModule3(name, nullptr, doc);
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
531
        if (m_ptr == nullptr)
532
            pybind11_fail("Internal error in module::module()");
Wenzel Jakob's avatar
Wenzel Jakob committed
533
534
535
        inc_ref();
    }

536
    template <typename Func, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
537
    module &def(const char *name_, Func &&f, const Extra& ... extra) {
538
        cpp_function func(std::forward<Func>(f), name(name_),
539
                          sibling((handle) attr(name_)), scope(*this), extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
540
541
        /* PyModule_AddObject steals a reference to 'func' */
        PyModule_AddObject(ptr(), name_, func.inc_ref().ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
542
543
544
        return *this;
    }

545
    module def_submodule(const char *name, const char *doc = nullptr) {
Wenzel Jakob's avatar
Wenzel Jakob committed
546
547
548
        std::string full_name = std::string(PyModule_GetName(m_ptr))
            + std::string(".") + std::string(name);
        module result(PyImport_AddModule(full_name.c_str()), true);
549
        if (doc)
550
            result.attr("__doc__") = pybind11::str(doc);
Wenzel Jakob's avatar
Wenzel Jakob committed
551
552
553
        attr(name) = result;
        return result;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
554
555

    static module import(const char *name) {
556
557
        PyObject *obj = PyImport_ImportModule(name);
        if (!obj)
558
            pybind11_fail("Module \"" + std::string(name) + "\" not found!");
559
        return module(obj, false);
Wenzel Jakob's avatar
Wenzel Jakob committed
560
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
561
562
563
};

NAMESPACE_BEGIN(detail)
Wenzel Jakob's avatar
Wenzel Jakob committed
564
/// Generic support for creating new Python heap types
565
class generic_type : public object {
566
    template <typename...> friend class class_;
Wenzel Jakob's avatar
Wenzel Jakob committed
567
public:
568
    PYBIND11_OBJECT_DEFAULT(generic_type, object, PyType_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
569
570
571
572
573
574
575
576
577
578
579
580
581
protected:
    void initialize(type_record *rec) {
        if (rec->base_type) {
            if (rec->base_handle)
                pybind11_fail("generic_type: specified base type multiple times!");
            rec->base_handle = detail::get_type_handle(*(rec->base_type));
            if (!rec->base_handle) {
                std::string tname(rec->base_type->name());
                detail::clean_type_id(tname);
                pybind11_fail("generic_type: type \"" + std::string(rec->name) +
                              "\" referenced unknown base type \"" + tname + "\"");
            }
        }
582

583
584
585
586
587
588
589
590
        auto &internals = get_internals();
        auto tindex = std::type_index(*(rec->type));

        if (internals.registered_types_cpp.find(tindex) !=
            internals.registered_types_cpp.end())
            pybind11_fail("generic_type: type \"" + std::string(rec->name) +
                          "\" is already registered!");

Wenzel Jakob's avatar
Wenzel Jakob committed
591
        object name(PYBIND11_FROM_STRING(rec->name), false);
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
        object scope_module;
        if (rec->scope) {
            scope_module = (object) rec->scope.attr("__module__");
            if (!scope_module)
                scope_module = (object) rec->scope.attr("__name__");
        }

#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
        /* Qualified names for Python >= 3.3 */
        object scope_qualname;
        if (rec->scope)
            scope_qualname = (object) rec->scope.attr("__qualname__");
        object ht_qualname;
        if (scope_qualname) {
            ht_qualname = object(PyUnicode_FromFormat(
                "%U.%U", scope_qualname.ptr(), name.ptr()), false);
        } else {
            ht_qualname = name;
        }
#endif
        std::string full_name = (scope_module ? ((std::string) scope_module.str() + "." + rec->name)
                                              : std::string(rec->name));

        char *tp_doc = nullptr;
        if (rec->doc) {
            /* 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);
        }

        object type_holder(PyType_Type.tp_alloc(&PyType_Type, 0), false);
625
626
627
        auto type = (PyHeapTypeObject*) type_holder.ptr();

        if (!type_holder || !name)
628
            pybind11_fail("generic_type: unable to create type object!");
629
630
631
632

        /* 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
633
634
        tinfo->type_size = rec->type_size;
        tinfo->init_holder = rec->init_holder;
635
        internals.registered_types_cpp[tindex] = tinfo;
636
637
638
639
        internals.registered_types_py[type] = tinfo;

        /* Basic type attributes */
        type->ht_type.tp_name = strdup(full_name.c_str());
640
        type->ht_type.tp_basicsize = (ssize_t) rec->instance_size;
Wenzel Jakob's avatar
Wenzel Jakob committed
641
642
        type->ht_type.tp_base = (PyTypeObject *) rec->base_handle.ptr();
        rec->base_handle.inc_ref();
643

644
645
        type->ht_name = name.release().ptr();

646
#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
647
        type->ht_qualname = ht_qualname.release().ptr();
648
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
649

650
651
652
653
        /* 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
654

655
        /* Supported elementary operations */
Wenzel Jakob's avatar
Wenzel Jakob committed
656
657
        type->ht_type.tp_init = (initproc) init;
        type->ht_type.tp_new = (newfunc) new_instance;
Wenzel Jakob's avatar
Wenzel Jakob committed
658
        type->ht_type.tp_dealloc = rec->dealloc;
659
660

        /* Support weak references (needed for the keep_alive feature) */
661
        type->ht_type.tp_weaklistoffset = offsetof(instance_essentials<void>, weakrefs);
662
663
664

        /* Flags */
        type->ht_type.tp_flags |= Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
665
666
667
#if PY_MAJOR_VERSION < 3
        type->ht_type.tp_flags |= Py_TPFLAGS_CHECKTYPES;
#endif
668
        type->ht_type.tp_flags &= ~Py_TPFLAGS_HAVE_GC;
669

670
        type->ht_type.tp_doc = tp_doc;
Wenzel Jakob's avatar
Wenzel Jakob committed
671
672

        if (PyType_Ready(&type->ht_type) < 0)
673
            pybind11_fail("generic_type: PyType_Ready failed!");
674
675

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

677
        if (scope_module) // Needed by pydoc
Wenzel Jakob's avatar
Wenzel Jakob committed
678
            attr("__module__") = scope_module;
Wenzel Jakob's avatar
Wenzel Jakob committed
679

680
        /* Register type with the parent scope */
681
682
        if (rec->scope)
            rec->scope.attr(handle(type->ht_name)) = *this;
Wenzel Jakob's avatar
Wenzel Jakob committed
683

684
        type_holder.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
685
686
    }

687
    /// Allocate a metaclass on demand (for static properties)
Wenzel Jakob's avatar
Wenzel Jakob committed
688
689
    handle metaclass() {
        auto &ht_type = ((PyHeapTypeObject *) m_ptr)->ht_type;
690
        auto &ob_type = PYBIND11_OB_TYPE(ht_type);
691

Wenzel Jakob's avatar
Wenzel Jakob committed
692
        if (ob_type == &PyType_Type) {
693
            std::string name_ = std::string(ht_type.tp_name) + "__Meta";
694
695
696
697
#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
            object ht_qualname(PyUnicode_FromFormat(
                "%U__Meta", ((object) attr("__qualname__")).ptr()), false);
#endif
698
            object name(PYBIND11_FROM_STRING(name_.c_str()), false);
699
            object type_holder(PyType_Type.tp_alloc(&PyType_Type, 0), false);
700
            if (!type_holder || !name)
701
                pybind11_fail("generic_type::metaclass(): unable to create type object!");
702
703

            auto type = (PyHeapTypeObject*) type_holder.ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
704
            type->ht_name = name.release().ptr();
705

Wenzel Jakob's avatar
Wenzel Jakob committed
706
707
#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
            /* Qualified names for Python >= 3.3 */
708
            type->ht_qualname = ht_qualname.release().ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
709
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
710
            type->ht_type.tp_name = strdup(name_.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
711
            type->ht_type.tp_base = ob_type;
712
713
714
            type->ht_type.tp_flags |= (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE) &
                                      ~Py_TPFLAGS_HAVE_GC;

Wenzel Jakob's avatar
Wenzel Jakob committed
715
            if (PyType_Ready(&type->ht_type) < 0)
716
                pybind11_fail("generic_type::metaclass(): PyType_Ready failed!");
717

Wenzel Jakob's avatar
Wenzel Jakob committed
718
            ob_type = (PyTypeObject *) type_holder.release().ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
719
720
721
722
723
724
725
726
727
728
729
        }
        return handle((PyObject *) ob_type);
    }

    static int init(void *self, PyObject *, PyObject *) {
        std::string msg = std::string(Py_TYPE(self)->tp_name) + ": No constructor defined!";
        PyErr_SetString(PyExc_TypeError, msg.c_str());
        return -1;
    }

    static PyObject *new_instance(PyTypeObject *type, PyObject *, PyObject *) {
730
731
732
        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
733
734
        self->owned = true;
        self->constructed = false;
735
        detail::get_internals().registered_instances.emplace(self->value, (PyObject *) self);
Wenzel Jakob's avatar
Wenzel Jakob committed
736
737
738
739
740
        return (PyObject *) self;
    }

    static void dealloc(instance<void> *self) {
        if (self->value) {
741
742
743
744
745
746
747
748
749
750
            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
751
            }
752
753
754
            if (!found)
                pybind11_fail("generic_type::dealloc(): Tried to deallocate unregistered instance!");

755
756
            if (self->weakrefs)
                PyObject_ClearWeakRefs((PyObject *) self);
Wenzel Jakob's avatar
Wenzel Jakob committed
757
758
759
760
        }
        Py_TYPE(self)->tp_free((PyObject*) self);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
761
762
763
    void install_buffer_funcs(
            buffer_info *(*get_buffer)(PyObject *, void *),
            void *get_buffer_data) {
Wenzel Jakob's avatar
Wenzel Jakob committed
764
765
        PyHeapTypeObject *type = (PyHeapTypeObject*) m_ptr;
        type->ht_type.tp_as_buffer = &type->as_buffer;
766
767
768
#if PY_MAJOR_VERSION < 3
        type->ht_type.tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER;
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
769
770
        type->as_buffer.bf_getbuffer = getbuffer;
        type->as_buffer.bf_releasebuffer = releasebuffer;
771
772
773
        auto tinfo = detail::get_type_info(&type->ht_type);
        tinfo->get_buffer = get_buffer;
        tinfo->get_buffer_data = get_buffer_data;
Wenzel Jakob's avatar
Wenzel Jakob committed
774
775
776
    }

    static int getbuffer(PyObject *obj, Py_buffer *view, int flags) {
777
778
779
        auto tinfo = detail::get_type_info(Py_TYPE(obj));
        if (view == nullptr || obj == nullptr || !tinfo || !tinfo->get_buffer) {
            PyErr_SetString(PyExc_BufferError, "generic_type::getbuffer(): Internal error");
Wenzel Jakob's avatar
Wenzel Jakob committed
780
781
782
            return -1;
        }
        memset(view, 0, sizeof(Py_buffer));
783
        buffer_info *info = tinfo->get_buffer(obj, tinfo->get_buffer_data);
Wenzel Jakob's avatar
Wenzel Jakob committed
784
785
786
787
        view->obj = obj;
        view->ndim = 1;
        view->internal = info;
        view->buf = info->ptr;
788
        view->itemsize = (ssize_t) info->itemsize;
Wenzel Jakob's avatar
Wenzel Jakob committed
789
790
791
792
793
794
        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) {
795
            view->ndim = (int) info->ndim;
796
797
            view->strides = (ssize_t *) &info->strides[0];
            view->shape = (ssize_t *) &info->shape[0];
Wenzel Jakob's avatar
Wenzel Jakob committed
798
799
800
801
802
803
804
        }
        Py_INCREF(view->obj);
        return 0;
    }

    static void releasebuffer(PyObject *, Py_buffer *view) { delete (buffer_info *) view->internal; }
};
805
806
807
808
809
810
811
812
813
814
815
816
817
818

template <template<typename> class Predicate, typename... BaseTypes> struct class_selector;
template <template<typename> class Predicate, typename Base, typename... Bases>
struct class_selector<Predicate, Base, Bases...> {
    static inline void set_bases(detail::type_record &record) {
        if (Predicate<Base>::value) record.base_type = &typeid(Base);
        else class_selector<Predicate, Bases...>::set_bases(record);
    }
};
template <template<typename> class Predicate>
struct class_selector<Predicate> {
    static inline void set_bases(detail::type_record &) {}
};

Wenzel Jakob's avatar
Wenzel Jakob committed
819
820
NAMESPACE_END(detail)

821
template <typename type_, typename... options>
Wenzel Jakob's avatar
Wenzel Jakob committed
822
class class_ : public detail::generic_type {
823
824
    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>;
825
    template <typename T> using is_base_class = detail::bool_constant<std::is_base_of<T, type_>::value && !std::is_same<T, type_>::value>;
826
827
828
    template <typename T> using is_valid_class_option =
        detail::bool_constant<
            is_holder<T>::value ||
829
830
            is_subtype<T>::value ||
            is_base_class<T>::value
831
832
        >;

Wenzel Jakob's avatar
Wenzel Jakob committed
833
public:
834
    using type = type_;
835
    using type_alias = detail::first_of_t<is_subtype, void, options...>;
836
    constexpr static bool has_alias = !std::is_void<type_alias>::value;
837
    using holder_type = detail::first_of_t<is_holder, std::unique_ptr<type>, options...>;
838
839
840
841
    using instance_type = detail::instance<type, holder_type>;

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

843
844
845
    static_assert(detail::count_t<is_base_class, options...>::value <= 1,
            "Invalid class_ base types: multiple inheritance is not supported");

846
    PYBIND11_OBJECT(class_, detail::generic_type, PyType_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
847

Wenzel Jakob's avatar
Wenzel Jakob committed
848
849
850
851
852
853
854
855
856
857
858
    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);
        record.type_size = sizeof(type);
        record.instance_size = sizeof(instance_type);
        record.init_holder = init_holder;
        record.dealloc = dealloc;

859
860
        detail::class_selector<is_base_class, options...>::set_bases(record);

Wenzel Jakob's avatar
Wenzel Jakob committed
861
862
863
864
        /* Process optional arguments, if any */
        detail::process_attributes<Extra...>::init(extra..., &record);

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

866
        if (has_alias) {
867
868
869
            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
870
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
871

872
    template <typename Func, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
873
    class_ &def(const char *name_, Func&& f, const Extra&... extra) {
874
        cpp_function cf(std::forward<Func>(f), name(name_),
Wenzel Jakob's avatar
Wenzel Jakob committed
875
876
                        sibling(attr(name_)), is_method(*this),
                        extra...);
877
        attr(cf.name()) = cf;
Wenzel Jakob's avatar
Wenzel Jakob committed
878
879
880
        return *this;
    }

881
    template <typename Func, typename... Extra> class_ &
Wenzel Jakob's avatar
Wenzel Jakob committed
882
    def_static(const char *name_, Func f, const Extra&... extra) {
883
        cpp_function cf(std::forward<Func>(f), name(name_),
884
                        sibling(attr(name_)), scope(*this), extra...);
885
        attr(cf.name()) = cf;
Wenzel Jakob's avatar
Wenzel Jakob committed
886
887
888
        return *this;
    }

889
    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
890
    class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
891
        op.execute(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
892
893
894
        return *this;
    }

895
    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
896
    class_ & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
897
        op.execute_cast(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
898
899
900
        return *this;
    }

901
    template <typename... Args, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
902
    class_ &def(const detail::init<Args...> &init, const Extra&... extra) {
903
        init.execute(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
904
905
906
        return *this;
    }

907
908
    template <typename... Args, typename... Extra>
    class_ &def(const detail::init_alias<Args...> &init, const Extra&... extra) {
909
        init.execute(*this, extra...);
910
911
912
        return *this;
    }

913
    template <typename Func> class_& def_buffer(Func &&func) {
Wenzel Jakob's avatar
Wenzel Jakob committed
914
915
916
        struct capture { Func func; };
        capture *ptr = new capture { std::forward<Func>(func) };
        install_buffer_funcs([](PyObject *obj, void *ptr) -> buffer_info* {
Wenzel Jakob's avatar
Wenzel Jakob committed
917
918
919
            detail::type_caster<type> caster;
            if (!caster.load(obj, false))
                return nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
920
921
            return new buffer_info(((capture *) ptr)->func(caster));
        }, ptr);
Wenzel Jakob's avatar
Wenzel Jakob committed
922
923
924
        return *this;
    }

925
    template <typename C, typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
926
    class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
927
928
929
        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
930
931
932
        return *this;
    }

933
    template <typename C, typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
934
    class_ &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) {
935
936
        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
937
938
939
        return *this;
    }

940
    template <typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
941
    class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
942
943
944
        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
945
946
947
        return *this;
    }

948
    template <typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
949
    class_ &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
950
951
        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
952
953
954
        return *this;
    }

955
956
957
    template <typename... Extra>
    class_ &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) {
        def_property(name, fget, cpp_function(), extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
958
959
960
        return *this;
    }

961
962
963
    template <typename... Extra>
    class_ &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) {
        def_property_static(name, fget, cpp_function(), extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
964
965
966
        return *this;
    }

967
968
    template <typename... Extra>
    class_ &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
969
        return def_property_static(name, fget, fset, is_method(*this), extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
970
971
    }

972
973
974
    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);
975
        char *doc_prev = rec_fget->doc; /* 'extra' field may include a property-specific documentation string */
976
        detail::process_attributes<Extra...>::init(extra..., rec_fget);
977
978
979
980
981
982
        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;
983
            detail::process_attributes<Extra...>::init(extra..., rec_fset);
984
985
986
987
988
            if (rec_fset->doc && rec_fset->doc != doc_prev) {
                free(doc_prev);
                rec_fset->doc = strdup(rec_fset->doc);
            }
        }
989
        pybind11::str doc_obj = pybind11::str(rec_fget->doc ? rec_fget->doc : "");
Wenzel Jakob's avatar
Wenzel Jakob committed
990
        object property(
Wenzel Jakob's avatar
Wenzel Jakob committed
991
992
            PyObject_CallFunctionObjArgs((PyObject *) &PyProperty_Type, fget.ptr() ? fget.ptr() : Py_None,
                                         fset.ptr() ? fset.ptr() : Py_None, Py_None, doc_obj.ptr(), nullptr), false);
993
994
995
996
        if (rec_fget->class_)
            attr(name) = property;
        else
            metaclass().attr(name) = property;
Wenzel Jakob's avatar
Wenzel Jakob committed
997
998
        return *this;
    }
999

Wenzel Jakob's avatar
Wenzel Jakob committed
1000
private:
1001
1002
1003
    /// 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 */) {
1004
        try {
1005
            new (&inst->holder) holder_type(std::static_pointer_cast<typename holder_type::element_type>(inst->value->shared_from_this()));
1006
1007
1008
        } catch (const std::bad_weak_ptr &) {
            new (&inst->holder) holder_type(inst->value);
        }
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
    }

    /// Initialize holder object, variant 2: try to construct from existing holder object, if possible
    template <typename T = holder_type,
              typename std::enable_if<std::is_copy_constructible<T>::value, int>::type = 0>
    static void init_holder_helper(instance_type *inst, const holder_type *holder_ptr, const void * /* dummy */) {
        if (holder_ptr)
            new (&inst->holder) holder_type(*holder_ptr);
        else
            new (&inst->holder) holder_type(inst->value);
    }

    /// Initialize holder object, variant 3: holder is not copy constructible (e.g. unique_ptr), always initialize from raw pointer
    template <typename T = holder_type,
              typename std::enable_if<!std::is_copy_constructible<T>::value, int>::type = 0>
    static void init_holder_helper(instance_type *inst, const holder_type * /* unused */, const void * /* dummy */) {
        new (&inst->holder) holder_type(inst->value);
    }

    /// 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);
1032
1033
1034
        inst->constructed = true;
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
1035
1036
1037
1038
1039
1040
1041
1042
    static void dealloc(PyObject *inst_) {
        instance_type *inst = (instance_type *) inst_;
        if (inst->owned) {
            if (inst->constructed)
                inst->holder.~holder_type();
            else
                ::operator delete(inst->value);
        }
1043
        generic_type::dealloc((detail::instance<void> *) inst);
Wenzel Jakob's avatar
Wenzel Jakob committed
1044
    }
1045
1046
1047
1048
1049
1050

    static detail::function_record *get_function_record(handle h) {
        h = detail::get_function(h);
        return h ? (detail::function_record *) capsule(
               PyCFunction_GetSelf(h.ptr()), true) : nullptr;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1051
1052
1053
1054
1055
};

/// Binds C++ enumerations and enumeration classes to Python
template <typename Type> class enum_ : public class_<Type> {
public:
1056
    using class_<Type>::def;
1057
    using UnderlyingType = typename std::underlying_type<Type>::type;
Wenzel Jakob's avatar
Wenzel Jakob committed
1058
1059
1060
    template <typename... Extra>
    enum_(const handle &scope, const char *name, const Extra&... extra)
      : class_<Type>(scope, name, extra...), m_parent(scope) {
1061
        auto entries = new std::unordered_map<UnderlyingType, const char *>();
1062
        def("__repr__", [name, entries](Type value) -> std::string {
1063
            auto it = entries->find((UnderlyingType) value);
Wenzel Jakob's avatar
Wenzel Jakob committed
1064
1065
1066
1067
            return std::string(name) + "." +
                ((it == entries->end()) ? std::string("???")
                                        : std::string(it->second));
        });
1068
1069
1070
1071
1072
        def("__init__", [](Type& value, UnderlyingType i) { value = (Type)i; });
        def("__init__", [](Type& value, UnderlyingType i) { new (&value) Type((Type) i); });
        def("__int__", [](Type value) { return (UnderlyingType) value; });
        def("__eq__", [](const Type &value, Type *value2) { return value2 && value == *value2; });
        def("__ne__", [](const Type &value, Type *value2) { return !value2 || value != *value2; });
1073
1074
1075
1076
        if (std::is_convertible<Type, UnderlyingType>::value) {
            // 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
            // convert Type to UnderlyingType below anyway because this needs to compile).
1077
1078
            def("__eq__", [](const Type &value, UnderlyingType value2) { return (UnderlyingType) value == value2; });
            def("__ne__", [](const Type &value, UnderlyingType value2) { return (UnderlyingType) value != value2; });
1079
        }
1080
        def("__hash__", [](const Type &value) { return (UnderlyingType) value; });
Wenzel Jakob's avatar
Wenzel Jakob committed
1081
        // Pickling and unpickling -- needed for use with the 'multiprocessing' module
1082
1083
        def("__getstate__", [](const Type &value) { return pybind11::make_tuple((UnderlyingType) value); });
        def("__setstate__", [](Type &p, tuple t) { new (&p) Type((Type) t[0].cast<UnderlyingType>()); });
Wenzel Jakob's avatar
Wenzel Jakob committed
1084
1085
1086
1087
1088
1089
1090
        m_entries = entries;
    }

    /// Export enumeration entries into the parent scope
    void export_values() {
        PyObject *dict = ((PyTypeObject *) this->m_ptr)->tp_dict;
        PyObject *key, *value;
1091
        ssize_t pos = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
1092
1093
1094
1095
1096
1097
1098
        while (PyDict_Next(dict, &pos, &key, &value))
            if (PyObject_IsInstance(value, this->m_ptr))
                m_parent.attr(key) = value;
    }

    /// Add an enumeration entry
    enum_& value(char const* name, Type value) {
1099
        this->attr(name) = pybind11::cast(value, return_value_policy::copy);
1100
        (*m_entries)[(UnderlyingType) value] = name;
Wenzel Jakob's avatar
Wenzel Jakob committed
1101
1102
1103
        return *this;
    }
private:
1104
    std::unordered_map<UnderlyingType, const char *> *m_entries;
Wenzel Jakob's avatar
Wenzel Jakob committed
1105
    handle m_parent;
Wenzel Jakob's avatar
Wenzel Jakob committed
1106
1107
1108
};

NAMESPACE_BEGIN(detail)
1109
template <typename... Args> struct init {
1110
1111
1112
    template <typename Class, typename... Extra, typename std::enable_if<!Class::has_alias, int>::type = 0>
    void execute(Class &cl, const Extra&... extra) const {
        using Base = typename Class::type;
Wenzel Jakob's avatar
Wenzel Jakob committed
1113
        /// Function which calls a specific C++ in-place constructor
1114
        cl.def("__init__", [](Base *self_, Args... args) { new (self_) Base(args...); }, extra...);
1115
1116
    }

1117
1118
1119
1120
1121
1122
1123
1124
    template <typename Class, typename... Extra,
              typename std::enable_if<Class::has_alias &&
                                       std::is_constructible<typename Class::type, Args...>::value, int>::type = 0>
    void execute(Class &cl, const Extra&... extra) const {
        using Base = typename Class::type;
        using Alias = typename Class::type_alias;
        handle cl_type = cl;
        cl.def("__init__", [cl_type](handle self_, Args... args) {
1125
1126
                if (self_.get_type() == cl_type)
                    new (self_.cast<Base *>()) Base(args...);
1127
                else
1128
                    new (self_.cast<Alias *>()) Alias(args...);
1129
1130
1131
            }, extra...);
    }

1132
1133
1134
1135
1136
1137
    template <typename Class, typename... Extra,
              typename std::enable_if<Class::has_alias &&
                                      !std::is_constructible<typename Class::type, Args...>::value, int>::type = 0>
    void execute(Class &cl, const Extra&... extra) const {
        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
1138
1139
    }
};
1140

1141
inline void keep_alive_impl(handle nurse, handle patient) {
1142
    /* Clever approach based on weak references taken from Boost.Python */
1143
    if (!nurse || !patient)
1144
        pybind11_fail("Could not activate keep_alive!");
1145

1146
    if (patient.is_none() || nurse.is_none())
1147
        return; /* Nothing to keep alive or nothing to be kept alive by */
1148

1149
    cpp_function disable_lifesupport(
1150
        [patient](handle weakref) { patient.dec_ref(); weakref.dec_ref(); });
1151

1152
    weakref wr(nurse, disable_lifesupport);
1153

1154
1155
    patient.inc_ref(); /* reference patient and leak the weak reference */
    (void) wr.release();
1156
1157
}

1158
1159
1160
1161
1162
1163
1164
PYBIND11_NOINLINE inline void keep_alive_impl(int Nurse, int Patient, handle args, handle ret) {
    handle nurse  (Nurse   > 0 ? PyTuple_GetItem(args.ptr(), Nurse   - 1) : ret.ptr());
    handle patient(Patient > 0 ? PyTuple_GetItem(args.ptr(), Patient - 1) : ret.ptr());

    keep_alive_impl(nurse, patient);
}

1165
template <typename Iterator, typename Sentinel, bool KeyIterator, typename... Extra>
1166
1167
1168
struct iterator_state {
    Iterator it;
    Sentinel end;
1169
1170
    bool first;
};
1171

Wenzel Jakob's avatar
Wenzel Jakob committed
1172
1173
NAMESPACE_END(detail)

1174
template <typename... Args> detail::init<Args...> init() { return detail::init<Args...>(); }
Wenzel Jakob's avatar
Wenzel Jakob committed
1175

1176
template <typename Iterator,
1177
          typename Sentinel,
1178
1179
          typename ValueType = decltype(*std::declval<Iterator>()),
          typename... Extra>
1180
iterator make_iterator(Iterator first, Sentinel last, Extra &&... extra) {
1181
    typedef detail::iterator_state<Iterator, Sentinel, false, Extra...> state;
1182
1183

    if (!detail::get_type_info(typeid(state))) {
1184
        class_<state>(handle(), "iterator")
1185
            .def("__iter__", [](state &s) -> state& { return s; })
1186
            .def("__next__", [](state &s) -> ValueType {
1187
1188
1189
1190
                if (!s.first)
                    ++s.it;
                else
                    s.first = false;
1191
1192
                if (s.it == s.end)
                    throw stop_iteration();
1193
                return *s.it;
1194
1195
1196
            }, return_value_policy::reference_internal, std::forward<Extra>(extra)...);
    }

1197
    return (iterator) cast(state { first, last, true });
1198
}
1199

1200
template <typename Iterator,
1201
          typename Sentinel,
1202
          typename KeyType = decltype((*std::declval<Iterator>()).first),
1203
          typename... Extra>
1204
iterator make_key_iterator(Iterator first, Sentinel last, Extra &&... extra) {
1205
    typedef detail::iterator_state<Iterator, Sentinel, true, Extra...> state;
1206
1207

    if (!detail::get_type_info(typeid(state))) {
1208
        class_<state>(handle(), "iterator")
1209
1210
1211
1212
1213
1214
1215
1216
            .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();
1217
                return (*s.it).first;
1218
1219
1220
1221
1222
            }, return_value_policy::reference_internal, std::forward<Extra>(extra)...);
    }

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

1224
1225
1226
1227
template <typename Type, typename... Extra> iterator make_iterator(Type &value, Extra&&... extra) {
    return make_iterator(std::begin(value), std::end(value), extra...);
}

1228
1229
1230
1231
template <typename Type, typename... Extra> iterator make_key_iterator(Type &value, Extra&&... extra) {
    return make_key_iterator(std::begin(value), std::end(value), extra...);
}

Wenzel Jakob's avatar
Wenzel Jakob committed
1232
template <typename InputType, typename OutputType> void implicitly_convertible() {
1233
    auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject * {
Wenzel Jakob's avatar
Wenzel Jakob committed
1234
1235
1236
1237
1238
1239
1240
1241
1242
        if (!detail::type_caster<InputType>().load(obj, false))
            return nullptr;
        tuple args(1);
        args[0] = obj;
        PyObject *result = PyObject_Call((PyObject *) type, args.ptr(), nullptr);
        if (result == nullptr)
            PyErr_Clear();
        return result;
    };
1243
1244
    auto &registered_types = detail::get_internals().registered_types_cpp;
    auto it = registered_types.find(std::type_index(typeid(OutputType)));
Wenzel Jakob's avatar
Wenzel Jakob committed
1245
    if (it == registered_types.end())
1246
        pybind11_fail("implicitly_convertible: Unable to find type " + type_id<OutputType>());
1247
    ((detail::type_info *) it->second)->implicit_conversions.push_back(implicit_caster);
Wenzel Jakob's avatar
Wenzel Jakob committed
1248
1249
}

1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
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:
    exception(module &m, const std::string name, PyObject* base=PyExc_Exception) {
        std::string full_name = std::string(PyModule_GetName(m.ptr()))
                + std::string(".") + name;
        char* exception_name = const_cast<char*>(full_name.c_str());
        m_ptr = PyErr_NewException(exception_name, base, NULL);
        inc_ref(); // PyModule_AddObject() steals a reference
        PyModule_AddObject(m.ptr(), name.c_str(), m_ptr);
    }
};

Dean Moldovan's avatar
Dean Moldovan committed
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
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) {
        strings[i] = args[i].cast<object>().str();
    }
    auto sep = kwargs["sep"] ? kwargs["sep"] : cast(" ");
    auto line = sep.attr("join").cast<object>()(strings);

    auto file = kwargs["file"] ? kwargs["file"].cast<object>()
                               : module::import("sys").attr("stdout");
    auto write = file.attr("write").cast<object>();
    write(line);
    write(kwargs["end"] ? kwargs["end"] : cast("\n"));

    if (kwargs["flush"] && kwargs["flush"].cast<bool>()) {
        file.attr("flush").cast<object>()();
    }
}
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());
}

1302
#if defined(WITH_THREAD)
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316

/* 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
1317
1318
 *    thread would otherwise constantly construct and destroy thread state data
 *    structures.
1319
1320
1321
1322
1323
 *
 * 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).
1324
 */
Wenzel Jakob's avatar
Wenzel Jakob committed
1325
1326
1327

class gil_scoped_acquire {
public:
1328
    PYBIND11_NOINLINE gil_scoped_acquire() {
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
        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;
1339
1340
1341
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(internals.tstate);
            #endif
1342
1343
            PyThread_set_key_value(internals.tstate, tstate);
        } else {
1344
            release = detail::get_thread_state_unchecked() != tstate;
1345
1346
1347
1348
        }

        if (release) {
            /* Work around an annoying assertion in PyThreadState_Swap */
1349
1350
1351
1352
            #if defined(Py_DEBUG)
                PyInterpreterState *interp = tstate->interp;
                tstate->interp = nullptr;
            #endif
1353
            PyEval_AcquireThread(tstate);
1354
1355
1356
            #if defined(Py_DEBUG)
                tstate->interp = interp;
            #endif
1357
1358
1359
1360
1361
1362
1363
1364
1365
        }

        inc_ref();
    }

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

1366
    PYBIND11_NOINLINE void dec_ref() {
1367
1368
        --tstate->gilstate_counter;
        #if !defined(NDEBUG)
1369
            if (detail::get_thread_state_unchecked() != tstate)
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
                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();
1381
            PyThread_delete_key_value(detail::get_internals().tstate);
1382
1383
1384
1385
            release = false;
        }
    }

1386
    PYBIND11_NOINLINE ~gil_scoped_acquire() {
1387
1388
1389
1390
1391
1392
1393
        dec_ref();
        if (release)
           PyEval_SaveThread();
    }
private:
    PyThreadState *tstate = nullptr;
    bool release = true;
Wenzel Jakob's avatar
Wenzel Jakob committed
1394
1395
1396
1397
};

class gil_scoped_release {
public:
1398
1399
    gil_scoped_release(bool disassoc = false) : disassoc(disassoc) {
        tstate = PyEval_SaveThread();
1400
        if (disassoc) {
1401
            auto key = detail::get_internals().tstate;
1402
1403
1404
1405
1406
1407
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(key);
            #else
                PyThread_set_key_value(key, nullptr);
            #endif
        }
1408
1409
1410
1411
1412
    }
    ~gil_scoped_release() {
        if (!tstate)
            return;
        PyEval_RestoreThread(tstate);
1413
        if (disassoc) {
1414
            auto key = detail::get_internals().tstate;
1415
1416
1417
1418
1419
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(key);
            #endif
            PyThread_set_key_value(key, tstate);
        }
1420
1421
1422
1423
    }
private:
    PyThreadState *tstate;
    bool disassoc;
Wenzel Jakob's avatar
Wenzel Jakob committed
1424
};
1425
1426
1427
#else
class gil_scoped_acquire { };
class gil_scoped_release { };
1428
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
1429

1430
1431
inline function get_type_overload(const void *this_ptr, const detail::type_info *this_type, const char *name)  {
    handle py_object = detail::get_object_handle(this_ptr, this_type);
1432
1433
    if (!py_object)
        return function();
1434
1435
1436
    handle type = py_object.get_type();
    auto key = std::make_pair(type.ptr(), name);

1437
1438
    /* Cache functions that aren't overloaded in Python to avoid
       many costly Python dictionary lookups below */
1439
1440
1441
1442
1443
1444
1445
1446
1447
    auto &cache = detail::get_internals().inactive_overload_cache;
    if (cache.find(key) != cache.end())
        return function();

    function overload = (function) py_object.attr(name);
    if (overload.is_cpp_function()) {
        cache.insert(key);
        return function();
    }
1448

1449
    /* Don't call dispatch code if invoked from overridden function */
1450
    PyFrameObject *frame = PyThreadState_Get()->frame;
1451
    if (frame && (std::string) pybind11::handle(frame->f_code->co_name).str() == name &&
1452
1453
1454
1455
1456
1457
1458
        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));
        if (self_caller == py_object.ptr())
            return function();
    }
1459
1460
1461
    return overload;
}

1462
1463
1464
1465
1466
1467
1468
1469
template <class T> function get_overload(const T *this_ptr, const char *name) {
    auto &cpp_types = detail::get_internals().registered_types_cpp;
    auto it = cpp_types.find(typeid(T));
    if (it == cpp_types.end())
        return function();
    return get_type_overload(this_ptr, (const detail::type_info *) it->second, name);
}

1470
#define PYBIND11_OVERLOAD_INT(ret_type, cname, name, ...) { \
1471
        pybind11::gil_scoped_acquire gil; \
1472
        pybind11::function overload = pybind11::get_overload(static_cast<const cname *>(this), name); \
1473
        if (overload) \
1474
            return overload(__VA_ARGS__).template cast<ret_type>();  }
1475

1476
#define PYBIND11_OVERLOAD_NAME(ret_type, cname, name, fn, ...) \
1477
    PYBIND11_OVERLOAD_INT(ret_type, cname, name, __VA_ARGS__) \
1478
    return cname::fn(__VA_ARGS__)
1479

1480
#define PYBIND11_OVERLOAD_PURE_NAME(ret_type, cname, name, fn, ...) \
1481
    PYBIND11_OVERLOAD_INT(ret_type, cname, name, __VA_ARGS__) \
1482
1483
1484
1485
1486
1487
1488
    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__)
1489

1490
NAMESPACE_END(pybind11)
Wenzel Jakob's avatar
Wenzel Jakob committed
1491
1492

#if defined(_MSC_VER)
Wenzel Jakob's avatar
Wenzel Jakob committed
1493
#  pragma warning(pop)
1494
1495
#elif defined(__INTEL_COMPILER)
/* Leave ignored warnings on */
1496
#elif defined(__GNUG__) && !defined(__clang__)
Wenzel Jakob's avatar
Wenzel Jakob committed
1497
#  pragma GCC diagnostic pop
Wenzel Jakob's avatar
Wenzel Jakob committed
1498
#endif