pybind11.h 44.1 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
6
7
8
9
10

    Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>

    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
15
16
17
18
19
#  pragma warning(push)
#  pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
#  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
#  pragma warning(disable: 4100) // warning C4100: Unreferenced formal parameter
#  pragma warning(disable: 4512) // warning C4512: Assignment operator was implicitly defined as deleted
20
21
#elif defined(__ICC) || defined(__INTEL_COMPILER)
#  pragma warning(disable:2196)  // warning #2196: routine is both "inline" and "noinline"
22
#elif defined(__GNUG__) and !defined(__clang__)
Wenzel Jakob's avatar
Wenzel Jakob committed
23
24
25
26
#  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
27
28
#endif

Wenzel Jakob's avatar
Wenzel Jakob committed
29
#include "attr.h"
Wenzel Jakob's avatar
Wenzel Jakob committed
30

31
NAMESPACE_BEGIN(pybind11)
Wenzel Jakob's avatar
Wenzel Jakob committed
32

Wenzel Jakob's avatar
Wenzel Jakob committed
33
/// Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object
34
class cpp_function : public function {
35
protected:
Wenzel Jakob's avatar
Wenzel Jakob committed
36
37
38
    /// Picks a suitable return value converter from cast.h
    template <typename T> using return_value_caster =
        detail::type_caster<typename std::conditional<
39
            std::is_void<T>::value, detail::void_type, typename detail::intrinsic_type<T>::type>::type>;
Wenzel Jakob's avatar
Wenzel Jakob committed
40
41

    /// Picks a suitable argument value converter from cast.h
42
    template <typename... T> using arg_value_caster =
Wenzel Jakob's avatar
Wenzel Jakob committed
43
44
        detail::type_caster<typename std::tuple<T...>>;
public:
45
    cpp_function() { }
Wenzel Jakob's avatar
Wenzel Jakob committed
46
47

    /// Vanilla function pointers
48
    template <typename Return, typename... Args, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
49
50
51
    cpp_function(Return (*f)(Args...), const Extra&... extra) {
        auto rec = new detail::function_record();
        rec->data = (void *) f;
Wenzel Jakob's avatar
Wenzel Jakob committed
52

53
        typedef arg_value_caster<Args...> cast_in;
54
55
        typedef return_value_caster<Return> cast_out;

56
        /* Dispatch code which converts function arguments and performs the actual function call */
Wenzel Jakob's avatar
Wenzel Jakob committed
57
        rec->impl = [](detail::function_record *rec, handle pyArgs, handle parent) -> handle {
Wenzel Jakob's avatar
Wenzel Jakob committed
58
            cast_in args;
59
60

            /* Try to cast the function arguments into the C++ domain */
61
            if (!args.load(pyArgs, true))
62
63
                return PYBIND11_TRY_NEXT_OVERLOAD;

Wenzel Jakob's avatar
Wenzel Jakob committed
64
65
            /* Invoke call policy pre-call hook */
            detail::process_attributes<Extra...>::precall(pyArgs);
66
67

            /* Do the call and convert the return value back into the Python domain */
Wenzel Jakob's avatar
Wenzel Jakob committed
68
69
70
71
72
73
            handle result = cast_out::cast(
                args.template call<Return>((Return (*) (Args...)) rec->data),
                rec->policy, parent);

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

75
            return result;
Wenzel Jakob's avatar
Wenzel Jakob committed
76
77
        };

Wenzel Jakob's avatar
Wenzel Jakob committed
78
79
        /* Process any user-provided function attributes */
        detail::process_attributes<Extra...>::init(extra..., rec);
80
81

        /* Generate a readable signature describing the function's arguments and return value types */
Wenzel Jakob's avatar
Wenzel Jakob committed
82
        using detail::descr;
83
        PYBIND11_DESCR signature = cast_in::name() + detail::_(" -> ") + cast_out::name();
84
85

        /* Register the function with Python from generic (non-templated) code */
Wenzel Jakob's avatar
Wenzel Jakob committed
86
        initialize(rec, signature.text(), signature.types(), sizeof...(Args));
Wenzel Jakob's avatar
Wenzel Jakob committed
87
88
89
    }

    /// Delegating helper constructor to deal with lambda functions
Wenzel Jakob's avatar
Wenzel Jakob committed
90
    template <typename Func, typename... Extra> cpp_function(Func &&f, const Extra&... extra) {
91
        initialize(std::forward<Func>(f),
Wenzel Jakob's avatar
Wenzel Jakob committed
92
                   (typename detail::remove_class<decltype(
Wenzel Jakob's avatar
Wenzel Jakob committed
93
                       &std::remove_reference<Func>::type::operator())>::type *) nullptr, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
94
95
    }

96
    /// Delegating helper constructor to deal with class methods (non-const)
97
    template <typename Return, typename Class, typename... Arg, typename... Extra> cpp_function(
Wenzel Jakob's avatar
Wenzel Jakob committed
98
            Return (Class::*f)(Arg...), const Extra&... extra) {
99
        initialize([f](Class *c, Arg... args) -> Return { return (c->*f)(args...); },
Wenzel Jakob's avatar
Wenzel Jakob committed
100
                   (Return (*) (Class *, Arg...)) nullptr, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
101
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
102

103
    /// Delegating helper constructor to deal with class methods (const)
104
    template <typename Return, typename Class, typename... Arg, typename... Extra> cpp_function(
Wenzel Jakob's avatar
Wenzel Jakob committed
105
            Return (Class::*f)(Arg...) const, const Extra&... extra) {
106
        initialize([f](const Class *c, Arg... args) -> Return { return (c->*f)(args...); },
Wenzel Jakob's avatar
Wenzel Jakob committed
107
                   (Return (*)(const Class *, Arg ...)) nullptr, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
108
109
    }

110
    /// Return the function name
Wenzel Jakob's avatar
Wenzel Jakob committed
111
    object name() const { return attr("__name__"); }
112

113
114
protected:
    /// Special internal constructor for functors, lambda functions, etc.
115
    template <typename Func, typename Return, typename... Args, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
116
    void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
117
        struct capture { typename std::remove_reference<Func>::type f; };
Wenzel Jakob's avatar
Wenzel Jakob committed
118

119
        /* Store the function including any extra state it might have (e.g. a lambda capture object) */
Wenzel Jakob's avatar
Wenzel Jakob committed
120
121
        auto rec = new detail::function_record();
        rec->data = new capture { std::forward<Func>(f) };
122

123
        /* Create a cleanup handler, but only if we have to (less generated code) */
124
        if (!std::is_trivially_destructible<Func>::value)
Wenzel Jakob's avatar
Wenzel Jakob committed
125
            rec->free_data = [](void *ptr) { delete (capture *) ptr; };
126
        else
Wenzel Jakob's avatar
Wenzel Jakob committed
127
            rec->free_data = operator delete;
128

129
        typedef arg_value_caster<Args...> cast_in;
130
        typedef return_value_caster<Return> cast_out;
Wenzel Jakob's avatar
Wenzel Jakob committed
131

132
        /* Dispatch code which converts function arguments and performs the actual function call */
Wenzel Jakob's avatar
Wenzel Jakob committed
133
        rec->impl = [](detail::function_record *rec, handle pyArgs, handle parent) -> handle {
Wenzel Jakob's avatar
Wenzel Jakob committed
134
            cast_in args;
135
136

            /* Try to cast the function arguments into the C++ domain */
137
            if (!args.load(pyArgs, true))
138
139
                return PYBIND11_TRY_NEXT_OVERLOAD;

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

            /* Do the call and convert the return value back into the Python domain */
Wenzel Jakob's avatar
Wenzel Jakob committed
144
145
146
147
148
149
            handle result = cast_out::cast(
                args.template call<Return>(((capture *) rec->data)->f),
                rec->policy, parent);

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

151
            return result;
Wenzel Jakob's avatar
Wenzel Jakob committed
152
153
        };

Wenzel Jakob's avatar
Wenzel Jakob committed
154
155
        /* Process any user-provided function attributes */
        detail::process_attributes<Extra...>::init(extra..., rec);
156
157

        /* Generate a readable signature describing the function's arguments and return value types */
Wenzel Jakob's avatar
Wenzel Jakob committed
158
        using detail::descr;
159
        PYBIND11_DESCR signature = cast_in::name() + detail::_(" -> ") + cast_out::name();
160
161

        /* Register the function with Python from generic (non-templated) code */
Wenzel Jakob's avatar
Wenzel Jakob committed
162
        initialize(rec, signature.text(), signature.types(), sizeof...(Args));
163
164
    }

165
    /// Register a function call with Python (generic non-templated code goes here)
Wenzel Jakob's avatar
Wenzel Jakob committed
166
167
168
    void initialize(detail::function_record *rec, const char *text,
                    const std::type_info *const *types, int args) {

169
        /* Create copies of all referenced C-style strings */
Wenzel Jakob's avatar
Wenzel Jakob committed
170
171
172
        rec->name = strdup(rec->name ? rec->name : "");
        if (rec->doc) rec->doc = strdup(rec->doc);
        for (auto &a: rec->args) {
173
174
175
176
177
            if (a.name)
                a.name = strdup(a.name);
            if (a.descr)
                a.descr = strdup(a.descr);
            else if (a.value)
178
                a.descr = strdup(((std::string) ((object) handle(a.value).attr("__repr__")).call().str()).c_str());
179
        }
180
        auto const &registered_types = detail::get_internals().registered_types_cpp;
181
182
183
184
185
186
187
188
189
190

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

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

229
#if PY_MAJOR_VERSION < 3
Wenzel Jakob's avatar
Wenzel Jakob committed
230
231
232
        if (strcmp(rec->name, "__next__") == 0) {
            std::free(rec->name);
            rec->name = strdup("next");
233
        }
234
235
#endif

Wenzel Jakob's avatar
Wenzel Jakob committed
236
        if (!rec->args.empty() && (int) rec->args.size() != args)
237
            pybind11_fail(
Wenzel Jakob's avatar
Wenzel Jakob committed
238
239
                "cpp_function(): function \"" + std::string(rec->name) + "\" takes " +
                std::to_string(args) + " arguments, but " + std::to_string(rec->args.size()) +
240
                " pybind11::arg entries were specified!");
241

Wenzel Jakob's avatar
Wenzel Jakob committed
242
243
244
        rec->is_constructor = !strcmp(rec->name, "__init__");
        rec->signature = strdup(signature.c_str());
        rec->args.shrink_to_fit();
245
246

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

Wenzel Jakob's avatar
Wenzel Jakob committed
251
252
253
254
        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;
255
256
            /* 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
257
258
            if (chain->class_ != rec->class_)
                chain = nullptr;
259
260
        }

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

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

            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
281
            if (!m_ptr)
282
                pybind11_fail("cpp_function::cpp_function(): Could not allocate function object");
Wenzel Jakob's avatar
Wenzel Jakob committed
283
        } else {
284
            /* Append at the end of the overload chain */
Wenzel Jakob's avatar
Wenzel Jakob committed
285
            m_ptr = rec->sibling.ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
286
            inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
287
288
289
290
            chain_start = chain;
            while (chain->next)
                chain = chain->next;
            chain->next = rec;
Wenzel Jakob's avatar
Wenzel Jakob committed
291
        }
292

Wenzel Jakob's avatar
Wenzel Jakob committed
293
        std::string signatures;
294
        int index = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
295
        /* Create a nice pydoc rec including all signatures and
296
           docstrings of the functions in the overload chain */
Wenzel Jakob's avatar
Wenzel Jakob committed
297
298
        for (auto it = chain_start; it != nullptr; it = it->next) {
            if (chain)
299
                signatures += std::to_string(++index) + ". ";
300
301
302
303
304
305
306
307
            signatures += "Signature : ";
            signatures += it->signature;
            signatures += "\n";
            if (it->doc && strlen(it->doc) > 0) {
                signatures += "\n";
                signatures += it->doc;
                signatures += "\n";
            }
308
            if (it->next)
Wenzel Jakob's avatar
Wenzel Jakob committed
309
310
                signatures += "\n";
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
311
312

        /* Install docstring */
Wenzel Jakob's avatar
Wenzel Jakob committed
313
314
        PyCFunctionObject *func = (PyCFunctionObject *) m_ptr;
        if (func->m_ml->ml_doc)
315
            std::free((char *) func->m_ml->ml_doc);
Wenzel Jakob's avatar
Wenzel Jakob committed
316
        func->m_ml->ml_doc = strdup(signatures.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
317
318
319

        if (rec->class_) {
            m_ptr = PYBIND11_INSTANCE_METHOD_NEW(m_ptr, rec->class_.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
320
            if (!m_ptr)
321
                pybind11_fail("cpp_function::cpp_function(): Could not allocate instance method object");
Wenzel Jakob's avatar
Wenzel Jakob committed
322
323
324
            Py_DECREF(func);
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453

    /// 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)
                rec->free_data(rec->data);
            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 */
        int nargs = (int) PyTuple_Size(args),
            nkwargs = kwargs ? (int) PyDict_Size(kwargs) : 0;

        handle parent = nargs > 0 ? PyTuple_GetItem(args, 0) : nullptr,
               result = PYBIND11_TRY_NEXT_OVERLOAD;
        try {
            for (; it != nullptr; it = it->next) {
                tuple args_(args, true);
                int kwargs_consumed = 0;

                /* 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)
                 */

                if (nargs < (int) it->args.size()) {
                    args_ = tuple(it->args.size());
                    for (int i = 0; i < nargs; ++i) {
                        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 {
                            kwargs_consumed = -1; /* definite failure */
                            break;
                        }
                    }
                }

                if (kwargs_consumed == nkwargs)
                    result = it->impl(it, args_, parent);

                if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD)
                    break;
            }
        } catch (const error_already_set &)      {                                                 return nullptr;
        } catch (const index_error &e)           { PyErr_SetString(PyExc_IndexError,    e.what()); return nullptr;
        } catch (const stop_iteration &e)        { PyErr_SetString(PyExc_StopIteration, e.what()); return nullptr;
        } catch (const std::bad_alloc &e)        { PyErr_SetString(PyExc_MemoryError,   e.what()); return nullptr;
        } catch (const std::domain_error &e)     { PyErr_SetString(PyExc_ValueError,    e.what()); return nullptr;
        } catch (const std::invalid_argument &e) { PyErr_SetString(PyExc_ValueError,    e.what()); return nullptr;
        } catch (const std::length_error &e)     { PyErr_SetString(PyExc_ValueError,    e.what()); return nullptr;
        } catch (const std::out_of_range &e)     { PyErr_SetString(PyExc_IndexError,    e.what()); return nullptr;
        } catch (const std::range_error &e)      { PyErr_SetString(PyExc_ValueError,    e.what()); return nullptr;
        } catch (const std::exception &e)        { PyErr_SetString(PyExc_RuntimeError,  e.what()); return nullptr;
        } catch (...) {
            PyErr_SetString(PyExc_RuntimeError, "Caught an unknown exception!");
            return nullptr;
        }

        if (result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) {
            std::string msg = "Incompatible function arguments. The "
                              "following argument types are supported:\n";
            int ctr = 0;
            for (detail::function_record *it2 = overloads; it2 != nullptr; it2 = it2->next) {
                msg += "    "+ std::to_string(++ctr) + ". ";
                msg += it2->signature;
                msg += "\n";
            }
            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) {
                /* When a construtor ran successfully, the corresponding
                   holder type (e.g. std::unique_ptr) must still be initialized. */
                PyObject *inst = PyTuple_GetItem(args, 0);
                auto tinfo = detail::get_type_info(Py_TYPE(inst));
                tinfo->init_holder(inst, nullptr);
            }
            return result.ptr();
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
454
455
};

456
/// Wrapper for Python extension modules
Wenzel Jakob's avatar
Wenzel Jakob committed
457
458
class module : public object {
public:
459
    PYBIND11_OBJECT_DEFAULT(module, object, PyModule_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
460
461

    module(const char *name, const char *doc = nullptr) {
462
#if PY_MAJOR_VERSION >= 3
Wenzel Jakob's avatar
Wenzel Jakob committed
463
464
465
466
467
468
469
        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);
470
471
472
#else
        m_ptr = Py_InitModule3(name, nullptr, doc);
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
473
        if (m_ptr == nullptr)
474
            pybind11_fail("Internal error in module::module()");
Wenzel Jakob's avatar
Wenzel Jakob committed
475
476
477
        inc_ref();
    }

478
    template <typename Func, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
479
    module &def(const char *name_, Func &&f, const Extra& ... extra) {
480
        cpp_function func(std::forward<Func>(f), name(name_),
481
                          sibling((handle) attr(name_)), scope(*this), extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
482
483
        /* PyModule_AddObject steals a reference to 'func' */
        PyModule_AddObject(ptr(), name_, func.inc_ref().ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
484
485
486
        return *this;
    }

487
    module def_submodule(const char *name, const char *doc = nullptr) {
Wenzel Jakob's avatar
Wenzel Jakob committed
488
489
490
        std::string full_name = std::string(PyModule_GetName(m_ptr))
            + std::string(".") + std::string(name);
        module result(PyImport_AddModule(full_name.c_str()), true);
491
        if (doc)
492
            result.attr("__doc__") = pybind11::str(doc);
Wenzel Jakob's avatar
Wenzel Jakob committed
493
494
495
        attr(name) = result;
        return result;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
496
497

    static module import(const char *name) {
498
499
        PyObject *obj = PyImport_ImportModule(name);
        if (!obj)
500
            pybind11_fail("Module \"" + std::string(name) + "\" not found!");
501
        return module(obj, false);
Wenzel Jakob's avatar
Wenzel Jakob committed
502
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
503
504
505
};

NAMESPACE_BEGIN(detail)
Wenzel Jakob's avatar
Wenzel Jakob committed
506
/// Generic support for creating new Python heap types
507
class generic_type : public object {
Wenzel Jakob's avatar
Wenzel Jakob committed
508
    template <typename type, typename holder_type> friend class class_;
Wenzel Jakob's avatar
Wenzel Jakob committed
509
public:
510
    PYBIND11_OBJECT_DEFAULT(generic_type, object, PyType_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
511
512
513
514
515
516
517
518
519
520
521
522
523
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 + "\"");
            }
        }
524
525

        object type_holder(PyType_Type.tp_alloc(&PyType_Type, 0), false);
Wenzel Jakob's avatar
Wenzel Jakob committed
526
        object name(PYBIND11_FROM_STRING(rec->name), false);
527
528
529
        auto type = (PyHeapTypeObject*) type_holder.ptr();

        if (!type_holder || !name)
530
            pybind11_fail("generic_type: unable to create type object!");
531
532
533
534
535

        /* Register supplemental type information in C++ dict */
        auto &internals = get_internals();
        detail::type_info *tinfo = new detail::type_info();
        tinfo->type = (PyTypeObject *) type;
Wenzel Jakob's avatar
Wenzel Jakob committed
536
537
        tinfo->type_size = rec->type_size;
        tinfo->init_holder = rec->init_holder;
538
        internals.registered_types_cpp[std::type_index(*(rec->type))] = tinfo;
539
540
        internals.registered_types_py[type] = tinfo;

Wenzel Jakob's avatar
Wenzel Jakob committed
541
        auto scope_module = (object) rec->scope.attr("__module__");
542
        if (!scope_module)
Wenzel Jakob's avatar
Wenzel Jakob committed
543
            scope_module = (object) rec->scope.attr("__name__");
544

Wenzel Jakob's avatar
Wenzel Jakob committed
545
546
        std::string full_name = (scope_module ? ((std::string) scope_module.str() + "." + rec->name)
                                              : std::string(rec->name));
547
548
        /* Basic type attributes */
        type->ht_type.tp_name = strdup(full_name.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
549
550
551
        type->ht_type.tp_basicsize = rec->instance_size;
        type->ht_type.tp_base = (PyTypeObject *) rec->base_handle.ptr();
        rec->base_handle.inc_ref();
552
553
554

#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
        /* Qualified names for Python >= 3.3 */
Wenzel Jakob's avatar
Wenzel Jakob committed
555
        auto scope_qualname = (object) rec->scope.attr("__qualname__");
556
557
558
559
560
561
562
        if (scope_qualname) {
            type->ht_qualname = PyUnicode_FromFormat(
                "%U.%U", scope_qualname.ptr(), name.ptr());
        } else {
            type->ht_qualname = name.ptr();
            name.inc_ref();
        }
563
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
564
        type->ht_name = name.release().ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
565

566
567
568
569
        /* 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
570

571
        /* Supported elementary operations */
Wenzel Jakob's avatar
Wenzel Jakob committed
572
573
        type->ht_type.tp_init = (initproc) init;
        type->ht_type.tp_new = (newfunc) new_instance;
Wenzel Jakob's avatar
Wenzel Jakob committed
574
        type->ht_type.tp_dealloc = rec->dealloc;
575
576

        /* Support weak references (needed for the keep_alive feature) */
577
        type->ht_type.tp_weaklistoffset = offsetof(instance_essentials<void>, weakrefs);
578
579
580

        /* Flags */
        type->ht_type.tp_flags |= Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
581
582
583
#if PY_MAJOR_VERSION < 3
        type->ht_type.tp_flags |= Py_TPFLAGS_CHECKTYPES;
#endif
584
        type->ht_type.tp_flags &= ~Py_TPFLAGS_HAVE_GC;
585

Wenzel Jakob's avatar
Wenzel Jakob committed
586
        if (rec->doc) {
587
588
            /* Allocate memory for docstring (using PyObject_MALLOC, since
               Python will free this later on) */
Wenzel Jakob's avatar
Wenzel Jakob committed
589
            size_t size = strlen(rec->doc) + 1;
590
            type->ht_type.tp_doc = (char *) PyObject_MALLOC(size);
Wenzel Jakob's avatar
Wenzel Jakob committed
591
            memcpy((void *) type->ht_type.tp_doc, rec->doc, size);
Wenzel Jakob's avatar
Wenzel Jakob committed
592
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
593
594

        if (PyType_Ready(&type->ht_type) < 0)
595
            pybind11_fail("generic_type: PyType_Ready failed!");
596
597

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

599
        if (scope_module) // Needed by pydoc
Wenzel Jakob's avatar
Wenzel Jakob committed
600
            attr("__module__") = scope_module;
Wenzel Jakob's avatar
Wenzel Jakob committed
601

602
        /* Register type with the parent scope */
Wenzel Jakob's avatar
Wenzel Jakob committed
603
        rec->scope.attr(handle(type->ht_name)) = *this;
Wenzel Jakob's avatar
Wenzel Jakob committed
604

605
        type_holder.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
606
607
    }

608
    /// Allocate a metaclass on demand (for static properties)
Wenzel Jakob's avatar
Wenzel Jakob committed
609
610
    handle metaclass() {
        auto &ht_type = ((PyHeapTypeObject *) m_ptr)->ht_type;
611
        auto &ob_type = PYBIND11_OB_TYPE(ht_type);
612

Wenzel Jakob's avatar
Wenzel Jakob committed
613
        if (ob_type == &PyType_Type) {
614
615
616
617
            std::string name_ = std::string(ht_type.tp_name) + "__Meta";
            object type_holder(PyType_Type.tp_alloc(&PyType_Type, 0), false);
            object name(PYBIND11_FROM_STRING(name_.c_str()), false);
            if (!type_holder || !name)
618
                pybind11_fail("generic_type::metaclass(): unable to create type object!");
619
620

            auto type = (PyHeapTypeObject*) type_holder.ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
621
622
623
624
625
626
            type->ht_name = name.release().ptr();
#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
            /* Qualified names for Python >= 3.3 */
            type->ht_qualname = PyUnicode_FromFormat(
                "%U__Meta", ((object) attr("__qualname__")).ptr());
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
627
            type->ht_type.tp_name = strdup(name_.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
628
            type->ht_type.tp_base = ob_type;
629
630
631
            type->ht_type.tp_flags |= (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE) &
                                      ~Py_TPFLAGS_HAVE_GC;

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

Wenzel Jakob's avatar
Wenzel Jakob committed
635
            ob_type = (PyTypeObject *) type_holder.release().ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
636
637
638
639
640
641
642
643
644
645
646
        }
        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 *) {
647
648
649
        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
650
651
652
653
654
655
656
657
658
659
660
661
662
663
        self->owned = true;
        self->parent = nullptr;
        self->constructed = false;
        detail::get_internals().registered_instances[self->value] = (PyObject *) self;
        return (PyObject *) self;
    }

    static void dealloc(instance<void> *self) {
        if (self->value) {
            bool dont_cache = self->parent && ((instance<void> *) self->parent)->value == self->value;
            if (!dont_cache) { // avoid an issue with internal references matching their parent's address
                auto &registered_instances = detail::get_internals().registered_instances;
                auto it = registered_instances.find(self->value);
                if (it == registered_instances.end())
664
                    pybind11_fail("generic_type::dealloc(): Tried to deallocate unregistered instance!");
Wenzel Jakob's avatar
Wenzel Jakob committed
665
666
667
                registered_instances.erase(it);
            }
            Py_XDECREF(self->parent);
668
669
            if (self->weakrefs)
                PyObject_ClearWeakRefs((PyObject *) self);
Wenzel Jakob's avatar
Wenzel Jakob committed
670
671
672
673
        }
        Py_TYPE(self)->tp_free((PyObject*) self);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
674
675
676
    void install_buffer_funcs(
            buffer_info *(*get_buffer)(PyObject *, void *),
            void *get_buffer_data) {
Wenzel Jakob's avatar
Wenzel Jakob committed
677
678
        PyHeapTypeObject *type = (PyHeapTypeObject*) m_ptr;
        type->ht_type.tp_as_buffer = &type->as_buffer;
679
680
681
#if PY_MAJOR_VERSION < 3
        type->ht_type.tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER;
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
682
683
        type->as_buffer.bf_getbuffer = getbuffer;
        type->as_buffer.bf_releasebuffer = releasebuffer;
684
685
686
        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
687
688
689
    }

    static int getbuffer(PyObject *obj, Py_buffer *view, int flags) {
690
691
692
        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
693
694
695
            return -1;
        }
        memset(view, 0, sizeof(Py_buffer));
696
        buffer_info *info = tinfo->get_buffer(obj, tinfo->get_buffer_data);
Wenzel Jakob's avatar
Wenzel Jakob committed
697
698
699
700
701
702
703
704
705
706
707
708
        view->obj = obj;
        view->ndim = 1;
        view->internal = info;
        view->buf = info->ptr;
        view->itemsize = info->itemsize;
        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) {
            view->ndim = info->ndim;
709
710
            view->strides = (ssize_t *) &info->strides[0];
            view->shape = (ssize_t *) &info->shape[0];
Wenzel Jakob's avatar
Wenzel Jakob committed
711
712
713
714
715
716
717
718
719
        }
        Py_INCREF(view->obj);
        return 0;
    }

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

Wenzel Jakob's avatar
Wenzel Jakob committed
720
721
template <typename type, typename holder_type = std::unique_ptr<type>>
class class_ : public detail::generic_type {
Wenzel Jakob's avatar
Wenzel Jakob committed
722
723
724
public:
    typedef detail::instance<type, holder_type> instance_type;

725
    PYBIND11_OBJECT(class_, detail::generic_type, PyType_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
726

Wenzel Jakob's avatar
Wenzel Jakob committed
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
    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;

        /* Process optional arguments, if any */
        detail::process_attributes<Extra...>::init(extra..., &record);

        detail::generic_type::initialize(&record);
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
743

744
    template <typename Func, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
745
    class_ &def(const char *name_, Func&& f, const Extra&... extra) {
746
        cpp_function cf(std::forward<Func>(f), name(name_),
Wenzel Jakob's avatar
Wenzel Jakob committed
747
748
                        sibling(attr(name_)), is_method(*this),
                        extra...);
749
        attr(cf.name()) = cf;
Wenzel Jakob's avatar
Wenzel Jakob committed
750
751
752
        return *this;
    }

753
    template <typename Func, typename... Extra> class_ &
Wenzel Jakob's avatar
Wenzel Jakob committed
754
    def_static(const char *name_, Func f, const Extra&... extra) {
755
        cpp_function cf(std::forward<Func>(f), name(name_),
756
                        sibling(attr(name_)), scope(*this), extra...);
757
        attr(cf.name()) = cf;
Wenzel Jakob's avatar
Wenzel Jakob committed
758
759
760
        return *this;
    }

761
    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
762
    class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
Wenzel Jakob's avatar
Wenzel Jakob committed
763
        op.template execute<type>(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
764
765
766
        return *this;
    }

767
    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
768
    class_ & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
Wenzel Jakob's avatar
Wenzel Jakob committed
769
        op.template execute_cast<type>(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
770
771
772
        return *this;
    }

773
    template <typename... Args, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
774
    class_ &def(const detail::init<Args...> &init, const Extra&... extra) {
Wenzel Jakob's avatar
Wenzel Jakob committed
775
        init.template execute<type>(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
776
777
778
        return *this;
    }

779
    template <typename Func> class_& def_buffer(Func &&func) {
Wenzel Jakob's avatar
Wenzel Jakob committed
780
781
782
        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
783
784
785
            detail::type_caster<type> caster;
            if (!caster.load(obj, false))
                return nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
786
787
            return new buffer_info(((capture *) ptr)->func(caster));
        }, ptr);
Wenzel Jakob's avatar
Wenzel Jakob committed
788
789
790
        return *this;
    }

791
    template <typename C, typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
792
    class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
793
794
        cpp_function fget([pm](const C &c) -> const D &{ return c.*pm; },
                          return_value_policy::reference_internal,
Wenzel Jakob's avatar
Wenzel Jakob committed
795
                          is_method(*this), extra...),
796
                     fset([pm](C &c, const D &value) { c.*pm = value; },
Wenzel Jakob's avatar
Wenzel Jakob committed
797
                          is_method(*this), extra...);
798
        def_property(name, fget, fset);
Wenzel Jakob's avatar
Wenzel Jakob committed
799
800
801
        return *this;
    }

802
    template <typename C, typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
803
    class_ &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) {
804
805
        cpp_function fget([pm](const C &c) -> const D &{ return c.*pm; },
                          return_value_policy::reference_internal,
Wenzel Jakob's avatar
Wenzel Jakob committed
806
                          is_method(*this), extra...);
807
        def_property_readonly(name, fget);
Wenzel Jakob's avatar
Wenzel Jakob committed
808
809
810
        return *this;
    }

811
    template <typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
812
813
    class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
        cpp_function fget([pm](object) -> const D &{ return *pm; },
814
815
                          return_value_policy::reference_internal, scope(*this), extra...),
                     fset([pm](object, const D &value) { *pm = value; }, scope(*this), extra...);
816
        def_property_static(name, fget, fset);
Wenzel Jakob's avatar
Wenzel Jakob committed
817
818
819
        return *this;
    }

820
    template <typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
821
822
    class_ &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
        cpp_function fget([pm](object) -> const D &{ return *pm; },
823
                          return_value_policy::reference_internal, scope(*this), extra...);
824
        def_property_readonly_static(name, fget);
Wenzel Jakob's avatar
Wenzel Jakob committed
825
826
827
        return *this;
    }

828
829
    class_ &def_property_readonly(const char *name, const cpp_function &fget, const char *doc = nullptr) {
        def_property(name, fget, cpp_function(), doc);
Wenzel Jakob's avatar
Wenzel Jakob committed
830
831
832
        return *this;
    }

833
834
    class_ &def_property_readonly_static(const char *name, const cpp_function &fget, const char *doc = nullptr) {
        def_property_static(name, fget, cpp_function(), doc);
Wenzel Jakob's avatar
Wenzel Jakob committed
835
836
837
        return *this;
    }

838
    class_ &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const char *doc = nullptr) {
Wenzel Jakob's avatar
Wenzel Jakob committed
839
        object doc_obj = doc ? pybind11::str(doc) : (object) fget.attr("__doc__");
Wenzel Jakob's avatar
Wenzel Jakob committed
840
        object property(
Wenzel Jakob's avatar
Wenzel Jakob committed
841
842
            PyObject_CallFunctionObjArgs((PyObject *) &PyProperty_Type, fget.ptr() ? fget.ptr() : Py_None,
                                         fset.ptr() ? fset.ptr() : Py_None, Py_None, doc_obj.ptr(), nullptr), false);
Wenzel Jakob's avatar
Wenzel Jakob committed
843
844
845
846
        attr(name) = property;
        return *this;
    }

847
    class_ &def_property_static(const char *name, const cpp_function &fget, const cpp_function &fset, const char *doc = nullptr) {
Wenzel Jakob's avatar
Wenzel Jakob committed
848
        object doc_obj = doc ? pybind11::str(doc) : (object) fget.attr("__doc__");
Wenzel Jakob's avatar
Wenzel Jakob committed
849
        object property(
Wenzel Jakob's avatar
Wenzel Jakob committed
850
851
            PyObject_CallFunctionObjArgs((PyObject *) &PyProperty_Type, fget.ptr() ? fget.ptr() : Py_None,
                                         fset.ptr() ? fset.ptr() : Py_None, Py_None, doc_obj.ptr(), nullptr), false);
Wenzel Jakob's avatar
Wenzel Jakob committed
852
853
854
        metaclass().attr(name) = property;
        return *this;
    }
855
856

    template <typename target> class_ alias() {
857
        auto &instances = pybind11::detail::get_internals().registered_types_cpp;
858
        instances[std::type_index(typeid(target))] = instances[std::type_index(typeid(type))];
859
860
        return *this;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
861
private:
862
863
864
    /// 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 */) {
865
        try {
866
            new (&inst->holder) holder_type(inst->value->shared_from_this());
867
868
869
        } catch (const std::bad_weak_ptr &) {
            new (&inst->holder) holder_type(inst->value);
        }
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
    }

    /// 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);
893
894
895
        inst->constructed = true;
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
896
897
898
899
900
901
902
903
    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);
        }
904
        generic_type::dealloc((detail::instance<void> *) inst);
Wenzel Jakob's avatar
Wenzel Jakob committed
905
906
907
908
909
910
    }
};

/// Binds C++ enumerations and enumeration classes to Python
template <typename Type> class enum_ : public class_<Type> {
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
911
912
913
    template <typename... Extra>
    enum_(const handle &scope, const char *name, const Extra&... extra)
      : class_<Type>(scope, name, extra...), m_parent(scope) {
Wenzel Jakob's avatar
Wenzel Jakob committed
914
        auto entries = new std::unordered_map<int, const char *>();
915
        this->def("__repr__", [name, entries](Type value) -> std::string {
Wenzel Jakob's avatar
Wenzel Jakob committed
916
            auto it = entries->find((int) value);
Wenzel Jakob's avatar
Wenzel Jakob committed
917
918
919
920
            return std::string(name) + "." +
                ((it == entries->end()) ? std::string("???")
                                        : std::string(it->second));
        });
921
        this->def("__init__", [](Type& value, int i) { value = (Type) i; });
922
        this->def("__int__", [](Type value) { return (int) value; });
923
924
925
        this->def("__eq__", [](const Type &value, Type value2) { return value == value2; });
        this->def("__ne__", [](const Type &value, Type value2) { return value != value2; });
        this->def("__hash__", [](const Type &value) { return (int) value; });
Wenzel Jakob's avatar
Wenzel Jakob committed
926
927
928
929
930
931
932
        m_entries = entries;
    }

    /// Export enumeration entries into the parent scope
    void export_values() {
        PyObject *dict = ((PyTypeObject *) this->m_ptr)->tp_dict;
        PyObject *key, *value;
933
        ssize_t pos = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
934
935
936
937
938
939
940
        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) {
941
        this->attr(name) = pybind11::cast(value, return_value_policy::copy);
Wenzel Jakob's avatar
Wenzel Jakob committed
942
943
944
945
946
        (*m_entries)[(int) value] = name;
        return *this;
    }
private:
    std::unordered_map<int, const char *> *m_entries;
Wenzel Jakob's avatar
Wenzel Jakob committed
947
    handle m_parent;
Wenzel Jakob's avatar
Wenzel Jakob committed
948
949
950
};

NAMESPACE_BEGIN(detail)
951
template <typename... Args> struct init {
Wenzel Jakob's avatar
Wenzel Jakob committed
952
    template <typename Base, typename Holder, typename... Extra> void execute(pybind11::class_<Base, Holder> &class_, const Extra&... extra) const {
Wenzel Jakob's avatar
Wenzel Jakob committed
953
        /// Function which calls a specific C++ in-place constructor
Wenzel Jakob's avatar
Wenzel Jakob committed
954
        class_.def("__init__", [](Base *instance, Args... args) { new (instance) Base(args...); }, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
955
956
    }
};
957

Wenzel Jakob's avatar
Wenzel Jakob committed
958
PYBIND11_NOINLINE inline void keep_alive_impl(int Nurse, int Patient, handle args, handle ret) {
959
    /* Clever approach based on weak references taken from Boost.Python */
Wenzel Jakob's avatar
Wenzel Jakob committed
960
961
    handle nurse  (Nurse   > 0 ? PyTuple_GetItem(args.ptr(), Nurse   - 1) : ret.ptr());
    handle patient(Patient > 0 ? PyTuple_GetItem(args.ptr(), Patient - 1) : ret.ptr());
962

963
    if (!nurse || !patient)
964
        pybind11_fail("Could not activate keep_alive!");
965
966

    cpp_function disable_lifesupport(
967
        [patient](handle weakref) { patient.dec_ref(); weakref.dec_ref(); });
968

969
    weakref wr(nurse, disable_lifesupport);
970

971
972
    patient.inc_ref(); /* reference patient and leak the weak reference */
    (void) wr.release();
973
974
}

Wenzel Jakob's avatar
Wenzel Jakob committed
975
976
977
978
979
NAMESPACE_END(detail)

template <typename... Args> detail::init<Args...> init() { return detail::init<Args...>(); };

template <typename InputType, typename OutputType> void implicitly_convertible() {
980
    auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject * {
Wenzel Jakob's avatar
Wenzel Jakob committed
981
982
983
984
985
986
987
988
989
        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;
    };
990
991
    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
992
    if (it == registered_types.end())
993
        pybind11_fail("implicitly_convertible: Unable to find type " + type_id<OutputType>());
994
    ((detail::type_info *) it->second)->implicit_conversions.push_back(implicit_caster);
Wenzel Jakob's avatar
Wenzel Jakob committed
995
996
}

997
#if defined(WITH_THREAD)
Wenzel Jakob's avatar
Wenzel Jakob committed
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
inline void init_threading() { PyEval_InitThreads(); }

class gil_scoped_acquire {
    PyGILState_STATE state;
public:
    inline gil_scoped_acquire() { state = PyGILState_Ensure(); }
    inline ~gil_scoped_acquire() { PyGILState_Release(state); }
};

class gil_scoped_release {
    PyThreadState *state;
public:
    inline gil_scoped_release() { state = PyEval_SaveThread(); }
    inline ~gil_scoped_release() { PyEval_RestoreThread(state); }
};
1013
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
1014

1015
1016
inline function get_overload(const void *this_ptr, const char *name)  {
    handle py_object = detail::get_object_handle(this_ptr);
1017
1018
    if (!py_object)
        return function();
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
    handle type = py_object.get_type();
    auto key = std::make_pair(type.ptr(), name);

    /* Cache functions that aren't overloaded in python to avoid
       many costly dictionary lookups in Python */
    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();
    }
1033

1034
    PyFrameObject *frame = PyThreadState_Get()->frame;
1035
    pybind11::str caller = pybind11::handle(frame->f_code->co_name).str();
1036
    if ((std::string) caller == name)
1037
1038
1039
1040
        return function();
    return overload;
}

1041
#define PYBIND11_OVERLOAD_INT(ret_type, class_name, name, ...) { \
1042
1043
        pybind11::gil_scoped_acquire gil; \
        pybind11::function overload = pybind11::get_overload(this, #name); \
1044
1045
1046
        if (overload) \
            return overload.call(__VA_ARGS__).cast<ret_type>();  }

1047
1048
#define PYBIND11_OVERLOAD(ret_type, class_name, name, ...) \
    PYBIND11_OVERLOAD_INT(ret_type, class_name, name, __VA_ARGS__) \
1049
1050
    return class_name::name(__VA_ARGS__)

1051
1052
#define PYBIND11_OVERLOAD_PURE(ret_type, class_name, name, ...) \
    PYBIND11_OVERLOAD_INT(ret_type, class_name, name, __VA_ARGS__) \
1053
    pybind11::pybind11_fail("Tried to call pure virtual function \"" #name "\"");
1054

1055
NAMESPACE_END(pybind11)
Wenzel Jakob's avatar
Wenzel Jakob committed
1056
1057

#if defined(_MSC_VER)
Wenzel Jakob's avatar
Wenzel Jakob committed
1058
#  pragma warning(pop)
1059
#elif defined(__GNUG__) and !defined(__clang__)
Wenzel Jakob's avatar
Wenzel Jakob committed
1060
#  pragma GCC diagnostic pop
Wenzel Jakob's avatar
Wenzel Jakob committed
1061
#endif