pybind11.h 43.5 KB
Newer Older
Wenzel Jakob's avatar
Wenzel Jakob committed
1
/*
Wenzel Jakob's avatar
Wenzel Jakob committed
2
3
    pybind11/pybind11.h: Main header file of the C++11 python
    binding generator library
Wenzel Jakob's avatar
Wenzel Jakob committed
4
5
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
#elif defined(__GNUG__) and !defined(__clang__)
Wenzel Jakob's avatar
Wenzel Jakob committed
21
22
23
24
#  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
25
26
#endif

Wenzel Jakob's avatar
Wenzel Jakob committed
27
#include "attr.h"
Wenzel Jakob's avatar
Wenzel Jakob committed
28

29
NAMESPACE_BEGIN(pybind11)
Wenzel Jakob's avatar
Wenzel Jakob committed
30

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

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

    /// Vanilla function pointers
46
    template <typename Return, typename... Args, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
47
48
49
    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
50

51
        typedef arg_value_caster<Args...> cast_in;
52
53
        typedef return_value_caster<Return> cast_out;

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

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

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

            /* Do the call and convert the return value back into the Python domain */
Wenzel Jakob's avatar
Wenzel Jakob committed
66
67
68
69
70
71
            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);
72

73
            return result;
Wenzel Jakob's avatar
Wenzel Jakob committed
74
75
        };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            /* Do the call and convert the return value back into the Python domain */
Wenzel Jakob's avatar
Wenzel Jakob committed
142
143
144
145
146
147
            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);
148

149
            return result;
Wenzel Jakob's avatar
Wenzel Jakob committed
150
151
        };

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

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

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

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

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

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

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

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

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

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

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

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

Wenzel Jakob's avatar
Wenzel Jakob committed
259
        if (!chain) {
260
            /* No existing overload was found, create a new function object */
Wenzel Jakob's avatar
Wenzel Jakob committed
261
262
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;
            capsule rec_capsule(rec, [](PyObject *o) {
                destruct((detail::function_record *) PyCapsule_GetPointer(o, nullptr));
268
            });
Wenzel Jakob's avatar
Wenzel Jakob committed
269
            m_ptr = PyCFunction_New(rec->def, rec_capsule.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
270
            if (!m_ptr)
271
                pybind11_fail("cpp_function::cpp_function(): Could not allocate function object");
Wenzel Jakob's avatar
Wenzel Jakob committed
272
        } else {
273
            /* Append at the end of the overload chain */
Wenzel Jakob's avatar
Wenzel Jakob committed
274
            m_ptr = rec->sibling.ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
275
            inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
276
277
278
279
            chain_start = chain;
            while (chain->next)
                chain = chain->next;
            chain->next = rec;
Wenzel Jakob's avatar
Wenzel Jakob committed
280
        }
281

Wenzel Jakob's avatar
Wenzel Jakob committed
282
        std::string signatures;
283
        int index = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
284
        /* Create a nice pydoc rec including all signatures and
285
           docstrings of the functions in the overload chain */
Wenzel Jakob's avatar
Wenzel Jakob committed
286
287
        for (auto it = chain_start; it != nullptr; it = it->next) {
            if (chain)
288
                signatures += std::to_string(++index) + ". ";
289
290
291
292
293
294
295
296
            signatures += "Signature : ";
            signatures += it->signature;
            signatures += "\n";
            if (it->doc && strlen(it->doc) > 0) {
                signatures += "\n";
                signatures += it->doc;
                signatures += "\n";
            }
297
            if (it->next)
Wenzel Jakob's avatar
Wenzel Jakob committed
298
299
                signatures += "\n";
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
300
301

        /* Install docstring */
Wenzel Jakob's avatar
Wenzel Jakob committed
302
303
        PyCFunctionObject *func = (PyCFunctionObject *) m_ptr;
        if (func->m_ml->ml_doc)
304
            std::free((char *) func->m_ml->ml_doc);
Wenzel Jakob's avatar
Wenzel Jakob committed
305
        func->m_ml->ml_doc = strdup(signatures.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
306
307
308

        if (rec->class_) {
            m_ptr = PYBIND11_INSTANCE_METHOD_NEW(m_ptr, rec->class_.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
309
            if (!m_ptr)
310
                pybind11_fail("cpp_function::cpp_function(): Could not allocate instance method object");
Wenzel Jakob's avatar
Wenzel Jakob committed
311
312
313
            Py_DECREF(func);
        }
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
314
315
316
317
318
319
320
321
322
323
324
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

    /// 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
443
444
};

445
/// Wrapper for Python extension modules
Wenzel Jakob's avatar
Wenzel Jakob committed
446
447
class module : public object {
public:
448
    PYBIND11_OBJECT_DEFAULT(module, object, PyModule_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
449
450

    module(const char *name, const char *doc = nullptr) {
451
#if PY_MAJOR_VERSION >= 3
Wenzel Jakob's avatar
Wenzel Jakob committed
452
453
454
455
456
457
458
        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);
459
460
461
#else
        m_ptr = Py_InitModule3(name, nullptr, doc);
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
462
        if (m_ptr == nullptr)
463
            pybind11_fail("Internal error in module::module()");
Wenzel Jakob's avatar
Wenzel Jakob committed
464
465
466
        inc_ref();
    }

467
    template <typename Func, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
468
    module &def(const char *name_, Func &&f, const Extra& ... extra) {
469
        cpp_function func(std::forward<Func>(f), name(name_),
Wenzel Jakob's avatar
Wenzel Jakob committed
470
471
472
                          sibling((handle) attr(name_)), extra...);
        /* PyModule_AddObject steals a reference to 'func' */
        PyModule_AddObject(ptr(), name_, func.inc_ref().ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
473
474
475
        return *this;
    }

476
    module def_submodule(const char *name, const char *doc = nullptr) {
Wenzel Jakob's avatar
Wenzel Jakob committed
477
478
479
        std::string full_name = std::string(PyModule_GetName(m_ptr))
            + std::string(".") + std::string(name);
        module result(PyImport_AddModule(full_name.c_str()), true);
480
        if (doc)
481
            result.attr("__doc__") = pybind11::str(doc);
Wenzel Jakob's avatar
Wenzel Jakob committed
482
483
484
        attr(name) = result;
        return result;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
485
486

    static module import(const char *name) {
487
488
        PyObject *obj = PyImport_ImportModule(name);
        if (!obj)
489
            pybind11_fail("Module \"" + std::string(name) + "\" not found!");
490
        return module(obj, false);
Wenzel Jakob's avatar
Wenzel Jakob committed
491
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
492
493
494
};

NAMESPACE_BEGIN(detail)
Wenzel Jakob's avatar
Wenzel Jakob committed
495
/// Generic support for creating new Python heap types
496
class generic_type : public object {
Wenzel Jakob's avatar
Wenzel Jakob committed
497
    template <typename type, typename holder_type> friend class class_;
Wenzel Jakob's avatar
Wenzel Jakob committed
498
public:
499
    PYBIND11_OBJECT_DEFAULT(generic_type, object, PyType_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
500
501
502
503
504
505
506
507
508
509
510
511
512
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 + "\"");
            }
        }
513
514

        object type_holder(PyType_Type.tp_alloc(&PyType_Type, 0), false);
Wenzel Jakob's avatar
Wenzel Jakob committed
515
        object name(PYBIND11_FROM_STRING(rec->name), false);
516
517
518
        auto type = (PyHeapTypeObject*) type_holder.ptr();

        if (!type_holder || !name)
519
            pybind11_fail("generic_type: unable to create type object!");
520
521
522
523
524

        /* 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
525
526
527
        tinfo->type_size = rec->type_size;
        tinfo->init_holder = rec->init_holder;
        internals.registered_types_cpp[rec->type] = tinfo;
528
529
        internals.registered_types_py[type] = tinfo;

Wenzel Jakob's avatar
Wenzel Jakob committed
530
        auto scope_module = (object) rec->scope.attr("__module__");
531
        if (!scope_module)
Wenzel Jakob's avatar
Wenzel Jakob committed
532
            scope_module = (object) rec->scope.attr("__name__");
533

Wenzel Jakob's avatar
Wenzel Jakob committed
534
535
        std::string full_name = (scope_module ? ((std::string) scope_module.str() + "." + rec->name)
                                              : std::string(rec->name));
536
537
        /* Basic type attributes */
        type->ht_type.tp_name = strdup(full_name.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
538
539
540
        type->ht_type.tp_basicsize = rec->instance_size;
        type->ht_type.tp_base = (PyTypeObject *) rec->base_handle.ptr();
        rec->base_handle.inc_ref();
541
542
543

#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
        /* Qualified names for Python >= 3.3 */
Wenzel Jakob's avatar
Wenzel Jakob committed
544
        auto scope_qualname = (object) rec->scope.attr("__qualname__");
545
546
547
548
549
550
551
        if (scope_qualname) {
            type->ht_qualname = PyUnicode_FromFormat(
                "%U.%U", scope_qualname.ptr(), name.ptr());
        } else {
            type->ht_qualname = name.ptr();
            name.inc_ref();
        }
552
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
553
        type->ht_name = name.release().ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
554

555
556
557
558
        /* 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
559

560
        /* Supported elementary operations */
Wenzel Jakob's avatar
Wenzel Jakob committed
561
562
        type->ht_type.tp_init = (initproc) init;
        type->ht_type.tp_new = (newfunc) new_instance;
Wenzel Jakob's avatar
Wenzel Jakob committed
563
        type->ht_type.tp_dealloc = rec->dealloc;
564
565

        /* Support weak references (needed for the keep_alive feature) */
566
        type->ht_type.tp_weaklistoffset = offsetof(instance_essentials<void>, weakrefs);
567
568
569

        /* Flags */
        type->ht_type.tp_flags |= Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
570
571
572
#if PY_MAJOR_VERSION < 3
        type->ht_type.tp_flags |= Py_TPFLAGS_CHECKTYPES;
#endif
573
        type->ht_type.tp_flags &= ~Py_TPFLAGS_HAVE_GC;
574

Wenzel Jakob's avatar
Wenzel Jakob committed
575
        if (rec->doc) {
576
577
            /* Allocate memory for docstring (using PyObject_MALLOC, since
               Python will free this later on) */
Wenzel Jakob's avatar
Wenzel Jakob committed
578
            size_t size = strlen(rec->doc) + 1;
579
            type->ht_type.tp_doc = (char *) PyObject_MALLOC(size);
Wenzel Jakob's avatar
Wenzel Jakob committed
580
            memcpy((void *) type->ht_type.tp_doc, rec->doc, size);
Wenzel Jakob's avatar
Wenzel Jakob committed
581
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
582
583

        if (PyType_Ready(&type->ht_type) < 0)
584
            pybind11_fail("generic_type: PyType_Ready failed!");
585
586

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

588
        if (scope_module) // Needed by pydoc
Wenzel Jakob's avatar
Wenzel Jakob committed
589
            attr("__module__") = scope_module;
Wenzel Jakob's avatar
Wenzel Jakob committed
590

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

594
        type_holder.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
595
596
    }

597
    /// Allocate a metaclass on demand (for static properties)
Wenzel Jakob's avatar
Wenzel Jakob committed
598
599
    handle metaclass() {
        auto &ht_type = ((PyHeapTypeObject *) m_ptr)->ht_type;
600
        auto &ob_type = PYBIND11_OB_TYPE(ht_type);
601

Wenzel Jakob's avatar
Wenzel Jakob committed
602
        if (ob_type == &PyType_Type) {
603
604
605
606
            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)
607
                pybind11_fail("generic_type::metaclass(): unable to create type object!");
608
609

            auto type = (PyHeapTypeObject*) type_holder.ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
610
611
612
613
614
615
            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
616
            type->ht_type.tp_name = strdup(name_.c_str());
Wenzel Jakob's avatar
Wenzel Jakob committed
617
            type->ht_type.tp_base = ob_type;
618
619
620
            type->ht_type.tp_flags |= (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE) &
                                      ~Py_TPFLAGS_HAVE_GC;

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

Wenzel Jakob's avatar
Wenzel Jakob committed
624
            ob_type = (PyTypeObject *) type_holder.release().ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
625
626
627
628
629
630
631
632
633
634
635
        }
        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 *) {
636
637
638
        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
639
640
641
642
643
644
645
646
647
648
649
650
651
652
        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())
653
                    pybind11_fail("generic_type::dealloc(): Tried to deallocate unregistered instance!");
Wenzel Jakob's avatar
Wenzel Jakob committed
654
655
656
                registered_instances.erase(it);
            }
            Py_XDECREF(self->parent);
657
658
            if (self->weakrefs)
                PyObject_ClearWeakRefs((PyObject *) self);
Wenzel Jakob's avatar
Wenzel Jakob committed
659
660
661
662
        }
        Py_TYPE(self)->tp_free((PyObject*) self);
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
663
664
665
    void install_buffer_funcs(
            buffer_info *(*get_buffer)(PyObject *, void *),
            void *get_buffer_data) {
Wenzel Jakob's avatar
Wenzel Jakob committed
666
667
        PyHeapTypeObject *type = (PyHeapTypeObject*) m_ptr;
        type->ht_type.tp_as_buffer = &type->as_buffer;
668
669
670
#if PY_MAJOR_VERSION < 3
        type->ht_type.tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER;
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
671
672
        type->as_buffer.bf_getbuffer = getbuffer;
        type->as_buffer.bf_releasebuffer = releasebuffer;
673
674
675
        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
676
677
678
    }

    static int getbuffer(PyObject *obj, Py_buffer *view, int flags) {
679
680
681
        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
682
683
684
            return -1;
        }
        memset(view, 0, sizeof(Py_buffer));
685
        buffer_info *info = tinfo->get_buffer(obj, tinfo->get_buffer_data);
Wenzel Jakob's avatar
Wenzel Jakob committed
686
687
688
689
690
691
692
693
694
695
696
697
        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;
698
699
            view->strides = (ssize_t *) &info->strides[0];
            view->shape = (ssize_t *) &info->shape[0];
Wenzel Jakob's avatar
Wenzel Jakob committed
700
701
702
703
704
705
706
707
708
        }
        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
709
710
template <typename type, typename holder_type = std::unique_ptr<type>>
class class_ : public detail::generic_type {
Wenzel Jakob's avatar
Wenzel Jakob committed
711
712
713
public:
    typedef detail::instance<type, holder_type> instance_type;

714
    PYBIND11_OBJECT(class_, detail::generic_type, PyType_Check)
Wenzel Jakob's avatar
Wenzel Jakob committed
715

Wenzel Jakob's avatar
Wenzel Jakob committed
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
    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
732

733
    template <typename Func, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
734
    class_ &def(const char *name_, Func&& f, const Extra&... extra) {
735
        cpp_function cf(std::forward<Func>(f), name(name_),
Wenzel Jakob's avatar
Wenzel Jakob committed
736
737
                        sibling(attr(name_)), is_method(*this),
                        extra...);
738
        attr(cf.name()) = cf;
Wenzel Jakob's avatar
Wenzel Jakob committed
739
740
741
        return *this;
    }

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

750
    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
751
752
    class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
        op.template execute<type>(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
753
754
755
        return *this;
    }

756
    template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
757
758
    class_ & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
        op.template execute_cast<type>(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
759
760
761
        return *this;
    }

762
    template <typename... Args, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
763
764
    class_ &def(const detail::init<Args...> &init, const Extra&... extra) {
        init.template execute<type>(*this, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
765
766
767
        return *this;
    }

768
    template <typename Func> class_& def_buffer(Func &&func) {
Wenzel Jakob's avatar
Wenzel Jakob committed
769
770
771
        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
772
773
774
            detail::type_caster<type> caster;
            if (!caster.load(obj, false))
                return nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
775
776
            return new buffer_info(((capture *) ptr)->func(caster));
        }, ptr);
Wenzel Jakob's avatar
Wenzel Jakob committed
777
778
779
        return *this;
    }

780
    template <typename C, typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
781
    class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
782
783
        cpp_function fget([pm](const C &c) -> const D &{ return c.*pm; },
                          return_value_policy::reference_internal,
Wenzel Jakob's avatar
Wenzel Jakob committed
784
                          is_method(*this), extra...),
785
                     fset([pm](C &c, const D &value) { c.*pm = value; },
Wenzel Jakob's avatar
Wenzel Jakob committed
786
                          is_method(*this), extra...);
787
        def_property(name, fget, fset);
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_readonly(const char *name, const 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
        def_property_readonly(name, fget);
Wenzel Jakob's avatar
Wenzel Jakob committed
797
798
799
        return *this;
    }

800
    template <typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
801
802
    class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
        cpp_function fget([pm](object) -> const D &{ return *pm; },
803
804
805
                          return_value_policy::reference_internal, extra...),
                     fset([pm](object, const D &value) { *pm = value; }, extra...);
        def_property_static(name, fget, fset);
Wenzel Jakob's avatar
Wenzel Jakob committed
806
807
808
        return *this;
    }

809
    template <typename D, typename... Extra>
Wenzel Jakob's avatar
Wenzel Jakob committed
810
811
812
    class_ &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
        cpp_function fget([pm](object) -> const D &{ return *pm; },
                          return_value_policy::reference_internal, extra...);
813
        def_property_readonly_static(name, fget);
Wenzel Jakob's avatar
Wenzel Jakob committed
814
815
816
        return *this;
    }

817
818
    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
819
820
821
        return *this;
    }

822
823
    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
824
825
826
        return *this;
    }

827
    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
828
        object doc_obj = doc ? pybind11::str(doc) : (object) fget.attr("__doc__");
Wenzel Jakob's avatar
Wenzel Jakob committed
829
        object property(
Wenzel Jakob's avatar
Wenzel Jakob committed
830
831
            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
832
833
834
835
        attr(name) = property;
        return *this;
    }

836
    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
837
        object doc_obj = doc ? pybind11::str(doc) : (object) fget.attr("__doc__");
Wenzel Jakob's avatar
Wenzel Jakob committed
838
        object property(
Wenzel Jakob's avatar
Wenzel Jakob committed
839
840
            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
841
842
843
        metaclass().attr(name) = property;
        return *this;
    }
844
845

    template <typename target> class_ alias() {
846
        auto &instances = pybind11::detail::get_internals().registered_types_cpp;
847
848
849
        instances[&typeid(target)] = instances[&typeid(type)];
        return *this;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
850
private:
851
852
853
    /// 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 */) {
854
        try {
855
            new (&inst->holder) holder_type(inst->value->shared_from_this());
856
857
858
        } catch (const std::bad_weak_ptr &) {
            new (&inst->holder) holder_type(inst->value);
        }
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
    }

    /// 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);
882
883
884
        inst->constructed = true;
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
885
886
887
888
889
890
891
892
    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);
        }
893
        generic_type::dealloc((detail::instance<void> *) inst);
Wenzel Jakob's avatar
Wenzel Jakob committed
894
895
896
897
898
899
    }
};

/// Binds C++ enumerations and enumeration classes to Python
template <typename Type> class enum_ : public class_<Type> {
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
900
901
902
    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
903
        auto entries = new std::unordered_map<int, const char *>();
904
        this->def("__repr__", [name, entries](Type value) -> std::string {
Wenzel Jakob's avatar
Wenzel Jakob committed
905
            auto it = entries->find((int) value);
Wenzel Jakob's avatar
Wenzel Jakob committed
906
907
908
909
            return std::string(name) + "." +
                ((it == entries->end()) ? std::string("???")
                                        : std::string(it->second));
        });
910
        this->def("__init__", [](Type& value, int i) { value = (Type) i; });
911
        this->def("__int__", [](Type value) { return (int) value; });
912
913
914
        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
915
916
917
918
919
920
921
        m_entries = entries;
    }

    /// Export enumeration entries into the parent scope
    void export_values() {
        PyObject *dict = ((PyTypeObject *) this->m_ptr)->tp_dict;
        PyObject *key, *value;
922
        ssize_t pos = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
923
924
925
926
927
928
929
        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) {
930
        this->attr(name) = pybind11::cast(value, return_value_policy::copy);
Wenzel Jakob's avatar
Wenzel Jakob committed
931
932
933
934
935
        (*m_entries)[(int) value] = name;
        return *this;
    }
private:
    std::unordered_map<int, const char *> *m_entries;
Wenzel Jakob's avatar
Wenzel Jakob committed
936
    handle m_parent;
Wenzel Jakob's avatar
Wenzel Jakob committed
937
938
939
};

NAMESPACE_BEGIN(detail)
940
template <typename... Args> struct init {
Wenzel Jakob's avatar
Wenzel Jakob committed
941
    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
942
        /// Function which calls a specific C++ in-place constructor
Wenzel Jakob's avatar
Wenzel Jakob committed
943
        class_.def("__init__", [](Base *instance, Args... args) { new (instance) Base(args...); }, extra...);
Wenzel Jakob's avatar
Wenzel Jakob committed
944
945
    }
};
946

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

952
    if (!nurse || !patient)
953
        pybind11_fail("Could not activate keep_alive!");
954
955

    cpp_function disable_lifesupport(
956
        [patient](handle weakref) { patient.dec_ref(); weakref.dec_ref(); });
957

958
    weakref wr(nurse, disable_lifesupport);
959

960
961
    patient.inc_ref(); /* reference patient and leak the weak reference */
    (void) wr.release();
962
963
}

Wenzel Jakob's avatar
Wenzel Jakob committed
964
965
966
967
968
NAMESPACE_END(detail)

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

template <typename InputType, typename OutputType> void implicitly_convertible() {
969
    auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject * {
Wenzel Jakob's avatar
Wenzel Jakob committed
970
971
972
973
974
975
976
977
978
        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;
    };
979
    auto & registered_types = detail::get_internals().registered_types_cpp;
980
    auto it = registered_types.find(&typeid(OutputType));
Wenzel Jakob's avatar
Wenzel Jakob committed
981
    if (it == registered_types.end())
982
        pybind11_fail("implicitly_convertible: Unable to find type " + type_id<OutputType>());
983
    ((detail::type_info *) it->second)->implicit_conversions.push_back(implicit_caster);
Wenzel Jakob's avatar
Wenzel Jakob committed
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
}

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

1002
1003
inline function get_overload(const void *this_ptr, const char *name)  {
    handle py_object = detail::get_object_handle(this_ptr);
1004
1005
    if (!py_object)
        return function();
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
    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();
    }
1020

1021
    PyFrameObject *frame = PyThreadState_Get()->frame;
1022
    pybind11::str caller = pybind11::handle(frame->f_code->co_name).str();
1023
    if ((std::string) caller == name)
1024
1025
1026
1027
        return function();
    return overload;
}

1028
#define PYBIND11_OVERLOAD_INT(ret_type, class_name, name, ...) { \
1029
1030
        pybind11::gil_scoped_acquire gil; \
        pybind11::function overload = pybind11::get_overload(this, #name); \
1031
1032
1033
        if (overload) \
            return overload.call(__VA_ARGS__).cast<ret_type>();  }

1034
1035
#define PYBIND11_OVERLOAD(ret_type, class_name, name, ...) \
    PYBIND11_OVERLOAD_INT(ret_type, class_name, name, __VA_ARGS__) \
1036
1037
    return class_name::name(__VA_ARGS__)

1038
1039
#define PYBIND11_OVERLOAD_PURE(ret_type, class_name, name, ...) \
    PYBIND11_OVERLOAD_INT(ret_type, class_name, name, __VA_ARGS__) \
1040
    pybind11::pybind11_fail("Tried to call pure virtual function \"" #name "\"");
1041

1042
NAMESPACE_END(pybind11)
Wenzel Jakob's avatar
Wenzel Jakob committed
1043
1044

#if defined(_MSC_VER)
Wenzel Jakob's avatar
Wenzel Jakob committed
1045
#  pragma warning(pop)
1046
#elif defined(__GNUG__) and !defined(__clang__)
Wenzel Jakob's avatar
Wenzel Jakob committed
1047
#  pragma GCC diagnostic pop
Wenzel Jakob's avatar
Wenzel Jakob committed
1048
#endif