pybind11.h 72.8 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
87
        static_assert(detail::expected_num_args<Extra...>(sizeof...(Args)),
                      "The number of named arguments does not match the function signature");

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

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

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

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

119
        /* Dispatch code which converts function arguments and performs the actual function call */
120
        rec->impl = [](detail::function_record *rec, handle args, handle kwargs, handle parent) -> handle {
121
            cast_in args_converter;
122
123

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

Wenzel Jakob's avatar
Wenzel Jakob committed
127
            /* Invoke call policy pre-call hook */
128
129
130
131
132
            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]);
133

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

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

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

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

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

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

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

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

        /* Stash some additional information used by an important optimization in 'functional.h' */
163
        using FunctionType = Return (*)(Args...) PYBIND11_NOEXCEPT_SPECIFIER;
164
165
166
167
168
169
170
        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);
        }
171
172
    }

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

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

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

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

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

#if PY_MAJOR_VERSION < 3
Wenzel Jakob's avatar
Wenzel Jakob committed
257
258
        if (rec->sibling && PyMethod_Check(rec->sibling.ptr()))
            rec->sibling = PyMethod_GET_FUNCTION(rec->sibling.ptr());
259
#endif
260

Wenzel Jakob's avatar
Wenzel Jakob committed
261
        detail::function_record *chain = nullptr, *chain_start = rec;
262
263
        if (rec->sibling) {
            if (PyCFunction_Check(rec->sibling.ptr())) {
264
                auto rec_capsule = reinterpret_borrow<capsule>(PyCFunction_GetSelf(rec->sibling.ptr()));
265
266
267
                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 */
268
                if (chain->scope != rec->scope)
269
270
271
272
273
274
                    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");
275
276
        }

Wenzel Jakob's avatar
Wenzel Jakob committed
277
        if (!chain) {
278
            /* No existing overload was found, create a new function object */
Wenzel Jakob's avatar
Wenzel Jakob committed
279
280
281
282
283
            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;
284

Wenzel Jakob's avatar
Wenzel Jakob committed
285
286
            capsule rec_capsule(rec, [](PyObject *o) {
                destruct((detail::function_record *) PyCapsule_GetPointer(o, nullptr));
287
            });
288
289
290

            object scope_module;
            if (rec->scope) {
291
292
293
294
295
                if (hasattr(rec->scope, "__module__")) {
                    scope_module = rec->scope.attr("__module__");
                } else if (hasattr(rec->scope, "__name__")) {
                    scope_module = rec->scope.attr("__name__");
                }
296
297
298
            }

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

Wenzel Jakob's avatar
Wenzel Jakob committed
311
        std::string signatures;
312
        int index = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
313
        /* Create a nice pydoc rec including all signatures and
314
           docstrings of the functions in the overload chain */
315
        if (chain && options::show_function_signatures()) {
316
317
318
319
320
321
            // 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
322
        for (auto it = chain_start; it != nullptr; it = it->next) {
323
324
325
326
327
            if (options::show_function_signatures()) {
                if (chain)
                    signatures += std::to_string(++index) + ". ";
                signatures += rec->name;
                signatures += it->signature;
328
                signatures += "\n";
329
330
331
            }
            if (it->doc && strlen(it->doc) > 0 && options::show_user_defined_docstrings()) {
                if (options::show_function_signatures()) signatures += "\n";
332
                signatures += it->doc;
333
                if (options::show_function_signatures()) signatures += "\n";
334
            }
335
            if (it->next)
Wenzel Jakob's avatar
Wenzel Jakob committed
336
337
                signatures += "\n";
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
338
339

        /* Install docstring */
Wenzel Jakob's avatar
Wenzel Jakob committed
340
341
        PyCFunctionObject *func = (PyCFunctionObject *) m_ptr;
        if (func->m_ml->ml_doc)
342
            std::free((char *) func->m_ml->ml_doc);
Wenzel Jakob's avatar
Wenzel Jakob committed
343
        func->m_ml->ml_doc = strdup(signatures.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
344

345
346
        if (rec->is_method) {
            m_ptr = PYBIND11_INSTANCE_METHOD_NEW(m_ptr, rec->scope.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
347
            if (!m_ptr)
348
                pybind11_fail("cpp_function::cpp_function(): Could not allocate instance method object");
Wenzel Jakob's avatar
Wenzel Jakob committed
349
350
351
            Py_DECREF(func);
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
352
353
354
355
356
357

    /// 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)
358
                rec->free_data(rec);
Wenzel Jakob's avatar
Wenzel Jakob committed
359
360
361
362
363
364
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
    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 */
383
384
        size_t nargs = (size_t) PyTuple_GET_SIZE(args),
               nkwargs = kwargs ? (size_t) PyDict_Size(kwargs) : 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
385

386
        handle parent = nargs > 0 ? PyTuple_GET_ITEM(args, 0) : nullptr,
Wenzel Jakob's avatar
Wenzel Jakob committed
387
388
389
               result = PYBIND11_TRY_NEXT_OVERLOAD;
        try {
            for (; it != nullptr; it = it->next) {
390
                auto args_ = reinterpret_borrow<tuple>(args);
391
                size_t kwargs_consumed = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
392
393
394
395
396
397
398
399

                /* 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)
                 */
400
401
402
403
404
                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
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
                        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 {
427
                            kwargs_consumed = (size_t) -1; /* definite failure */
Wenzel Jakob's avatar
Wenzel Jakob committed
428
429
430
431
                            break;
                        }
                    }
                }
432
433

                try {
434
435
436
                    if ((kwargs_consumed == nkwargs || it->has_kwargs) &&
                        (nargs_ == it->nargs || it->has_args))
                        result = it->impl(it, args_, kwargs, parent);
437
                } catch (reference_cast_error &) {
438
439
                    result = PYBIND11_TRY_NEXT_OVERLOAD;
                }
Wenzel Jakob's avatar
Wenzel Jakob committed
440
441
442
443

                if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD)
                    break;
            }
444
445
        } catch (error_already_set &e) {
            e.restore();
446
            return nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
447
        } catch (...) {
448
449
450
            /* When an exception is caught, give each registered exception
               translator a chance to translate it to a Python exception
               in reverse order of registration.
451

452
               A translator may choose to do one of the following:
453

454
455
456
457
458
                - 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. */

459
            auto last_exception = std::current_exception();
460
461
462
463
464
465
466
467
468
469
470
            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
471
472
473
474
            return nullptr;
        }

        if (result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) {
475
476
477
            if (overloads->is_operator)
                return handle(Py_NotImplemented).inc_ref().ptr();

478
479
480
481
            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
482
483
484
            int ctr = 0;
            for (detail::function_record *it2 = overloads; it2 != nullptr; it2 = it2->next) {
                msg += "    "+ std::to_string(++ctr) + ". ";
485
486
487

                bool wrote_sig = false;
                if (overloads->is_constructor) {
488
                    // For a constructor, rewrite `(self: Object, arg0, ...) -> NoneType` as `Object(arg0, ...)`
489
                    std::string sig = it2->signature;
490
                    size_t start = sig.find('(') + 7; // skip "(self: "
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
                    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
507
508
                msg += "\n";
            }
509
            msg += "\nInvoked with: ";
510
            auto args_ = reinterpret_borrow<tuple>(args);
511
            for (size_t ti = overloads->is_constructor ? 1 : 0; ti < args_.size(); ++ti) {
512
                msg += pybind11::repr(args_[ti]);
513
514
515
                if ((ti + 1) != args_.size() )
                    msg += ", ";
            }
Wenzel Jakob's avatar
Wenzel Jakob committed
516
517
518
519
520
521
522
523
524
525
            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) {
526
                /* When a constructor ran successfully, the corresponding
Wenzel Jakob's avatar
Wenzel Jakob committed
527
                   holder type (e.g. std::unique_ptr) must still be initialized. */
528
                PyObject *inst = PyTuple_GET_ITEM(args, 0);
Wenzel Jakob's avatar
Wenzel Jakob committed
529
530
531
532
533
534
                auto tinfo = detail::get_type_info(Py_TYPE(inst));
                tinfo->init_holder(inst, nullptr);
            }
            return result.ptr();
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
535
536
};

537
/// Wrapper for Python extension modules
Wenzel Jakob's avatar
Wenzel Jakob committed
538
539
class module : public object {
public:
540
    PYBIND11_OBJECT_DEFAULT(module, object, PyModule_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
541

542
    explicit module(const char *name, const char *doc = nullptr) {
543
        if (!options::show_user_defined_docstrings()) doc = nullptr;
544
#if PY_MAJOR_VERSION >= 3
Wenzel Jakob's avatar
Wenzel Jakob committed
545
546
547
548
549
550
551
        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);
552
553
554
#else
        m_ptr = Py_InitModule3(name, nullptr, doc);
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
555
        if (m_ptr == nullptr)
556
            pybind11_fail("Internal error in module::module()");
Wenzel Jakob's avatar
Wenzel Jakob committed
557
558
559
        inc_ref();
    }

560
    template <typename Func, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
561
    module &def(const char *name_, Func &&f, const Extra& ... extra) {
562
563
        cpp_function func(std::forward<Func>(f), name(name_), scope(*this),
                          sibling(getattr(*this, name_, none())), extra...);
564
565
566
        // 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
567
568
569
        return *this;
    }

570
    module def_submodule(const char *name, const char *doc = nullptr) {
Wenzel Jakob's avatar
Wenzel Jakob committed
571
572
        std::string full_name = std::string(PyModule_GetName(m_ptr))
            + std::string(".") + std::string(name);
573
        auto result = reinterpret_borrow<module>(PyImport_AddModule(full_name.c_str()));
574
        if (doc && options::show_user_defined_docstrings())
575
            result.attr("__doc__") = pybind11::str(doc);
Wenzel Jakob's avatar
Wenzel Jakob committed
576
577
578
        attr(name) = result;
        return result;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
579
580

    static module import(const char *name) {
581
582
        PyObject *obj = PyImport_ImportModule(name);
        if (!obj)
583
            throw error_already_set();
584
        return reinterpret_steal<module>(obj);
Wenzel Jakob's avatar
Wenzel Jakob committed
585
    }
586
587
588
589
590
591
592
593
594
595
596
597
598
599

    // 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
600
601
602
};

NAMESPACE_BEGIN(detail)
Dean Moldovan's avatar
Dean Moldovan committed
603
extern "C" inline PyObject *get_dict(PyObject *op, void *) {
604
605
606
    PyObject *&dict = *_PyObject_GetDictPtr(op);
    if (!dict) {
        dict = PyDict_New();
Dean Moldovan's avatar
Dean Moldovan committed
607
    }
608
609
    Py_XINCREF(dict);
    return dict;
Dean Moldovan's avatar
Dean Moldovan committed
610
611
}

612
613
extern "C" inline int set_dict(PyObject *op, PyObject *new_dict, void *) {
    if (!PyDict_Check(new_dict)) {
Dean Moldovan's avatar
Dean Moldovan committed
614
        PyErr_Format(PyExc_TypeError, "__dict__ must be set to a dictionary, not a '%.200s'",
615
                     Py_TYPE(new_dict)->tp_name);
Dean Moldovan's avatar
Dean Moldovan committed
616
617
        return -1;
    }
618
619
620
621
    PyObject *&dict = *_PyObject_GetDictPtr(op);
    Py_INCREF(new_dict);
    Py_CLEAR(dict);
    dict = new_dict;
Dean Moldovan's avatar
Dean Moldovan committed
622
623
624
625
626
627
628
629
    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
630
/// Generic support for creating new Python heap types
631
class generic_type : public object {
632
    template <typename...> friend class class_;
Wenzel Jakob's avatar
Wenzel Jakob committed
633
public:
634
    PYBIND11_OBJECT_DEFAULT(generic_type, object, PyType_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
635
636
protected:
    void initialize(type_record *rec) {
637
638
639
        auto &internals = get_internals();
        auto tindex = std::type_index(*(rec->type));

640
        if (get_type_info(*(rec->type)))
641
642
643
            pybind11_fail("generic_type: type \"" + std::string(rec->name) +
                          "\" is already registered!");

644
        auto name = reinterpret_steal<object>(PYBIND11_FROM_STRING(rec->name));
645
646
        object scope_module;
        if (rec->scope) {
647
648
649
650
            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");

651
652
653
654
655
            if (hasattr(rec->scope, "__module__")) {
                scope_module = rec->scope.attr("__module__");
            } else if (hasattr(rec->scope, "__name__")) {
                scope_module = rec->scope.attr("__name__");
            }
656
657
658
659
660
        }

#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
        /* Qualified names for Python >= 3.3 */
        object scope_qualname;
661
662
        if (rec->scope && hasattr(rec->scope, "__qualname__"))
            scope_qualname = rec->scope.attr("__qualname__");
663
664
        object ht_qualname;
        if (scope_qualname) {
665
666
            ht_qualname = reinterpret_steal<object>(PyUnicode_FromFormat(
                "%U.%U", scope_qualname.ptr(), name.ptr()));
667
668
669
670
        } else {
            ht_qualname = name;
        }
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
671
672

        size_t num_bases = rec->bases.size();
673
        auto bases = tuple(rec->bases);
Wenzel Jakob's avatar
Wenzel Jakob committed
674

675
        std::string full_name = (scope_module ? ((std::string) pybind11::str(scope_module) + "." + rec->name)
676
677
678
                                              : std::string(rec->name));

        char *tp_doc = nullptr;
679
        if (rec->doc && options::show_user_defined_docstrings()) {
680
681
682
683
684
685
686
            /* 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
687
688
689
690
691
        /* 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) */

692
        auto type_holder = reinterpret_steal<object>(PyType_Type.tp_alloc(&PyType_Type, 0));
693
694
695
        auto type = (PyHeapTypeObject*) type_holder.ptr();

        if (!type_holder || !name)
696
            pybind11_fail(std::string(rec->name) + ": Unable to create type object!");
697
698
699
700

        /* 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
701
702
        tinfo->type_size = rec->type_size;
        tinfo->init_holder = rec->init_holder;
703
        tinfo->direct_conversions = &internals.direct_conversions[tindex];
704
        internals.registered_types_cpp[tindex] = tinfo;
705
706
707
708
        internals.registered_types_py[type] = tinfo;

        /* Basic type attributes */
        type->ht_type.tp_name = strdup(full_name.c_str());
709
        type->ht_type.tp_basicsize = (ssize_t) rec->instance_size;
Wenzel Jakob's avatar
Wenzel Jakob committed
710
711
712
713
714
715

        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;
        }
716

717
718
        type->ht_name = name.release().ptr();

719
#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
720
        type->ht_qualname = ht_qualname.release().ptr();
721
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
722

723
724
725
726
        /* 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
727

728
        /* Supported elementary operations */
Wenzel Jakob's avatar
Wenzel Jakob committed
729
730
        type->ht_type.tp_init = (initproc) init;
        type->ht_type.tp_new = (newfunc) new_instance;
Wenzel Jakob's avatar
Wenzel Jakob committed
731
        type->ht_type.tp_dealloc = rec->dealloc;
732
733

        /* Support weak references (needed for the keep_alive feature) */
734
        type->ht_type.tp_weaklistoffset = offsetof(instance_essentials<void>, weakrefs);
735
736
737

        /* Flags */
        type->ht_type.tp_flags |= Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
738
739
740
#if PY_MAJOR_VERSION < 3
        type->ht_type.tp_flags |= Py_TPFLAGS_CHECKTYPES;
#endif
741
        type->ht_type.tp_flags &= ~Py_TPFLAGS_HAVE_GC;
742

Dean Moldovan's avatar
Dean Moldovan committed
743
744
745
        /* Support dynamic attributes */
        if (rec->dynamic_attr) {
            type->ht_type.tp_flags |= Py_TPFLAGS_HAVE_GC;
746
747
            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
748
749
750
751
752
            type->ht_type.tp_getset = generic_getset;
            type->ht_type.tp_traverse = traverse;
            type->ht_type.tp_clear = clear;
        }

753
        type->ht_type.tp_doc = tp_doc;
Wenzel Jakob's avatar
Wenzel Jakob committed
754
755

        if (PyType_Ready(&type->ht_type) < 0)
756
757
            pybind11_fail(std::string(rec->name) + ": PyType_Ready failed (" +
                          detail::error_string() + ")!");
758
759

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

761
        if (scope_module) // Needed by pydoc
Wenzel Jakob's avatar
Wenzel Jakob committed
762
            attr("__module__") = scope_module;
Wenzel Jakob's avatar
Wenzel Jakob committed
763

764
        /* Register type with the parent scope */
765
766
        if (rec->scope)
            rec->scope.attr(handle(type->ht_name)) = *this;
Wenzel Jakob's avatar
Wenzel Jakob committed
767

Wenzel Jakob's avatar
Wenzel Jakob committed
768
769
770
        if (rec->multiple_inheritance)
            mark_parents_nonsimple(&type->ht_type);

771
        type_holder.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
772
773
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
774
775
    /// Helper function which tags all parents of a type using mult. inheritance
    void mark_parents_nonsimple(PyTypeObject *value) {
776
        auto t = reinterpret_borrow<tuple>(value->tp_bases);
Wenzel Jakob's avatar
Wenzel Jakob committed
777
778
779
780
781
782
783
784
        for (handle h : t) {
            auto tinfo2 = get_type_info((PyTypeObject *) h.ptr());
            if (tinfo2)
                tinfo2->simple_type = false;
            mark_parents_nonsimple((PyTypeObject *) h.ptr());
        }
    }

785
    /// Allocate a metaclass on demand (for static properties)
Wenzel Jakob's avatar
Wenzel Jakob committed
786
787
    handle metaclass() {
        auto &ht_type = ((PyHeapTypeObject *) m_ptr)->ht_type;
788
        auto &ob_type = PYBIND11_OB_TYPE(ht_type);
789

Wenzel Jakob's avatar
Wenzel Jakob committed
790
        if (ob_type == &PyType_Type) {
791
            std::string name_ = std::string(ht_type.tp_name) + "__Meta";
792
#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
793
            auto ht_qualname = reinterpret_steal<object>(PyUnicode_FromFormat("%U__Meta", attr("__qualname__").ptr()));
794
#endif
795
796
            auto name = reinterpret_steal<object>(PYBIND11_FROM_STRING(name_.c_str()));
            auto type_holder = reinterpret_steal<object>(PyType_Type.tp_alloc(&PyType_Type, 0));
797
            if (!type_holder || !name)
798
                pybind11_fail("generic_type::metaclass(): unable to create type object!");
799
800

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

Wenzel Jakob's avatar
Wenzel Jakob committed
803
804
#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
            /* Qualified names for Python >= 3.3 */
805
            type->ht_qualname = ht_qualname.release().ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
806
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
807
            type->ht_type.tp_name = strdup(name_.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
808
            type->ht_type.tp_base = ob_type;
809
810
811
            type->ht_type.tp_flags |= (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE) &
                                      ~Py_TPFLAGS_HAVE_GC;

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

Wenzel Jakob's avatar
Wenzel Jakob committed
815
            ob_type = (PyTypeObject *) type_holder.release().ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
816
817
818
819
820
821
822
823
824
825
826
        }
        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 *) {
827
828
829
        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
830
        self->owned = true;
831
        self->holder_constructed = false;
832
        detail::get_internals().registered_instances.emplace(self->value, (PyObject *) self);
Wenzel Jakob's avatar
Wenzel Jakob committed
833
834
835
836
837
        return (PyObject *) self;
    }

    static void dealloc(instance<void> *self) {
        if (self->value) {
838
839
840
841
842
843
844
845
846
847
            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
848
            }
849
850
851
            if (!found)
                pybind11_fail("generic_type::dealloc(): Tried to deallocate unregistered instance!");

852
853
            if (self->weakrefs)
                PyObject_ClearWeakRefs((PyObject *) self);
Dean Moldovan's avatar
Dean Moldovan committed
854

855
856
857
858
            PyObject **dict_ptr = _PyObject_GetDictPtr((PyObject *) self);
            if (dict_ptr) {
                Py_CLEAR(*dict_ptr);
            }
Wenzel Jakob's avatar
Wenzel Jakob committed
859
860
861
862
        }
        Py_TYPE(self)->tp_free((PyObject*) self);
    }

Dean Moldovan's avatar
Dean Moldovan committed
863
    static int traverse(PyObject *op, visitproc visit, void *arg) {
864
865
        PyObject *&dict = *_PyObject_GetDictPtr(op);
        Py_VISIT(dict);
Dean Moldovan's avatar
Dean Moldovan committed
866
867
868
869
        return 0;
    }

    static int clear(PyObject *op) {
870
871
        PyObject *&dict = *_PyObject_GetDictPtr(op);
        Py_CLEAR(dict);
Dean Moldovan's avatar
Dean Moldovan committed
872
873
874
        return 0;
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
875
876
877
    void install_buffer_funcs(
            buffer_info *(*get_buffer)(PyObject *, void *),
            void *get_buffer_data) {
Wenzel Jakob's avatar
Wenzel Jakob committed
878
879
        PyHeapTypeObject *type = (PyHeapTypeObject*) m_ptr;
        type->ht_type.tp_as_buffer = &type->as_buffer;
880
881
882
#if PY_MAJOR_VERSION < 3
        type->ht_type.tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER;
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
883
884
        type->as_buffer.bf_getbuffer = getbuffer;
        type->as_buffer.bf_releasebuffer = releasebuffer;
885
886
887
        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
888
889
890
    }

    static int getbuffer(PyObject *obj, Py_buffer *view, int flags) {
891
892
893
        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
894
895
896
            return -1;
        }
        memset(view, 0, sizeof(Py_buffer));
897
        buffer_info *info = tinfo->get_buffer(obj, tinfo->get_buffer_data);
Wenzel Jakob's avatar
Wenzel Jakob committed
898
899
900
901
        view->obj = obj;
        view->ndim = 1;
        view->internal = info;
        view->buf = info->ptr;
902
        view->itemsize = (ssize_t) info->itemsize;
Wenzel Jakob's avatar
Wenzel Jakob committed
903
904
905
906
907
908
        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) {
909
            view->ndim = (int) info->ndim;
910
911
            view->strides = (ssize_t *) &info->strides[0];
            view->shape = (ssize_t *) &info->shape[0];
Wenzel Jakob's avatar
Wenzel Jakob committed
912
913
914
915
916
917
918
        }
        Py_INCREF(view->obj);
        return 0;
    }

    static void releasebuffer(PyObject *, Py_buffer *view) { delete (buffer_info *) view->internal; }
};
919

Wenzel Jakob's avatar
Wenzel Jakob committed
920
921
NAMESPACE_END(detail)

922
template <typename type_, typename... options>
Wenzel Jakob's avatar
Wenzel Jakob committed
923
class class_ : public detail::generic_type {
924
925
    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
926
    template <typename T> using is_base = detail::bool_constant<std::is_base_of<T, type_>::value && !std::is_same<T, type_>::value>;
927
928
929
    // 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>> {};
930

Wenzel Jakob's avatar
Wenzel Jakob committed
931
public:
932
    using type = type_;
933
    using type_alias = detail::first_of_t<is_subtype, void, options...>;
934
    constexpr static bool has_alias = !std::is_void<type_alias>::value;
935
    using holder_type = detail::first_of_t<is_holder, std::unique_ptr<type>, options...>;
936
937
    using instance_type = detail::instance<type, holder_type>;

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

941
    PYBIND11_OBJECT(class_, generic_type, PyType_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
942

Wenzel Jakob's avatar
Wenzel Jakob committed
943
944
945
946
947
948
    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);
949
        record.type_size = sizeof(detail::conditional_t<has_alias, type_alias, type>);
Wenzel Jakob's avatar
Wenzel Jakob committed
950
951
952
953
        record.instance_size = sizeof(instance_type);
        record.init_holder = init_holder;
        record.dealloc = dealloc;

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

Wenzel Jakob's avatar
Wenzel Jakob committed
958
959
960
961
        /* Process optional arguments, if any */
        detail::process_attributes<Extra...>::init(extra..., &record);

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

963
        if (has_alias) {
964
965
966
            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
967
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
968

969
    template <typename Base, detail::enable_if_t<is_base<Base>::value, int> = 0>
Wenzel Jakob's avatar
Wenzel Jakob committed
970
971
972
973
974
975
    static void add_base(detail::type_record &rec) {
        rec.add_base(&typeid(Base), [](void *src) -> void * {
            return static_cast<Base *>(reinterpret_cast<type *>(src));
        });
    }

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

979
    template <typename Func, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
980
    class_ &def(const char *name_, Func&& f, const Extra&... extra) {
981
982
        cpp_function cf(std::forward<Func>(f), name(name_), is_method(*this),
                        sibling(getattr(*this, name_, none())), extra...);
983
        attr(cf.name()) = cf;
Wenzel Jakob's avatar
Wenzel Jakob committed
984
985
986
        return *this;
    }

987
    template <typename Func, typename... Extra> class_ &
Wenzel Jakob's avatar
Wenzel Jakob committed
988
    def_static(const char *name_, Func f, const Extra&... extra) {
989
990
        cpp_function cf(std::forward<Func>(f), name(name_), scope(*this),
                        sibling(getattr(*this, name_, none())), extra...);
991
        attr(cf.name()) = cf;
Wenzel Jakob's avatar
Wenzel Jakob committed
992
993
994
        return *this;
    }

995
    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
996
    class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
997
        op.execute(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
998
999
1000
        return *this;
    }

1001
    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1002
    class_ & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
1003
        op.execute_cast(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1004
1005
1006
        return *this;
    }

1007
    template <typename... Args, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1008
    class_ &def(const detail::init<Args...> &init, const Extra&... extra) {
1009
        init.execute(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1010
1011
1012
        return *this;
    }

1013
1014
    template <typename... Args, typename... Extra>
    class_ &def(const detail::init_alias<Args...> &init, const Extra&... extra) {
1015
        init.execute(*this, extra...);
1016
1017
1018
        return *this;
    }

1019
    template <typename Func> class_& def_buffer(Func &&func) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1020
1021
1022
        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
1023
1024
1025
            detail::type_caster<type> caster;
            if (!caster.load(obj, false))
                return nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
1026
1027
            return new buffer_info(((capture *) ptr)->func(caster));
        }, ptr);
Wenzel Jakob's avatar
Wenzel Jakob committed
1028
1029
1030
        return *this;
    }

1031
    template <typename C, typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1032
    class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
1033
1034
1035
        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
1036
1037
1038
        return *this;
    }

1039
    template <typename C, typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1040
    class_ &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) {
1041
1042
        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
1043
1044
1045
        return *this;
    }

1046
    template <typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1047
    class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
1048
1049
1050
        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
1051
1052
1053
        return *this;
    }

1054
    template <typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
1055
    class_ &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
1056
1057
        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
1058
1059
1060
        return *this;
    }

1061
1062
1063
1064
1065
1066
1067
    /// 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
1068
1069
    template <typename... Extra>
    class_ &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) {
1070
1071
1072
1073
1074
1075
1076
        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
1077
1078
    }

1079
    /// Uses cpp_function's return_value_policy by default
1080
1081
    template <typename... Extra>
    class_ &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) {
1082
1083
1084
1085
1086
1087
1088
        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
1089
1090
    }

1091
    /// Uses cpp_function's return_value_policy by default
1092
1093
    template <typename... Extra>
    class_ &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
1094
        return def_property_static(name, fget, fset, is_method(*this), extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
1095
1096
    }

1097
1098
1099
1100
1101
1102
1103
    /// 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
1104
1105
1106
    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);
1107
        char *doc_prev = rec_fget->doc; /* 'extra' field may include a property-specific documentation string */
1108
        detail::process_attributes<Extra...>::init(extra..., rec_fget);
1109
1110
1111
1112
1113
1114
        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;
1115
            detail::process_attributes<Extra...>::init(extra..., rec_fset);
1116
1117
1118
1119
1120
            if (rec_fset->doc && rec_fset->doc != doc_prev) {
                free(doc_prev);
                rec_fset->doc = strdup(rec_fset->doc);
            }
        }
1121
        pybind11::str doc_obj = pybind11::str((rec_fget->doc && pybind11::options::show_user_defined_docstrings()) ? rec_fget->doc : "");
1122
        const auto property = reinterpret_steal<object>(
Wenzel Jakob's avatar
Wenzel Jakob committed
1123
            PyObject_CallFunctionObjArgs((PyObject *) &PyProperty_Type, fget.ptr() ? fget.ptr() : Py_None,
1124
                                         fset.ptr() ? fset.ptr() : Py_None, Py_None, doc_obj.ptr(), nullptr));
1125
        if (rec_fget->is_method && rec_fget->scope)
1126
1127
1128
            attr(name) = property;
        else
            metaclass().attr(name) = property;
Wenzel Jakob's avatar
Wenzel Jakob committed
1129
1130
        return *this;
    }
1131

Wenzel Jakob's avatar
Wenzel Jakob committed
1132
private:
1133
1134
1135
    /// 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 */) {
1136
        try {
1137
            new (&inst->holder) holder_type(std::static_pointer_cast<typename holder_type::element_type>(inst->value->shared_from_this()));
1138
            inst->holder_constructed = true;
1139
        } catch (const std::bad_weak_ptr &) {
1140
1141
1142
1143
            if (inst->owned) {
                new (&inst->holder) holder_type(inst->value);
                inst->holder_constructed = true;
            }
1144
        }
1145
1146
1147
1148
    }

    /// Initialize holder object, variant 2: try to construct from existing holder object, if possible
    template <typename T = holder_type,
1149
              detail::enable_if_t<std::is_copy_constructible<T>::value, int> = 0>
1150
    static void init_holder_helper(instance_type *inst, const holder_type *holder_ptr, const void * /* dummy */) {
1151
        if (holder_ptr) {
1152
            new (&inst->holder) holder_type(*holder_ptr);
1153
1154
            inst->holder_constructed = true;
        } else if (inst->owned) {
1155
            new (&inst->holder) holder_type(inst->value);
1156
1157
            inst->holder_constructed = true;
        }
1158
1159
1160
1161
    }

    /// Initialize holder object, variant 3: holder is not copy constructible (e.g. unique_ptr), always initialize from raw pointer
    template <typename T = holder_type,
1162
              detail::enable_if_t<!std::is_copy_constructible<T>::value, int> = 0>
1163
    static void init_holder_helper(instance_type *inst, const holder_type * /* unused */, const void * /* dummy */) {
1164
1165
1166
1167
        if (inst->owned) {
            new (&inst->holder) holder_type(inst->value);
            inst->holder_constructed = true;
        }
1168
1169
1170
1171
1172
1173
    }

    /// 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);
1174
1175
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
1176
1177
    static void dealloc(PyObject *inst_) {
        instance_type *inst = (instance_type *) inst_;
1178
1179
1180
1181
1182
        if (inst->holder_constructed)
            inst->holder.~holder_type();
        else if (inst->owned)
            ::operator delete(inst->value);

1183
        generic_type::dealloc((detail::instance<void> *) inst);
Wenzel Jakob's avatar
Wenzel Jakob committed
1184
    }
1185
1186
1187

    static detail::function_record *get_function_record(handle h) {
        h = detail::get_function(h);
1188
1189
        return h ? (detail::function_record *) reinterpret_borrow<capsule>(PyCFunction_GetSelf(h.ptr()))
                 : nullptr;
1190
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1191
1192
1193
1194
1195
};

/// Binds C++ enumerations and enumeration classes to Python
template <typename Type> class enum_ : public class_<Type> {
public:
1196
    using class_<Type>::def;
1197
1198
1199
    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
1200
1201
1202
    template <typename... Extra>
    enum_(const handle &scope, const char *name, const Extra&... extra)
      : class_<Type>(scope, name, extra...), m_parent(scope) {
1203
1204
1205
1206
1207
1208

        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 *>();
1209
        def("__repr__", [name, entries](Type value) -> std::string {
1210
            auto it = entries->find((Scalar) value);
Wenzel Jakob's avatar
Wenzel Jakob committed
1211
1212
1213
1214
            return std::string(name) + "." +
                ((it == entries->end()) ? std::string("???")
                                        : std::string(it->second));
        });
1215
1216
1217
        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; });
1218
1219
        def("__eq__", [](const Type &value, Type *value2) { return value2 && value == *value2; });
        def("__ne__", [](const Type &value, Type *value2) { return !value2 || value != *value2; });
1220
1221
1222
1223
1224
1225
1226
        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) {
1227
1228
            // 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
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
            // 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; });
            }
1248
        }
1249
        def("__hash__", [](const Type &value) { return (Scalar) value; });
Wenzel Jakob's avatar
Wenzel Jakob committed
1250
        // Pickling and unpickling -- needed for use with the 'multiprocessing' module
1251
1252
        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
1253
1254
1255
1256
        m_entries = entries;
    }

    /// Export enumeration entries into the parent scope
1257
    enum_ &export_values() {
Wenzel Jakob's avatar
Wenzel Jakob committed
1258
1259
        PyObject *dict = ((PyTypeObject *) this->m_ptr)->tp_dict;
        PyObject *key, *value;
1260
        ssize_t pos = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
1261
1262
1263
        while (PyDict_Next(dict, &pos, &key, &value))
            if (PyObject_IsInstance(value, this->m_ptr))
                m_parent.attr(key) = value;
1264
        return *this;
Wenzel Jakob's avatar
Wenzel Jakob committed
1265
1266
1267
1268
    }

    /// Add an enumeration entry
    enum_& value(char const* name, Type value) {
1269
        this->attr(name) = pybind11::cast(value, return_value_policy::copy);
1270
        (*m_entries)[(Scalar) value] = name;
Wenzel Jakob's avatar
Wenzel Jakob committed
1271
1272
1273
        return *this;
    }
private:
1274
    std::unordered_map<Scalar, const char *> *m_entries;
Wenzel Jakob's avatar
Wenzel Jakob committed
1275
    handle m_parent;
Wenzel Jakob's avatar
Wenzel Jakob committed
1276
1277
1278
};

NAMESPACE_BEGIN(detail)
1279
template <typename... Args> struct init {
1280
1281
    template <typename Class, typename... Extra, enable_if_t<!Class::has_alias, int> = 0>
    static void execute(Class &cl, const Extra&... extra) {
1282
        using Base = typename Class::type;
Wenzel Jakob's avatar
Wenzel Jakob committed
1283
        /// Function which calls a specific C++ in-place constructor
1284
        cl.def("__init__", [](Base *self_, Args... args) { new (self_) Base(args...); }, extra...);
1285
1286
    }

1287
    template <typename Class, typename... Extra,
1288
1289
1290
              enable_if_t<Class::has_alias &&
                          std::is_constructible<typename Class::type, Args...>::value, int> = 0>
    static void execute(Class &cl, const Extra&... extra) {
1291
1292
1293
1294
        using Base = typename Class::type;
        using Alias = typename Class::type_alias;
        handle cl_type = cl;
        cl.def("__init__", [cl_type](handle self_, Args... args) {
1295
1296
                if (self_.get_type() == cl_type)
                    new (self_.cast<Base *>()) Base(args...);
1297
                else
1298
                    new (self_.cast<Alias *>()) Alias(args...);
1299
1300
1301
            }, extra...);
    }

1302
    template <typename Class, typename... Extra,
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
              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) {
1313
1314
        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
1315
1316
    }
};
1317

1318

1319
inline void keep_alive_impl(handle nurse, handle patient) {
1320
    /* Clever approach based on weak references taken from Boost.Python */
1321
    if (!nurse || !patient)
1322
        pybind11_fail("Could not activate keep_alive!");
1323

1324
    if (patient.is_none() || nurse.is_none())
1325
        return; /* Nothing to keep alive or nothing to be kept alive by */
1326

1327
    cpp_function disable_lifesupport(
1328
        [patient](handle weakref) { patient.dec_ref(); weakref.dec_ref(); });
1329

1330
    weakref wr(nurse, disable_lifesupport);
1331

1332
1333
    patient.inc_ref(); /* reference patient and leak the weak reference */
    (void) wr.release();
1334
1335
}

1336
1337
1338
1339
1340
1341
1342
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);
}

1343
template <typename Iterator, typename Sentinel, bool KeyIterator, return_value_policy Policy>
1344
1345
1346
struct iterator_state {
    Iterator it;
    Sentinel end;
1347
1348
    bool first;
};
1349

Wenzel Jakob's avatar
Wenzel Jakob committed
1350
1351
NAMESPACE_END(detail)

1352
template <typename... Args> detail::init<Args...> init() { return detail::init<Args...>(); }
1353
template <typename... Args> detail::init_alias<Args...> init_alias() { return detail::init_alias<Args...>(); }
Wenzel Jakob's avatar
Wenzel Jakob committed
1354

1355
1356
template <return_value_policy Policy = return_value_policy::reference_internal,
          typename Iterator,
1357
          typename Sentinel,
1358
1359
          typename ValueType = decltype(*std::declval<Iterator>()),
          typename... Extra>
1360
iterator make_iterator(Iterator first, Sentinel last, Extra &&... extra) {
1361
    typedef detail::iterator_state<Iterator, Sentinel, false, Policy> state;
1362

Wenzel Jakob's avatar
Wenzel Jakob committed
1363
    if (!detail::get_type_info(typeid(state), false)) {
1364
        class_<state>(handle(), "iterator")
1365
            .def("__iter__", [](state &s) -> state& { return s; })
1366
            .def("__next__", [](state &s) -> ValueType {
1367
1368
1369
1370
                if (!s.first)
                    ++s.it;
                else
                    s.first = false;
1371
1372
                if (s.it == s.end)
                    throw stop_iteration();
1373
                return *s.it;
1374
            }, std::forward<Extra>(extra)..., Policy);
1375
1376
    }

1377
    return (iterator) cast(state { first, last, true });
1378
}
1379

1380
1381
template <return_value_policy Policy = return_value_policy::reference_internal,
          typename Iterator,
1382
          typename Sentinel,
1383
          typename KeyType = decltype((*std::declval<Iterator>()).first),
1384
          typename... Extra>
1385
iterator make_key_iterator(Iterator first, Sentinel last, Extra &&... extra) {
1386
    typedef detail::iterator_state<Iterator, Sentinel, true, Policy> state;
1387

Wenzel Jakob's avatar
Wenzel Jakob committed
1388
    if (!detail::get_type_info(typeid(state), false)) {
1389
        class_<state>(handle(), "iterator")
1390
1391
1392
1393
1394
1395
1396
1397
            .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();
1398
                return (*s.it).first;
1399
            }, std::forward<Extra>(extra)..., Policy);
1400
1401
1402
1403
    }

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

1405
1406
1407
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...);
1408
1409
}

1410
1411
1412
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...);
1413
1414
}

Wenzel Jakob's avatar
Wenzel Jakob committed
1415
template <typename InputType, typename OutputType> void implicitly_convertible() {
1416
    auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject * {
Wenzel Jakob's avatar
Wenzel Jakob committed
1417
1418
1419
1420
1421
1422
1423
1424
1425
        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;
    };
1426
1427
1428
1429

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

1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
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:
1448
1449
1450
1451
1452
1453
1454
1455
    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;
1456
    }
1457
1458
1459
1460
1461

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

1464
1465
1466
1467
1468
/** 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.
 */
1469
1470
1471
1472
1473
template <typename CppException>
exception<CppException> &register_exception(handle scope,
                                            const char *name,
                                            PyObject *base = PyExc_Exception) {
    static exception<CppException> ex(scope, name, base);
1474
1475
1476
1477
    register_exception_translator([](std::exception_ptr p) {
        if (!p) return;
        try {
            std::rethrow_exception(p);
1478
        } catch (const CppException &e) {
1479
1480
1481
1482
1483
1484
            ex(e.what());
        }
    });
    return ex;
}

Dean Moldovan's avatar
Dean Moldovan committed
1485
1486
1487
1488
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) {
1489
        strings[i] = str(args[i]);
Dean Moldovan's avatar
Dean Moldovan committed
1490
    }
1491
    auto sep = kwargs.contains("sep") ? kwargs["sep"] : cast(" ");
1492
    auto line = sep.attr("join")(strings);
Dean Moldovan's avatar
Dean Moldovan committed
1493

1494
1495
1496
1497
1498
1499
    object file;
    if (kwargs.contains("file")) {
        file = kwargs["file"].cast<object>();
    } else {
        try {
            file = module::import("sys").attr("stdout");
1500
        } catch (const error_already_set &) {
1501
1502
1503
1504
1505
1506
1507
1508
            /* 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;
        }
    }

1509
    auto write = file.attr("write");
Dean Moldovan's avatar
Dean Moldovan committed
1510
    write(line);
1511
    write(kwargs.contains("end") ? kwargs["end"] : cast("\n"));
Dean Moldovan's avatar
Dean Moldovan committed
1512

1513
    if (kwargs.contains("flush") && kwargs["flush"].cast<bool>())
1514
        file.attr("flush")();
Dean Moldovan's avatar
Dean Moldovan committed
1515
1516
1517
1518
1519
1520
1521
1522
1523
}
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());
}

1524
#if defined(WITH_THREAD)
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538

/* 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
1539
1540
 *    thread would otherwise constantly construct and destroy thread state data
 *    structures.
1541
1542
1543
1544
1545
 *
 * 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).
1546
 */
Wenzel Jakob's avatar
Wenzel Jakob committed
1547
1548
1549

class gil_scoped_acquire {
public:
1550
    PYBIND11_NOINLINE gil_scoped_acquire() {
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
        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;
1561
1562
1563
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(internals.tstate);
            #endif
1564
1565
            PyThread_set_key_value(internals.tstate, tstate);
        } else {
1566
            release = detail::get_thread_state_unchecked() != tstate;
1567
1568
1569
1570
        }

        if (release) {
            /* Work around an annoying assertion in PyThreadState_Swap */
1571
1572
1573
1574
            #if defined(Py_DEBUG)
                PyInterpreterState *interp = tstate->interp;
                tstate->interp = nullptr;
            #endif
1575
            PyEval_AcquireThread(tstate);
1576
1577
1578
            #if defined(Py_DEBUG)
                tstate->interp = interp;
            #endif
1579
1580
1581
1582
1583
1584
1585
1586
1587
        }

        inc_ref();
    }

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

1588
    PYBIND11_NOINLINE void dec_ref() {
1589
1590
        --tstate->gilstate_counter;
        #if !defined(NDEBUG)
1591
            if (detail::get_thread_state_unchecked() != tstate)
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
                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();
1603
            PyThread_delete_key_value(detail::get_internals().tstate);
1604
1605
1606
1607
            release = false;
        }
    }

1608
    PYBIND11_NOINLINE ~gil_scoped_acquire() {
1609
1610
1611
1612
1613
1614
1615
        dec_ref();
        if (release)
           PyEval_SaveThread();
    }
private:
    PyThreadState *tstate = nullptr;
    bool release = true;
Wenzel Jakob's avatar
Wenzel Jakob committed
1616
1617
1618
1619
};

class gil_scoped_release {
public:
1620
    explicit gil_scoped_release(bool disassoc = false) : disassoc(disassoc) {
1621
        tstate = PyEval_SaveThread();
1622
        if (disassoc) {
1623
            auto key = detail::get_internals().tstate;
1624
1625
1626
1627
1628
1629
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(key);
            #else
                PyThread_set_key_value(key, nullptr);
            #endif
        }
1630
1631
1632
1633
1634
    }
    ~gil_scoped_release() {
        if (!tstate)
            return;
        PyEval_RestoreThread(tstate);
1635
        if (disassoc) {
1636
            auto key = detail::get_internals().tstate;
1637
1638
1639
1640
1641
            #if PY_MAJOR_VERSION < 3
                PyThread_delete_key_value(key);
            #endif
            PyThread_set_key_value(key, tstate);
        }
1642
1643
1644
1645
    }
private:
    PyThreadState *tstate;
    bool disassoc;
Wenzel Jakob's avatar
Wenzel Jakob committed
1646
};
1647
1648
1649
#else
class gil_scoped_acquire { };
class gil_scoped_release { };
1650
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
1651

1652
1653
1654
1655
1656
1657
1658
1659
error_already_set::~error_already_set() {
    if (value) {
        gil_scoped_acquire gil;
        PyErr_Restore(type, value, trace);
        PyErr_Clear();
    }
}

1660
1661
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);
1662
1663
    if (!py_object)
        return function();
1664
1665
1666
    handle type = py_object.get_type();
    auto key = std::make_pair(type.ptr(), name);

1667
1668
    /* Cache functions that aren't overloaded in Python to avoid
       many costly Python dictionary lookups below */
1669
1670
1671
1672
    auto &cache = detail::get_internals().inactive_overload_cache;
    if (cache.find(key) != cache.end())
        return function();

1673
    function overload = getattr(py_object, name, function());
1674
1675
1676
1677
    if (overload.is_cpp_function()) {
        cache.insert(key);
        return function();
    }
1678

1679
    /* Don't call dispatch code if invoked from overridden function */
1680
    PyFrameObject *frame = PyThreadState_Get()->frame;
1681
    if (frame && (std::string) str(frame->f_code->co_name) == name &&
1682
1683
1684
1685
1686
1687
1688
        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();
    }
1689
1690
1691
    return overload;
}

1692
template <class T> function get_overload(const T *this_ptr, const char *name) {
1693
1694
    auto tinfo = detail::get_type_info(typeid(T));
    return tinfo ? get_type_overload(this_ptr, tinfo, name) : function();
1695
1696
}

1697
#define PYBIND11_OVERLOAD_INT(ret_type, cname, name, ...) { \
1698
        pybind11::gil_scoped_acquire gil; \
1699
        pybind11::function overload = pybind11::get_overload(static_cast<const cname *>(this), name); \
1700
        if (overload) { \
1701
            auto o = overload(__VA_ARGS__); \
1702
            if (pybind11::detail::cast_is_temporary_value_reference<ret_type>::value) { \
1703
1704
                static pybind11::detail::overload_caster_t<ret_type> caster; \
                return pybind11::detail::cast_ref<ret_type>(std::move(o), caster); \
1705
1706
1707
1708
            } \
            else return pybind11::detail::cast_safe<ret_type>(std::move(o)); \
        } \
    }
1709

1710
#define PYBIND11_OVERLOAD_NAME(ret_type, cname, name, fn, ...) \
1711
    PYBIND11_OVERLOAD_INT(ret_type, cname, name, __VA_ARGS__) \
1712
    return cname::fn(__VA_ARGS__)
1713

1714
#define PYBIND11_OVERLOAD_PURE_NAME(ret_type, cname, name, fn, ...) \
1715
    PYBIND11_OVERLOAD_INT(ret_type, cname, name, __VA_ARGS__) \
1716
1717
1718
1719
1720
1721
1722
    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__)
1723

1724
NAMESPACE_END(pybind11)
Wenzel Jakob's avatar
Wenzel Jakob committed
1725
1726

#if defined(_MSC_VER)
Wenzel Jakob's avatar
Wenzel Jakob committed
1727
#  pragma warning(pop)
1728
1729
#elif defined(__INTEL_COMPILER)
/* Leave ignored warnings on */
1730
#elif defined(__GNUG__) && !defined(__clang__)
Wenzel Jakob's avatar
Wenzel Jakob committed
1731
#  pragma GCC diagnostic pop
Wenzel Jakob's avatar
Wenzel Jakob committed
1732
#endif