cast.h 86.3 KB
Newer Older
Wenzel Jakob's avatar
Wenzel Jakob committed
1
/*
2
    pybind11/cast.h: Partial template specializations to cast between
Wenzel Jakob's avatar
Wenzel Jakob committed
3
4
    C++ and Python types

5
    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
Wenzel Jakob's avatar
Wenzel Jakob committed
6
7
8
9
10

    All rights reserved. Use of this source code is governed by a
    BSD-style license that can be found in the LICENSE file.
*/

11
#pragma once
Wenzel Jakob's avatar
Wenzel Jakob committed
12

13
#include "pytypes.h"
14
15
#include "detail/typeid.h"
#include "detail/descr.h"
Wenzel Jakob's avatar
Wenzel Jakob committed
16
#include <array>
Wenzel Jakob's avatar
Wenzel Jakob committed
17
#include <limits>
18
#include <tuple>
Wenzel Jakob's avatar
Wenzel Jakob committed
19

20
21
22
23
24
25
26
27
28
29
30
31
32
#if defined(PYBIND11_CPP17)
#  if defined(__has_include)
#    if __has_include(<string_view>)
#      define PYBIND11_HAS_STRING_VIEW
#    endif
#  elif defined(_MSC_VER)
#    define PYBIND11_HAS_STRING_VIEW
#  endif
#endif
#ifdef PYBIND11_HAS_STRING_VIEW
#include <string_view>
#endif

33
NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
Wenzel Jakob's avatar
Wenzel Jakob committed
34
NAMESPACE_BEGIN(detail)
35
// Forward declarations:
36
37
inline PyTypeObject *make_static_property_type();
inline PyTypeObject *make_default_metaclass();
38
39
inline PyObject *make_object_base_type(PyTypeObject *metaclass);
struct value_and_holder;
Wenzel Jakob's avatar
Wenzel Jakob committed
40

Wenzel Jakob's avatar
Wenzel Jakob committed
41
42
43
/// Additional type information which does not fit into the PyTypeObject
struct type_info {
    PyTypeObject *type;
44
    const std::type_info *cpptype;
45
    size_t type_size, holder_size_in_ptrs;
46
    void *(*operator_new)(size_t);
47
    void (*init_instance)(instance *, const void *);
48
    void (*dealloc)(const value_and_holder &v_h);
Wenzel Jakob's avatar
Wenzel Jakob committed
49
50
    std::vector<PyObject *(*)(PyObject *, PyTypeObject *)> implicit_conversions;
    std::vector<std::pair<const std::type_info *, void *(*)(void *)>> implicit_casts;
51
    std::vector<bool (*)(PyObject *, void *&)> *direct_conversions;
Wenzel Jakob's avatar
Wenzel Jakob committed
52
53
    buffer_info *(*get_buffer)(PyObject *, void *) = nullptr;
    void *get_buffer_data = nullptr;
54
    /* A simple type never occurs as a (direct or indirect) parent
Wenzel Jakob's avatar
Wenzel Jakob committed
55
     * of a class that makes use of multiple inheritance */
56
57
58
    bool simple_type : 1;
    /* True if there is no multiple inheritance in this type's inheritance tree */
    bool simple_ancestors : 1;
59
    /* for base vs derived holder_type checks */
60
    bool default_holder : 1;
61
62
    /* true if this is a type registered with py::module_local */
    bool module_local : 1;
Wenzel Jakob's avatar
Wenzel Jakob committed
63
};
64

65
66
67
68
PYBIND11_UNSHARED_STATIC_LOCALS PYBIND11_NOINLINE inline internals *&get_internals_ptr() {
    static internals *internals_ptr = nullptr;
    return internals_ptr;
}
69

Wenzel Jakob's avatar
Wenzel Jakob committed
70
PYBIND11_NOINLINE inline internals &get_internals() {
71
    internals *&internals_ptr = get_internals_ptr();
Wenzel Jakob's avatar
Wenzel Jakob committed
72
73
74
    if (internals_ptr)
        return *internals_ptr;
    handle builtins(PyEval_GetBuiltins());
75
    const char *id = PYBIND11_INTERNALS_ID;
76
    if (builtins.contains(id) && isinstance<capsule>(builtins[id])) {
77
        internals_ptr = *static_cast<internals **>(capsule(builtins[id]));
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

        // We loaded builtins through python's builtins, which means that our error_already_set and
        // builtin_exception may be different local classes than the ones set up in the initial
        // exception translator, below, so add another for our local exception classes.
        //
        // stdlibc++ doesn't require this (types there are identified only by name)
        #if !defined(__GLIBCXX__)
        internals_ptr->registered_exception_translators.push_front(
            [](std::exception_ptr p) -> void {
                try {
                    if (p) std::rethrow_exception(p);
                } catch (error_already_set &e)       { e.restore();   return;
                } catch (const builtin_exception &e) { e.set_error(); return;
                }
            }
        );
        #endif
Wenzel Jakob's avatar
Wenzel Jakob committed
95
96
    } else {
        internals_ptr = new internals();
97
98
99
100
101
102
103
        #if defined(WITH_THREAD)
            PyEval_InitThreads();
            PyThreadState *tstate = PyThreadState_Get();
            internals_ptr->tstate = PyThread_create_key();
            PyThread_set_key_value(internals_ptr->tstate, tstate);
            internals_ptr->istate = tstate->interp;
        #endif
104
        builtins[id] = capsule(&internals_ptr);
105
106
107
108
        internals_ptr->registered_exception_translators.push_front(
            [](std::exception_ptr p) -> void {
                try {
                    if (p) std::rethrow_exception(p);
109
                } catch (error_already_set &e)           { e.restore();                                    return;
110
                } catch (const builtin_exception &e)     { e.set_error();                                  return;
111
112
113
114
115
116
117
118
119
120
121
122
123
                } catch (const std::bad_alloc &e)        { PyErr_SetString(PyExc_MemoryError,   e.what()); return;
                } catch (const std::domain_error &e)     { PyErr_SetString(PyExc_ValueError,    e.what()); return;
                } catch (const std::invalid_argument &e) { PyErr_SetString(PyExc_ValueError,    e.what()); return;
                } catch (const std::length_error &e)     { PyErr_SetString(PyExc_ValueError,    e.what()); return;
                } catch (const std::out_of_range &e)     { PyErr_SetString(PyExc_IndexError,    e.what()); return;
                } catch (const std::range_error &e)      { PyErr_SetString(PyExc_ValueError,    e.what()); return;
                } catch (const std::exception &e)        { PyErr_SetString(PyExc_RuntimeError,  e.what()); return;
                } catch (...) {
                    PyErr_SetString(PyExc_RuntimeError, "Caught an unknown exception!");
                    return;
                }
            }
        );
124
125
        internals_ptr->static_property_type = make_static_property_type();
        internals_ptr->default_metaclass = make_default_metaclass();
126
        internals_ptr->instance_base = make_object_base_type(internals_ptr->default_metaclass);
Wenzel Jakob's avatar
Wenzel Jakob committed
127
128
129
130
    }
    return *internals_ptr;
}

131
132
133
134
135
136
// Works like internals.registered_types_cpp, but for module-local registered types:
PYBIND11_NOINLINE PYBIND11_UNSHARED_STATIC_LOCALS inline type_map<void *> &registered_local_types_cpp() {
    static type_map<void *> locals{};
    return locals;
}

137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
/// A life support system for temporary objects created by `type_caster::load()`.
/// Adding a patient will keep it alive up until the enclosing function returns.
class loader_life_support {
public:
    /// A new patient frame is created when a function is entered
    loader_life_support() {
        get_internals().loader_patient_stack.push_back(nullptr);
    }

    /// ... and destroyed after it returns
    ~loader_life_support() {
        auto &stack = get_internals().loader_patient_stack;
        if (stack.empty())
            pybind11_fail("loader_life_support: internal error");

        auto ptr = stack.back();
        stack.pop_back();
        Py_CLEAR(ptr);

        // A heuristic to reduce the stack's capacity (e.g. after long recursive calls)
        if (stack.capacity() > 16 && stack.size() != 0 && stack.capacity() / stack.size() > 2)
            stack.shrink_to_fit();
    }

    /// This can only be used inside a pybind11-bound function, either by `argument_loader`
    /// at argument preparation time or by `py::cast()` at execution time.
    PYBIND11_NOINLINE static void add_patient(handle h) {
        auto &stack = get_internals().loader_patient_stack;
        if (stack.empty())
            throw cast_error("When called outside a bound function, py::cast() cannot "
                             "do Python -> C++ conversions which require the creation "
                             "of temporary values");

        auto &list_ptr = stack.back();
        if (list_ptr == nullptr) {
            list_ptr = PyList_New(1);
            if (!list_ptr)
                pybind11_fail("loader_life_support: error allocating list");
            PyList_SET_ITEM(list_ptr, 0, h.inc_ref().ptr());
        } else {
            auto result = PyList_Append(list_ptr, h.ptr());
            if (result == -1)
                pybind11_fail("loader_life_support: error adding patient");
        }
    }
};

184
185
186
187
188
189
190
191
192
193
194
// Gets the cache entry for the given type, creating it if necessary.  The return value is the pair
// returned by emplace, i.e. an iterator for the entry and a bool set to `true` if the entry was
// just created.
inline std::pair<decltype(internals::registered_types_py)::iterator, bool> all_type_info_get_cache(PyTypeObject *type);

// Populates a just-created cache entry.
PYBIND11_NOINLINE inline void all_type_info_populate(PyTypeObject *t, std::vector<type_info *> &bases) {
    std::vector<PyTypeObject *> check;
    for (handle parent : reinterpret_borrow<tuple>(t->tp_bases))
        check.push_back((PyTypeObject *) parent.ptr());

Wenzel Jakob's avatar
Wenzel Jakob committed
195
    auto const &type_dict = get_internals().registered_types_py;
196
197
198
199
200
201
    for (size_t i = 0; i < check.size(); i++) {
        auto type = check[i];
        // Ignore Python2 old-style class super type:
        if (!PyType_Check((PyObject *) type)) continue;

        // Check `type` in the current set of registered python types:
Wenzel Jakob's avatar
Wenzel Jakob committed
202
        auto it = type_dict.find(type);
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
        if (it != type_dict.end()) {
            // We found a cache entry for it, so it's either pybind-registered or has pre-computed
            // pybind bases, but we have to make sure we haven't already seen the type(s) before: we
            // want to follow Python/virtual C++ rules that there should only be one instance of a
            // common base.
            for (auto *tinfo : it->second) {
                // NB: Could use a second set here, rather than doing a linear search, but since
                // having a large number of immediate pybind11-registered types seems fairly
                // unlikely, that probably isn't worthwhile.
                bool found = false;
                for (auto *known : bases) {
                    if (known == tinfo) { found = true; break; }
                }
                if (!found) bases.push_back(tinfo);
            }
        }
        else if (type->tp_bases) {
            // It's some python type, so keep follow its bases classes to look for one or more
            // registered types
            if (i + 1 == check.size()) {
                // When we're at the end, we can pop off the current element to avoid growing
224
                // `check` when adding just one base (which is typical--i.e. when there is no
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
                // multiple inheritance)
                check.pop_back();
                i--;
            }
            for (handle parent : reinterpret_borrow<tuple>(type->tp_bases))
                check.push_back((PyTypeObject *) parent.ptr());
        }
    }
}

/**
 * Extracts vector of type_info pointers of pybind-registered roots of the given Python type.  Will
 * be just 1 pybind type for the Python type of a pybind-registered class, or for any Python-side
 * derived class that uses single inheritance.  Will contain as many types as required for a Python
 * class that uses multiple inheritance to inherit (directly or indirectly) from multiple
 * pybind-registered classes.  Will be empty if neither the type nor any base classes are
 * pybind-registered.
 *
 * The value is cached for the lifetime of the Python type.
 */
inline const std::vector<detail::type_info *> &all_type_info(PyTypeObject *type) {
    auto ins = all_type_info_get_cache(type);
    if (ins.second)
        // New cache entry: populate it
        all_type_info_populate(type, ins.first->second);

    return ins.first->second;
}

/**
 * Gets a single pybind11 type info for a python type.  Returns nullptr if neither the type nor any
 * ancestors are pybind11-registered.  Throws an exception if there are multiple bases--use
 * `all_type_info` instead if you want to support multiple bases.
 */
PYBIND11_NOINLINE inline detail::type_info* get_type_info(PyTypeObject *type) {
    auto &bases = all_type_info(type);
    if (bases.size() == 0)
        return nullptr;
    if (bases.size() > 1)
        pybind11_fail("pybind11::detail::get_type_info: type has multiple pybind11-registered bases");
    return bases.front();
Wenzel Jakob's avatar
Wenzel Jakob committed
266
267
}

268
/// Return the type info for a given C++ type; on lookup failure can either throw or return nullptr.
269
270
/// `check_global_types` can be specified as `false` to only check types registered locally to the
/// current module.
271
PYBIND11_NOINLINE inline detail::type_info *get_type_info(const std::type_index &tp,
272
273
                                                          bool throw_if_missing = false,
                                                          bool check_global_types = true) {
274
275
    std::type_index type_idx(tp);
    auto &locals = registered_local_types_cpp();
276
    auto it = locals.find(type_idx);
277
278
    if (it != locals.end())
        return (detail::type_info *) it->second;
279
280
281
282
283
284
    if (check_global_types) {
        auto &types = get_internals().registered_types_cpp;
        it = types.find(type_idx);
        if (it != types.end())
            return (detail::type_info *) it->second;
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
285
286
287
288
289
    if (throw_if_missing) {
        std::string tname = tp.name();
        detail::clean_type_id(tname);
        pybind11_fail("pybind11::detail::get_type_info: unable to find type info for \"" + tname + "\"");
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
290
291
292
    return nullptr;
}

Wenzel Jakob's avatar
Wenzel Jakob committed
293
294
PYBIND11_NOINLINE inline handle get_type_handle(const std::type_info &tp, bool throw_if_missing) {
    detail::type_info *type_info = get_type_info(tp, throw_if_missing);
Wenzel Jakob's avatar
Wenzel Jakob committed
295
296
297
    return handle(type_info ? ((PyObject *) type_info->type) : nullptr);
}

298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
struct value_and_holder {
    instance *inst;
    size_t index;
    const detail::type_info *type;
    void **vh;

    value_and_holder(instance *i, const detail::type_info *type, size_t vpos, size_t index) :
        inst{i}, index{index}, type{type},
        vh{inst->simple_layout ? inst->simple_value_holder : &inst->nonsimple.values_and_holders[vpos]}
    {}

    // Used for past-the-end iterator
    value_and_holder(size_t index) : index{index} {}

    template <typename V = void> V *&value_ptr() const {
        return reinterpret_cast<V *&>(vh[0]);
    }
    // True if this `value_and_holder` has a non-null value pointer
    explicit operator bool() const { return value_ptr(); }

    template <typename H> H &holder() const {
        return reinterpret_cast<H &>(vh[1]);
    }
    bool holder_constructed() const {
        return inst->simple_layout
            ? inst->simple_holder_constructed
324
            : inst->nonsimple.status[index] & instance::status_holder_constructed;
325
326
327
328
329
    }
    void set_holder_constructed() {
        if (inst->simple_layout)
            inst->simple_holder_constructed = true;
        else
330
331
332
333
334
335
336
337
338
339
340
341
            inst->nonsimple.status[index] |= instance::status_holder_constructed;
    }
    bool instance_registered() const {
        return inst->simple_layout
            ? inst->simple_instance_registered
            : inst->nonsimple.status[index] & instance::status_instance_registered;
    }
    void set_instance_registered() {
        if (inst->simple_layout)
            inst->simple_instance_registered = true;
        else
            inst->nonsimple.status[index] |= instance::status_instance_registered;
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
    }
};

// Container for accessing and iterating over an instance's values/holders
struct values_and_holders {
private:
    instance *inst;
    using type_vec = std::vector<detail::type_info *>;
    const type_vec &tinfo;

public:
    values_and_holders(instance *inst) : inst{inst}, tinfo(all_type_info(Py_TYPE(inst))) {}

    struct iterator {
    private:
        instance *inst;
358
        const type_vec *types;
359
360
        value_and_holder curr;
        friend struct values_and_holders;
361
362
        iterator(instance *inst, const type_vec *tinfo)
            : inst{inst}, types{tinfo},
363
            curr(inst /* instance */,
364
                 types->empty() ? nullptr : (*types)[0] /* type info */,
365
366
367
368
369
370
371
372
373
                 0, /* vpos: (non-simple types only): the first vptr comes first */
                 0 /* index */)
        {}
        // Past-the-end iterator:
        iterator(size_t end) : curr(end) {}
    public:
        bool operator==(const iterator &other) { return curr.index == other.curr.index; }
        bool operator!=(const iterator &other) { return curr.index != other.curr.index; }
        iterator &operator++() {
374
375
            if (!inst->simple_layout)
                curr.vh += 1 + (*types)[curr.index]->holder_size_in_ptrs;
376
            ++curr.index;
377
            curr.type = curr.index < types->size() ? (*types)[curr.index] : nullptr;
378
379
380
381
382
383
            return *this;
        }
        value_and_holder &operator*() { return curr; }
        value_and_holder *operator->() { return &curr; }
    };

384
    iterator begin() { return iterator(inst, &tinfo); }
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
    iterator end() { return iterator(tinfo.size()); }

    iterator find(const type_info *find_type) {
        auto it = begin(), endit = end();
        while (it != endit && it->type != find_type) ++it;
        return it;
    }

    size_t size() { return tinfo.size(); }
};

/**
 * Extracts C++ value and holder pointer references from an instance (which may contain multiple
 * values/holders for python-side multiple inheritance) that match the given type.  Throws an error
 * if the given type (or ValueType, if omitted) is not a pybind11 base of the given instance.  If
 * `find_type` is omitted (or explicitly specified as nullptr) the first value/holder are returned,
 * regardless of type (and the resulting .type will be nullptr).
 *
 * The returned object should be short-lived: in particular, it must not outlive the called-upon
 * instance.
 */
PYBIND11_NOINLINE inline value_and_holder instance::get_value_and_holder(const type_info *find_type /*= nullptr default in common.h*/) {
    // Optimize common case:
    if (!find_type || Py_TYPE(this) == find_type->type)
        return value_and_holder(this, find_type, 0, 0);

    detail::values_and_holders vhs(this);
    auto it = vhs.find(find_type);
    if (it != vhs.end())
        return *it;

#if defined(NDEBUG)
    pybind11_fail("pybind11::detail::instance::get_value_and_holder: "
            "type is not a pybind11 base of the given instance "
            "(compile in debug mode for type details)");
#else
    pybind11_fail("pybind11::detail::instance::get_value_and_holder: `" +
            std::string(find_type->type->tp_name) + "' is not a pybind11 base of the given `" +
            std::string(Py_TYPE(this)->tp_name) + "' instance");
#endif
}

PYBIND11_NOINLINE inline void instance::allocate_layout() {
    auto &tinfo = all_type_info(Py_TYPE(this));

    const size_t n_types = tinfo.size();

    if (n_types == 0)
        pybind11_fail("instance allocation failed: new instance has no pybind11-registered base types");

    simple_layout =
        n_types == 1 && tinfo.front()->holder_size_in_ptrs <= instance_simple_holder_in_ptrs();

    // Simple path: no python-side multiple inheritance, and a small-enough holder
    if (simple_layout) {
        simple_value_holder[0] = nullptr;
        simple_holder_constructed = false;
442
        simple_instance_registered = false;
443
444
445
446
447
448
449
450
451
452
453
454
    }
    else { // multiple base types or a too-large holder
        // Allocate space to hold: [v1*][h1][v2*][h2]...[bb...] where [vN*] is a value pointer,
        // [hN] is the (uninitialized) holder instance for value N, and [bb...] is a set of bool
        // values that tracks whether each associated holder has been initialized.  Each [block] is
        // padded, if necessary, to an integer multiple of sizeof(void *).
        size_t space = 0;
        for (auto t : tinfo) {
            space += 1; // value pointer
            space += t->holder_size_in_ptrs; // holder instance
        }
        size_t flags_at = space;
455
        space += size_in_ptrs(n_types); // status bytes (holder_constructed and instance_registered)
456
457
458
459
460
461
462
463
464
465
466
467
468
469

        // Allocate space for flags, values, and holders, and initialize it to 0 (flags and values,
        // in particular, need to be 0).  Use Python's memory allocation functions: in Python 3.6
        // they default to using pymalloc, which is designed to be efficient for small allocations
        // like the one we're doing here; in earlier versions (and for larger allocations) they are
        // just wrappers around malloc.
#if PY_VERSION_HEX >= 0x03050000
        nonsimple.values_and_holders = (void **) PyMem_Calloc(space, sizeof(void *));
        if (!nonsimple.values_and_holders) throw std::bad_alloc();
#else
        nonsimple.values_and_holders = (void **) PyMem_New(void *, space);
        if (!nonsimple.values_and_holders) throw std::bad_alloc();
        std::memset(nonsimple.values_and_holders, 0, space * sizeof(void *));
#endif
470
        nonsimple.status = reinterpret_cast<uint8_t *>(&nonsimple.values_and_holders[flags_at]);
471
472
473
474
475
476
477
478
479
    }
    owned = true;
}

PYBIND11_NOINLINE inline void instance::deallocate_layout() {
    if (!simple_layout)
        PyMem_Free(nonsimple.values_and_holders);
}

480
PYBIND11_NOINLINE inline bool isinstance_generic(handle obj, const std::type_info &tp) {
Wenzel Jakob's avatar
Wenzel Jakob committed
481
    handle type = detail::get_type_handle(tp, false);
482
483
    if (!type)
        return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
484
    return isinstance(obj, type);
485
486
}

Wenzel Jakob's avatar
Wenzel Jakob committed
487
PYBIND11_NOINLINE inline std::string error_string() {
488
489
490
491
492
    if (!PyErr_Occurred()) {
        PyErr_SetString(PyExc_RuntimeError, "Unknown internal error occurred");
        return "Unknown internal error occurred";
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
493
    error_scope scope; // Preserve error state
Wenzel Jakob's avatar
Wenzel Jakob committed
494

495
    std::string errorString;
Wenzel Jakob's avatar
Wenzel Jakob committed
496
497
    if (scope.type) {
        errorString += handle(scope.type).attr("__name__").cast<std::string>();
Wenzel Jakob's avatar
Wenzel Jakob committed
498
499
        errorString += ": ";
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
500
    if (scope.value)
501
        errorString += (std::string) str(scope.value);
Wenzel Jakob's avatar
Wenzel Jakob committed
502

503
504
    PyErr_NormalizeException(&scope.type, &scope.value, &scope.trace);

505
506
507
508
509
#if PY_MAJOR_VERSION >= 3
    if (scope.trace != nullptr)
        PyException_SetTraceback(scope.value, scope.trace);
#endif

Wenzel Jakob's avatar
Wenzel Jakob committed
510
#if !defined(PYPY_VERSION)
511
    if (scope.trace) {
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
        PyTracebackObject *trace = (PyTracebackObject *) scope.trace;

        /* Get the deepest trace possible */
        while (trace->tb_next)
            trace = trace->tb_next;

        PyFrameObject *frame = trace->tb_frame;
        errorString += "\n\nAt:\n";
        while (frame) {
            int lineno = PyFrame_GetLineNumber(frame);
            errorString +=
                "  " + handle(frame->f_code->co_filename).cast<std::string>() +
                "(" + std::to_string(lineno) + "): " +
                handle(frame->f_code->co_name).cast<std::string>() + "\n";
            frame = frame->f_back;
527
        }
528
        trace = trace->tb_next;
529
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
530
#endif
531

Wenzel Jakob's avatar
Wenzel Jakob committed
532
533
534
    return errorString;
}

535
536
537
538
PYBIND11_NOINLINE inline handle get_object_handle(const void *ptr, const detail::type_info *type ) {
    auto &instances = get_internals().registered_instances;
    auto range = instances.equal_range(ptr);
    for (auto it = range.first; it != range.second; ++it) {
539
540
541
542
        for (auto vh : values_and_holders(it->second)) {
            if (vh.type == type)
                return handle((PyObject *) it->second);
        }
543
544
    }
    return handle();
Wenzel Jakob's avatar
Wenzel Jakob committed
545
546
}

547
inline PyThreadState *get_thread_state_unchecked() {
Wenzel Jakob's avatar
Wenzel Jakob committed
548
549
550
#if defined(PYPY_VERSION)
    return PyThreadState_GET();
#elif PY_VERSION_HEX < 0x03000000
551
552
553
554
555
556
557
558
559
560
    return _PyThreadState_Current;
#elif PY_VERSION_HEX < 0x03050000
    return (PyThreadState*) _Py_atomic_load_relaxed(&_PyThreadState_Current);
#elif PY_VERSION_HEX < 0x03050200
    return (PyThreadState*) _PyThreadState_Current.value;
#else
    return _PyThreadState_UncheckedGet();
#endif
}

561
// Forward declarations
562
inline void keep_alive_impl(handle nurse, handle patient);
563
inline PyObject *make_new_instance(PyTypeObject *type);
564

Wenzel Jakob's avatar
Wenzel Jakob committed
565
566
567
class type_caster_generic {
public:
    PYBIND11_NOINLINE type_caster_generic(const std::type_info &type_info)
568
     : typeinfo(get_type_info(type_info)) { }
Wenzel Jakob's avatar
Wenzel Jakob committed
569

570
571
    bool load(handle src, bool convert) {
        return load_impl<type_caster_generic>(src, convert);
Wenzel Jakob's avatar
Wenzel Jakob committed
572
573
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
574
    PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent,
575
                                         const detail::type_info *tinfo,
Wenzel Jakob's avatar
Wenzel Jakob committed
576
                                         void *(*copy_constructor)(const void *),
Wenzel Jakob's avatar
Wenzel Jakob committed
577
                                         void *(*move_constructor)(const void *),
Wenzel Jakob's avatar
Wenzel Jakob committed
578
                                         const void *existing_holder = nullptr) {
579
        if (!tinfo) // no type info: error will be set already
Wenzel Jakob's avatar
Wenzel Jakob committed
580
581
            return handle();

582
583
584
        void *src = const_cast<void *>(_src);
        if (src == nullptr)
            return none().release();
585

586
        auto it_instances = get_internals().registered_instances.equal_range(src);
Jason Rhinelander's avatar
Jason Rhinelander committed
587
        for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
588
589
590
591
            for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
                if (instance_type && instance_type == tinfo)
                    return handle((PyObject *) it_i->second).inc_ref();
            }
592
593
        }

594
        auto inst = reinterpret_steal<object>(make_new_instance(tinfo->type));
595
        auto wrapper = reinterpret_cast<instance *>(inst.ptr());
596
        wrapper->owned = false;
597
        void *&valueptr = values_and_holders(wrapper).begin()->value_ptr();
598
599

        switch (policy) {
Wenzel Jakob's avatar
Wenzel Jakob committed
600
601
            case return_value_policy::automatic:
            case return_value_policy::take_ownership:
602
                valueptr = src;
Wenzel Jakob's avatar
Wenzel Jakob committed
603
604
605
606
607
                wrapper->owned = true;
                break;

            case return_value_policy::automatic_reference:
            case return_value_policy::reference:
608
                valueptr = src;
Wenzel Jakob's avatar
Wenzel Jakob committed
609
610
611
612
613
                wrapper->owned = false;
                break;

            case return_value_policy::copy:
                if (copy_constructor)
614
                    valueptr = copy_constructor(src);
Wenzel Jakob's avatar
Wenzel Jakob committed
615
616
617
618
619
620
621
622
                else
                    throw cast_error("return_value_policy = copy, but the "
                                     "object is non-copyable!");
                wrapper->owned = true;
                break;

            case return_value_policy::move:
                if (move_constructor)
623
                    valueptr = move_constructor(src);
Wenzel Jakob's avatar
Wenzel Jakob committed
624
                else if (copy_constructor)
625
                    valueptr = copy_constructor(src);
Wenzel Jakob's avatar
Wenzel Jakob committed
626
627
628
629
630
631
632
                else
                    throw cast_error("return_value_policy = move, but the "
                                     "object is neither movable nor copyable!");
                wrapper->owned = true;
                break;

            case return_value_policy::reference_internal:
633
                valueptr = src;
Wenzel Jakob's avatar
Wenzel Jakob committed
634
                wrapper->owned = false;
635
                keep_alive_impl(inst, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
636
637
638
639
                break;

            default:
                throw cast_error("unhandled return_value_policy: should not happen!");
Wenzel Jakob's avatar
Wenzel Jakob committed
640
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
641

642
        tinfo->init_instance(wrapper, existing_holder);
643

Wenzel Jakob's avatar
Wenzel Jakob committed
644
        return inst.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
645
646
647
    }

protected:
648

649
    // Base methods for generic caster; there are overridden in copyable_holder_caster
650
651
652
653
654
655
656
657
    void load_value(value_and_holder &&v_h) {
        auto *&vptr = v_h.value_ptr();
        // Lazy allocation for unallocated values:
        if (vptr == nullptr) {
            auto *type = v_h.type ? v_h.type : typeinfo;
            vptr = type->operator_new(type->type_size);
        }
        value = vptr;
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
    }
    bool try_implicit_casts(handle src, bool convert) {
        for (auto &cast : typeinfo->implicit_casts) {
            type_caster_generic sub_caster(*cast.first);
            if (sub_caster.load(src, convert)) {
                value = cast.second(sub_caster.value);
                return true;
            }
        }
        return false;
    }
    bool try_direct_conversions(handle src) {
        for (auto &converter : *typeinfo->direct_conversions) {
            if (converter(src.ptr(), value))
                return true;
        }
        return false;
    }
    void check_holder_compat() {}

    // Implementation of `load`; this takes the type of `this` so that it can dispatch the relevant
    // bits of code between here and copyable_holder_caster where the two classes need different
    // logic (without having to resort to virtual inheritance).
    template <typename ThisT>
    PYBIND11_NOINLINE bool load_impl(handle src, bool convert) {
        if (!src || !typeinfo)
            return false;
        if (src.is_none()) {
            // Defer accepting None to other overloads (if we aren't in convert mode):
            if (!convert) return false;
            value = nullptr;
            return true;
        }

        auto &this_ = static_cast<ThisT &>(*this);
        this_.check_holder_compat();

        PyTypeObject *srctype = Py_TYPE(src.ptr());

        // Case 1: If src is an exact type match for the target type then we can reinterpret_cast
        // the instance's value pointer to the target type:
        if (srctype == typeinfo->type) {
            this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
            return true;
        }
        // Case 2: We have a derived class
        else if (PyType_IsSubtype(srctype, typeinfo->type)) {
            auto &bases = all_type_info(srctype);
            bool no_cpp_mi = typeinfo->simple_type;

            // Case 2a: the python type is a Python-inherited derived class that inherits from just
            // one simple (no MI) pybind11 class, or is an exact match, so the C++ instance is of
            // the right type and we can use reinterpret_cast.
            // (This is essentially the same as case 2b, but because not using multiple inheritance
            // is extremely common, we handle it specially to avoid the loop iterator and type
            // pointer lookup overhead)
            if (bases.size() == 1 && (no_cpp_mi || bases.front()->type == typeinfo->type)) {
                this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder());
                return true;
            }
            // Case 2b: the python type inherits from multiple C++ bases.  Check the bases to see if
            // we can find an exact match (or, for a simple C++ type, an inherited match); if so, we
            // can safely reinterpret_cast to the relevant pointer.
            else if (bases.size() > 1) {
                for (auto base : bases) {
                    if (no_cpp_mi ? PyType_IsSubtype(base->type, typeinfo->type) : base->type == typeinfo->type) {
                        this_.load_value(reinterpret_cast<instance *>(src.ptr())->get_value_and_holder(base));
                        return true;
                    }
                }
            }

            // Case 2c: C++ multiple inheritance is involved and we couldn't find an exact type match
            // in the registered bases, above, so try implicit casting (needed for proper C++ casting
            // when MI is involved).
            if (this_.try_implicit_casts(src, convert))
                return true;
        }

        // Perform an implicit conversion
        if (convert) {
            for (auto &converter : typeinfo->implicit_conversions) {
740
741
742
                auto temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
                if (load_impl<ThisT>(temp, false)) {
                    loader_life_support::add_patient(temp);
743
                    return true;
744
                }
745
746
747
748
749
750
751
752
            }
            if (this_.try_direct_conversions(src))
                return true;
        }
        return false;
    }


753
754
755
756
    // Called to do type lookup and wrap the pointer and type in a pair when a dynamic_cast
    // isn't needed or can't be used.  If the type is unknown, sets the error and returns a pair
    // with .second = nullptr.  (p.first = nullptr is not an error: it becomes None).
    PYBIND11_NOINLINE static std::pair<const void *, const type_info *> src_and_type(
757
            const void *src, const std::type_info &cast_type, const std::type_info *rtti_type = nullptr) {
758
759
        if (auto *tpi = get_type_info(cast_type))
            return {src, const_cast<const type_info *>(tpi)};
760
761

        // Not found, set error:
762
        std::string tname = rtti_type ? rtti_type->name() : cast_type.name();
763
764
765
766
767
768
        detail::clean_type_id(tname);
        std::string msg = "Unregistered type : " + tname;
        PyErr_SetString(PyExc_TypeError, msg.c_str());
        return {nullptr, nullptr};
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
769
    const type_info *typeinfo = nullptr;
770
    void *value = nullptr;
Wenzel Jakob's avatar
Wenzel Jakob committed
771
772
};

773
774
775
776
777
778
779
/**
 * Determine suitable casting operator for pointer-or-lvalue-casting type casters.  The type caster
 * needs to provide `operator T*()` and `operator T&()` operators.
 *
 * If the type supports moving the value away via an `operator T&&() &&` method, it should use
 * `movable_cast_op_type` instead.
 */
780
template <typename T>
781
using cast_op_type =
782
    conditional_t<std::is_pointer<remove_reference_t<T>>::value,
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
        typename std::add_pointer<intrinsic_t<T>>::type,
        typename std::add_lvalue_reference<intrinsic_t<T>>::type>;

/**
 * Determine suitable casting operator for a type caster with a movable value.  Such a type caster
 * needs to provide `operator T*()`, `operator T&()`, and `operator T&&() &&`.  The latter will be
 * called in appropriate contexts where the value can be moved rather than copied.
 *
 * These operator are automatically provided when using the PYBIND11_TYPE_CASTER macro.
 */
template <typename T>
using movable_cast_op_type =
    conditional_t<std::is_pointer<typename std::remove_reference<T>::type>::value,
        typename std::add_pointer<intrinsic_t<T>>::type,
    conditional_t<std::is_rvalue_reference<T>::value,
        typename std::add_rvalue_reference<intrinsic_t<T>>::type,
        typename std::add_lvalue_reference<intrinsic_t<T>>::type>>;
800

801
802
803
804
805
806
807
// std::is_copy_constructible isn't quite enough: it lets std::vector<T> (and similar) through when
// T is non-copyable, but code containing such a copy constructor fails to actually compile.
template <typename T, typename SFINAE = void> struct is_copy_constructible : std::is_copy_constructible<T> {};

// Specialization for types that appear to be copy constructible but also look like stl containers
// (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if
// so, copy constructability depends on whether the value_type is copy constructible.
808
809
810
811
812
813
814
815
816
817
818
template <typename Container> struct is_copy_constructible<Container, enable_if_t<all_of<
        std::is_copy_constructible<Container>,
        std::is_same<typename Container::value_type &, typename Container::reference>
    >::value>> : is_copy_constructible<typename Container::value_type> {};

#if !defined(PYBIND11_CPP17)
// Likewise for std::pair before C++17 (which mandates that the copy constructor not exist when the
// two types aren't themselves copy constructible).
template <typename T1, typename T2> struct is_copy_constructible<std::pair<T1, T2>>
    : all_of<is_copy_constructible<T1>, is_copy_constructible<T2>> {};
#endif
819

820
/// Generic type caster for objects stored on the heap
Wenzel Jakob's avatar
Wenzel Jakob committed
821
template <typename type> class type_caster_base : public type_caster_generic {
822
    using itype = intrinsic_t<type>;
823
public:
824
    static PYBIND11_DESCR name() { return type_descr(_<type>()); }
825

Wenzel Jakob's avatar
Wenzel Jakob committed
826
    type_caster_base() : type_caster_base(typeid(type)) { }
827
    explicit type_caster_base(const std::type_info &info) : type_caster_generic(info) { }
828

829
    static handle cast(const itype &src, return_value_policy policy, handle parent) {
830
        if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
831
            policy = return_value_policy::copy;
832
        return cast(&src, policy, parent);
833
834
    }

835
836
    static handle cast(itype &&src, return_value_policy, handle parent) {
        return cast(&src, return_value_policy::move, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
837
838
    }

839
840
841
842
843
    // Returns a (pointer, type_info) pair taking care of necessary RTTI type lookup for a
    // polymorphic type.  If the instance isn't derived, returns the non-RTTI base version.
    template <typename T = itype, enable_if_t<std::is_polymorphic<T>::value, int> = 0>
    static std::pair<const void *, const type_info *> src_and_type(const itype *src) {
        const void *vsrc = src;
844
        auto &cast_type = typeid(itype);
845
846
847
        const std::type_info *instance_type = nullptr;
        if (vsrc) {
            instance_type = &typeid(*src);
848
            if (!same_type(cast_type, *instance_type)) {
849
850
851
                // This is a base pointer to a derived type; if it is a pybind11-registered type, we
                // can get the correct derived pointer (which may be != base pointer) by a
                // dynamic_cast to most derived type:
852
853
                if (auto *tpi = get_type_info(*instance_type))
                    return {dynamic_cast<const void *>(src), const_cast<const type_info *>(tpi)};
854
855
856
857
858
859
860
861
862
863
            }
        }
        // Otherwise we have either a nullptr, an `itype` pointer, or an unknown derived pointer, so
        // don't do a cast
        return type_caster_generic::src_and_type(vsrc, cast_type, instance_type);
    }

    // Non-polymorphic type, so no dynamic casting; just call the generic version directly
    template <typename T = itype, enable_if_t<!std::is_polymorphic<T>::value, int> = 0>
    static std::pair<const void *, const type_info *> src_and_type(const itype *src) {
864
        return type_caster_generic::src_and_type(src, typeid(itype));
865
866
    }

867
    static handle cast(const itype *src, return_value_policy policy, handle parent) {
868
        auto st = src_and_type(src);
Wenzel Jakob's avatar
Wenzel Jakob committed
869
        return type_caster_generic::cast(
870
            st.first, policy, parent, st.second,
871
            make_copy_constructor(src), make_move_constructor(src));
872
873
    }

874
    static handle cast_holder(const itype *src, const void *holder) {
875
        auto st = src_and_type(src);
876
        return type_caster_generic::cast(
877
            st.first, return_value_policy::take_ownership, {}, st.second,
878
879
880
            nullptr, nullptr, holder);
    }

881
    template <typename T> using cast_op_type = cast_op_type<T>;
882

883
884
    operator itype*() { return (type *) value; }
    operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); }
885

886
protected:
887
888
    using Constructor = void *(*)(const void *);

889
    /* Only enabled when the types are {copy,move}-constructible *and* when the type
890
891
892
893
894
895
896
897
898
       does not have a private operator new implementation. */
    template <typename T, typename = enable_if_t<is_copy_constructible<T>::value>>
    static auto make_copy_constructor(const T *x) -> decltype(new T(*x), Constructor{}) {
        return [](const void *arg) -> void * {
            return new T(*reinterpret_cast<const T *>(arg));
        };
    }

    template <typename T, typename = enable_if_t<std::is_move_constructible<T>::value>>
899
    static auto make_move_constructor(const T *x) -> decltype(new T(std::move(*const_cast<T *>(x))), Constructor{}) {
900
901
902
903
        return [](const void *arg) -> void * {
            return new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg))));
        };
    }
904

905
906
    static Constructor make_copy_constructor(...) { return nullptr; }
    static Constructor make_move_constructor(...) { return nullptr; }
907
908
};

Wenzel Jakob's avatar
Wenzel Jakob committed
909
template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
910
template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
Wenzel Jakob's avatar
Wenzel Jakob committed
911

912
// Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T
913
template <typename T> typename make_caster<T>::template cast_op_type<T> cast_op(make_caster<T> &caster) {
914
915
    return caster.operator typename make_caster<T>::template cast_op_type<T>();
}
916
917
918
919
template <typename T> typename make_caster<T>::template cast_op_type<typename std::add_rvalue_reference<T>::type>
cast_op(make_caster<T> &&caster) {
    return std::move(caster).operator
        typename make_caster<T>::template cast_op_type<typename std::add_rvalue_reference<T>::type>();
920
921
}

922
923
924
925
926
927
928
template <typename type> class type_caster<std::reference_wrapper<type>> {
private:
    using caster_t = make_caster<type>;
    caster_t subcaster;
    using subcaster_cast_op_type = typename caster_t::template cast_op_type<type>;
    static_assert(std::is_same<typename std::remove_const<type>::type &, subcaster_cast_op_type>::value,
            "std::reference_wrapper<T> caster requires T to have a caster with an `T &` operator");
929
public:
930
931
    bool load(handle src, bool convert) { return subcaster.load(src, convert); }
    static PYBIND11_DESCR name() { return caster_t::name(); }
932
    static handle cast(const std::reference_wrapper<type> &src, return_value_policy policy, handle parent) {
933
934
935
936
        // It is definitely wrong to take ownership of this pointer, so mask that rvp
        if (policy == return_value_policy::take_ownership || policy == return_value_policy::automatic)
            policy = return_value_policy::automatic_reference;
        return caster_t::cast(&src.get(), policy, parent);
937
    }
938
    template <typename T> using cast_op_type = std::reference_wrapper<type>;
939
    operator std::reference_wrapper<type>() { return subcaster.operator subcaster_cast_op_type&(); }
940
941
};

942
#define PYBIND11_TYPE_CASTER(type, py_name) \
Wenzel Jakob's avatar
Wenzel Jakob committed
943
944
945
    protected: \
        type value; \
    public: \
946
        static PYBIND11_DESCR name() { return type_descr(py_name); } \
947
948
        template <typename T_, enable_if_t<std::is_same<type, remove_cv_t<T_>>::value, int> = 0> \
        static handle cast(T_ *src, return_value_policy policy, handle parent) { \
949
            if (!src) return none().release(); \
950
951
952
953
954
            if (policy == return_value_policy::take_ownership) { \
                auto h = cast(std::move(*src), policy, parent); delete src; return h; \
            } else { \
                return cast(*src, policy, parent); \
            } \
Wenzel Jakob's avatar
Wenzel Jakob committed
955
956
        } \
        operator type*() { return &value; } \
957
        operator type&() { return value; } \
958
        operator type&&() && { return std::move(value); } \
959
        template <typename T_> using cast_op_type = pybind11::detail::movable_cast_op_type<T_>
Wenzel Jakob's avatar
Wenzel Jakob committed
960

961

962
963
964
965
966
967
968
template <typename CharT> using is_std_char_type = any_of<
    std::is_same<CharT, char>, /* std::string */
    std::is_same<CharT, char16_t>, /* std::u16string */
    std::is_same<CharT, char32_t>, /* std::u32string */
    std::is_same<CharT, wchar_t> /* std::wstring */
>;

Wenzel Jakob's avatar
Wenzel Jakob committed
969
template <typename T>
970
struct type_caster<T, enable_if_t<std::is_arithmetic<T>::value && !is_std_char_type<T>::value>> {
971
972
973
    using _py_type_0 = conditional_t<sizeof(T) <= sizeof(long), long, long long>;
    using _py_type_1 = conditional_t<std::is_signed<T>::value, _py_type_0, typename std::make_unsigned<_py_type_0>::type>;
    using py_type = conditional_t<std::is_floating_point<T>::value, double, _py_type_1>;
Wenzel Jakob's avatar
Wenzel Jakob committed
974
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
975

976
    bool load(handle src, bool convert) {
Wenzel Jakob's avatar
Wenzel Jakob committed
977
        py_type py_value;
Wenzel Jakob's avatar
Wenzel Jakob committed
978

979
        if (!src)
980
            return false;
981
982
983
984
985
986

        if (std::is_floating_point<T>::value) {
            if (convert || PyFloat_Check(src.ptr()))
                py_value = (py_type) PyFloat_AsDouble(src.ptr());
            else
                return false;
987
988
989
990
991
992
993
994
        } else if (PyFloat_Check(src.ptr())) {
            return false;
        } else if (std::is_unsigned<py_type>::value) {
            py_value = as_unsigned<py_type>(src.ptr());
        } else { // signed integer:
            py_value = sizeof(T) <= sizeof(long)
                ? (py_type) PyLong_AsLong(src.ptr())
                : (py_type) PYBIND11_LONG_AS_LONGLONG(src.ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
995
996
        }

997
998
999
1000
1001
        bool py_err = py_value == (py_type) -1 && PyErr_Occurred();
        if (py_err || (std::is_integral<T>::value && sizeof(py_type) != sizeof(T) &&
                       (py_value < (py_type) std::numeric_limits<T>::min() ||
                        py_value > (py_type) std::numeric_limits<T>::max()))) {
            bool type_error = py_err && PyErr_ExceptionMatches(
1002
#if PY_VERSION_HEX < 0x03000000 && !defined(PYPY_VERSION)
1003
                PyExc_SystemError
1004
#else
1005
                PyExc_TypeError
1006
#endif
1007
            );
Wenzel Jakob's avatar
Wenzel Jakob committed
1008
            PyErr_Clear();
1009
            if (type_error && convert && PyNumber_Check(src.ptr())) {
1010
1011
1012
                auto tmp = reinterpret_borrow<object>(std::is_floating_point<T>::value
                                                      ? PyNumber_Float(src.ptr())
                                                      : PyNumber_Long(src.ptr()));
1013
1014
1015
                PyErr_Clear();
                return load(tmp, false);
            }
Wenzel Jakob's avatar
Wenzel Jakob committed
1016
1017
            return false;
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
1018

Wenzel Jakob's avatar
Wenzel Jakob committed
1019
1020
1021
1022
        value = (T) py_value;
        return true;
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
1023
    static handle cast(T src, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
        if (std::is_floating_point<T>::value) {
            return PyFloat_FromDouble((double) src);
        } else if (sizeof(T) <= sizeof(long)) {
            if (std::is_signed<T>::value)
                return PyLong_FromLong((long) src);
            else
                return PyLong_FromUnsignedLong((unsigned long) src);
        } else {
            if (std::is_signed<T>::value)
                return PyLong_FromLongLong((long long) src);
            else
                return PyLong_FromUnsignedLongLong((unsigned long long) src);
        }
    }

1039
    PYBIND11_TYPE_CASTER(T, _<std::is_integral<T>::value>("int", "float"));
Wenzel Jakob's avatar
Wenzel Jakob committed
1040
};
Wenzel Jakob's avatar
Wenzel Jakob committed
1041

1042
template<typename T> struct void_caster {
Wenzel Jakob's avatar
Wenzel Jakob committed
1043
public:
1044
1045
1046
1047
1048
    bool load(handle src, bool) {
        if (src && src.is_none())
            return true;
        return false;
    }
1049
    static handle cast(T, return_value_policy /* policy */, handle /* parent */) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1050
        return none().inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
1051
    }
1052
    PYBIND11_TYPE_CASTER(T, _("None"));
Wenzel Jakob's avatar
Wenzel Jakob committed
1053
1054
};

1055
1056
template <> class type_caster<void_type> : public void_caster<void_type> {};

1057
1058
1059
1060
1061
template <> class type_caster<void> : public type_caster<void_type> {
public:
    using type_caster<void_type>::cast;

    bool load(handle h, bool) {
1062
1063
        if (!h) {
            return false;
1064
        } else if (h.is_none()) {
1065
1066
1067
            value = nullptr;
            return true;
        }
1068
1069

        /* Check if this is a capsule */
1070
        if (isinstance<capsule>(h)) {
1071
            value = reinterpret_borrow<capsule>(h);
1072
1073
1074
1075
            return true;
        }

        /* Check if this is a C++ type */
1076
1077
1078
        auto &bases = all_type_info((PyTypeObject *) h.get_type().ptr());
        if (bases.size() == 1) { // Only allowing loading from a single-value type
            value = values_and_holders(reinterpret_cast<instance *>(h.ptr())).begin()->value_ptr();
1079
1080
1081
1082
1083
            return true;
        }

        /* Fail */
        return false;
1084
1085
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
1086
    static handle cast(const void *ptr, return_value_policy /* policy */, handle /* parent */) {
1087
1088
1089
        if (ptr)
            return capsule(ptr).release();
        else
Wenzel Jakob's avatar
Wenzel Jakob committed
1090
            return none().inc_ref();
1091
    }
1092

1093
1094
    template <typename T> using cast_op_type = void*&;
    operator void *&() { return value; }
1095
    static PYBIND11_DESCR name() { return type_descr(_("capsule")); }
1096
private:
1097
    void *value = nullptr;
1098
1099
};

1100
template <> class type_caster<std::nullptr_t> : public void_caster<std::nullptr_t> { };
1101

Wenzel Jakob's avatar
Wenzel Jakob committed
1102
1103
template <> class type_caster<bool> {
public:
1104
    bool load(handle src, bool convert) {
1105
1106
        if (!src) return false;
        else if (src.ptr() == Py_True) { value = true; return true; }
Wenzel Jakob's avatar
Wenzel Jakob committed
1107
        else if (src.ptr() == Py_False) { value = false; return true; }
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
        else if (convert || !strcmp("numpy.bool_", Py_TYPE(src.ptr())->tp_name)) {
            // (allow non-implicit conversion for numpy booleans)

            Py_ssize_t res = -1;
            if (src.is_none()) {
                res = 0;  // None is implicitly converted to False
            }
            #if defined(PYPY_VERSION)
            // On PyPy, check that "__bool__" (or "__nonzero__" on Python 2.7) attr exists
            else if (hasattr(src, PYBIND11_BOOL_ATTR)) {
                res = PyObject_IsTrue(src.ptr());
            }
            #else
            // Alternate approach for CPython: this does the same as the above, but optimized
            // using the CPython API so as to avoid an unneeded attribute lookup.
            else if (auto tp_as_number = src.ptr()->ob_type->tp_as_number) {
                if (PYBIND11_NB_BOOL(tp_as_number)) {
                    res = (*PYBIND11_NB_BOOL(tp_as_number))(src.ptr());
                }
            }
            #endif
            if (res == 0 || res == 1) {
                value = (bool) res;
                return true;
            }
        }
        return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
1135
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1136
1137
    static handle cast(bool src, return_value_policy /* policy */, handle /* parent */) {
        return handle(src ? Py_True : Py_False).inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
1138
    }
1139
    PYBIND11_TYPE_CASTER(bool, _("bool"));
Wenzel Jakob's avatar
Wenzel Jakob committed
1140
1141
};

1142
// Helper class for UTF-{8,16,32} C++ stl strings:
1143
1144
1145
template <typename StringType, bool IsView = false> struct string_caster {
    using CharT = typename StringType::value_type;

1146
    // Simplify life by being able to assume standard char sizes (the standard only guarantees
1147
    // minimums, but Python requires exact sizes)
1148
1149
1150
1151
1152
1153
1154
1155
    static_assert(!std::is_same<CharT, char>::value || sizeof(CharT) == 1, "Unsupported char size != 1");
    static_assert(!std::is_same<CharT, char16_t>::value || sizeof(CharT) == 2, "Unsupported char16_t size != 2");
    static_assert(!std::is_same<CharT, char32_t>::value || sizeof(CharT) == 4, "Unsupported char32_t size != 4");
    // wchar_t can be either 16 bits (Windows) or 32 (everywhere else)
    static_assert(!std::is_same<CharT, wchar_t>::value || sizeof(CharT) == 2 || sizeof(CharT) == 4,
            "Unsupported wchar_t size != 2/4");
    static constexpr size_t UTF_N = 8 * sizeof(CharT);

Wenzel Jakob's avatar
Wenzel Jakob committed
1156
    bool load(handle src, bool) {
eirrgang's avatar
eirrgang committed
1157
#if PY_MAJOR_VERSION < 3
Wenzel Jakob's avatar
Wenzel Jakob committed
1158
        object temp;
1159
#endif
Wenzel Jakob's avatar
Wenzel Jakob committed
1160
        handle load_src = src;
1161
1162
1163
        if (!src) {
            return false;
        } else if (!PyUnicode_Check(load_src.ptr())) {
eirrgang's avatar
eirrgang committed
1164
#if PY_MAJOR_VERSION >= 3
1165
            return load_bytes(load_src);
1166
#else
1167
1168
1169
1170
            if (sizeof(CharT) == 1) {
                return load_bytes(load_src);
            }

1171
            // The below is a guaranteed failure in Python 3 when PyUnicode_Check returns false
1172
1173
            if (!PYBIND11_BYTES_CHECK(load_src.ptr()))
                return false;
1174

1175
            temp = reinterpret_steal<object>(PyUnicode_FromObject(load_src.ptr()));
Wenzel Jakob's avatar
Wenzel Jakob committed
1176
1177
            if (!temp) { PyErr_Clear(); return false; }
            load_src = temp;
1178
#endif
1179
1180
1181
        }

        object utfNbytes = reinterpret_steal<object>(PyUnicode_AsEncodedString(
1182
            load_src.ptr(), UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr));
1183
1184
1185
1186
1187
1188
        if (!utfNbytes) { PyErr_Clear(); return false; }

        const CharT *buffer = reinterpret_cast<const CharT *>(PYBIND11_BYTES_AS_STRING(utfNbytes.ptr()));
        size_t length = (size_t) PYBIND11_BYTES_SIZE(utfNbytes.ptr()) / sizeof(CharT);
        if (UTF_N > 8) { buffer++; length--; } // Skip BOM for UTF-16/32
        value = StringType(buffer, length);
1189
1190
1191

        // If we're loading a string_view we need to keep the encoded Python object alive:
        if (IsView)
1192
            loader_life_support::add_patient(utfNbytes);
1193

Wenzel Jakob's avatar
Wenzel Jakob committed
1194
1195
        return true;
    }
hulucc's avatar
hulucc committed
1196

1197
    static handle cast(const StringType &src, return_value_policy /* policy */, handle /* parent */) {
1198
        const char *buffer = reinterpret_cast<const char *>(src.data());
1199
        ssize_t nbytes = ssize_t(src.size() * sizeof(CharT));
1200
        handle s = decode_utfN(buffer, nbytes);
1201
1202
        if (!s) throw error_already_set();
        return s;
Wenzel Jakob's avatar
Wenzel Jakob committed
1203
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1204

1205
    PYBIND11_TYPE_CASTER(StringType, _(PYBIND11_STRING_NAME));
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221

private:
    static handle decode_utfN(const char *buffer, ssize_t nbytes) {
#if !defined(PYPY_VERSION)
        return
            UTF_N == 8  ? PyUnicode_DecodeUTF8(buffer, nbytes, nullptr) :
            UTF_N == 16 ? PyUnicode_DecodeUTF16(buffer, nbytes, nullptr, nullptr) :
                          PyUnicode_DecodeUTF32(buffer, nbytes, nullptr, nullptr);
#else
        // PyPy seems to have multiple problems related to PyUnicode_UTF*: the UTF8 version
        // sometimes segfaults for unknown reasons, while the UTF16 and 32 versions require a
        // non-const char * arguments, which is also a nuissance, so bypass the whole thing by just
        // passing the encoding as a string value, which works properly:
        return PyUnicode_Decode(buffer, nbytes, UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr);
#endif
    }
1222

1223
1224
    // When loading into a std::string or char*, accept a bytes object as-is (i.e.
    // without any encoding/decoding attempt).  For other C++ char sizes this is a no-op.
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
    // which supports loading a unicode from a str, doesn't take this path.
    template <typename C = CharT>
    bool load_bytes(enable_if_t<sizeof(C) == 1, handle> src) {
        if (PYBIND11_BYTES_CHECK(src.ptr())) {
            // We were passed a Python 3 raw bytes; accept it into a std::string or char*
            // without any encoding attempt.
            const char *bytes = PYBIND11_BYTES_AS_STRING(src.ptr());
            if (bytes) {
                value = StringType(bytes, (size_t) PYBIND11_BYTES_SIZE(src.ptr()));
                return true;
            }
        }

        return false;
    }
1240

1241
1242
    template <typename C = CharT>
    bool load_bytes(enable_if_t<sizeof(C) != 1, handle>) { return false; }
hulucc's avatar
hulucc committed
1243
1244
};

1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
template <typename CharT, class Traits, class Allocator>
struct type_caster<std::basic_string<CharT, Traits, Allocator>, enable_if_t<is_std_char_type<CharT>::value>>
    : string_caster<std::basic_string<CharT, Traits, Allocator>> {};

#ifdef PYBIND11_HAS_STRING_VIEW
template <typename CharT, class Traits>
struct type_caster<std::basic_string_view<CharT, Traits>, enable_if_t<is_std_char_type<CharT>::value>>
    : string_caster<std::basic_string_view<CharT, Traits>, true> {};
#endif

1255
1256
1257
1258
1259
1260
1261
// Type caster for C-style strings.  We basically use a std::string type caster, but also add the
// ability to use None as a nullptr char* (which the string caster doesn't allow).
template <typename CharT> struct type_caster<CharT, enable_if_t<is_std_char_type<CharT>::value>> {
    using StringType = std::basic_string<CharT>;
    using StringCaster = type_caster<StringType>;
    StringCaster str_caster;
    bool none = false;
Wenzel Jakob's avatar
Wenzel Jakob committed
1262
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
1263
    bool load(handle src, bool convert) {
1264
1265
1266
1267
1268
1269
1270
1271
        if (!src) return false;
        if (src.is_none()) {
            // Defer accepting None to other overloads (if we aren't in convert mode):
            if (!convert) return false;
            none = true;
            return true;
        }
        return str_caster.load(src, convert);
1272
1273
    }

1274
1275
1276
    static handle cast(const CharT *src, return_value_policy policy, handle parent) {
        if (src == nullptr) return pybind11::none().inc_ref();
        return StringCaster::cast(StringType(src), policy, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
1277
1278
    }

1279
1280
1281
1282
1283
1284
1285
    static handle cast(CharT src, return_value_policy policy, handle parent) {
        if (std::is_same<char, CharT>::value) {
            handle s = PyUnicode_DecodeLatin1((const char *) &src, 1, nullptr);
            if (!s) throw error_already_set();
            return s;
        }
        return StringCaster::cast(StringType(1, src), policy, parent);
Wenzel Jakob's avatar
Wenzel Jakob committed
1286
1287
    }

1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
    operator CharT*() { return none ? nullptr : const_cast<CharT *>(static_cast<StringType &>(str_caster).c_str()); }
    operator CharT() {
        if (none)
            throw value_error("Cannot convert None to a character");

        auto &value = static_cast<StringType &>(str_caster);
        size_t str_len = value.size();
        if (str_len == 0)
            throw value_error("Cannot convert empty string to a character");

        // If we're in UTF-8 mode, we have two possible failures: one for a unicode character that
        // is too high, and one for multiple unicode characters (caught later), so we need to figure
        // out how long the first encoded character is in bytes to distinguish between these two
        // errors.  We also allow want to allow unicode characters U+0080 through U+00FF, as those
        // can fit into a single char value.
        if (StringCaster::UTF_N == 8 && str_len > 1 && str_len <= 4) {
            unsigned char v0 = static_cast<unsigned char>(value[0]);
            size_t char0_bytes = !(v0 & 0x80) ? 1 : // low bits only: 0-127
                (v0 & 0xE0) == 0xC0 ? 2 : // 0b110xxxxx - start of 2-byte sequence
                (v0 & 0xF0) == 0xE0 ? 3 : // 0b1110xxxx - start of 3-byte sequence
                4; // 0b11110xxx - start of 4-byte sequence

            if (char0_bytes == str_len) {
                // If we have a 128-255 value, we can decode it into a single char:
                if (char0_bytes == 2 && (v0 & 0xFC) == 0xC0) { // 0x110000xx 0x10xxxxxx
                    return static_cast<CharT>(((v0 & 3) << 6) + (static_cast<unsigned char>(value[1]) & 0x3F));
                }
                // Otherwise we have a single character, but it's > U+00FF
                throw value_error("Character code point not in range(0x100)");
            }
        }
Wenzel Jakob's avatar
Wenzel Jakob committed
1319

1320
1321
1322
1323
1324
1325
1326
1327
        // UTF-16 is much easier: we can only have a surrogate pair for values above U+FFFF, thus a
        // surrogate pair with total length 2 instantly indicates a range error (but not a "your
        // string was too long" error).
        else if (StringCaster::UTF_N == 16 && str_len == 2) {
            char16_t v0 = static_cast<char16_t>(value[0]);
            if (v0 >= 0xD800 && v0 < 0xE000)
                throw value_error("Character code point not in range(0x10000)");
        }
1328

1329
1330
        if (str_len != 1)
            throw value_error("Expected a character, but multi-character string found");
hulucc's avatar
hulucc committed
1331

1332
        return value[0];
Wenzel Jakob's avatar
Wenzel Jakob committed
1333
    }
hulucc's avatar
hulucc committed
1334

Wenzel Jakob's avatar
Wenzel Jakob committed
1335
    static PYBIND11_DESCR name() { return type_descr(_(PYBIND11_STRING_NAME)); }
1336
    template <typename _T> using cast_op_type = remove_reference_t<pybind11::detail::cast_op_type<_T>>;
hulucc's avatar
hulucc committed
1337
1338
};

1339
// Base implementation for std::tuple and std::pair
1340
1341
1342
template <template<typename...> class Tuple, typename... Ts> class tuple_caster {
    using type = Tuple<Ts...>;
    static constexpr auto size = sizeof...(Ts);
1343
    using indices = make_index_sequence<size>;
1344
public:
1345

Wenzel Jakob's avatar
Wenzel Jakob committed
1346
    bool load(handle src, bool convert) {
1347
1348
1349
1350
        if (!isinstance<sequence>(src))
            return false;
        const auto seq = reinterpret_borrow<sequence>(src);
        if (seq.size() != size)
1351
            return false;
1352
        return load_impl(seq, convert, indices{});
1353
    }
1354

1355
1356
1357
    template <typename T>
    static handle cast(T &&src, return_value_policy policy, handle parent) {
        return cast_impl(std::forward<T>(src), policy, parent, indices{});
1358
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1359

1360
    static PYBIND11_DESCR name() {
1361
        return type_descr(_("Tuple[") + detail::concat(make_caster<Ts>::name()...) + _("]"));
Wenzel Jakob's avatar
Wenzel Jakob committed
1362
1363
    }

1364
1365
    template <typename T> using cast_op_type = type;

1366
1367
    operator type() & { return implicit_cast(indices{}); }
    operator type() && { return std::move(*this).implicit_cast(indices{}); }
Wenzel Jakob's avatar
Wenzel Jakob committed
1368

Wenzel Jakob's avatar
Wenzel Jakob committed
1369
protected:
1370
    template <size_t... Is>
1371
    type implicit_cast(index_sequence<Is...>) & { return type(cast_op<Ts>(std::get<Is>(subcasters))...); }
1372
    template <size_t... Is>
1373
    type implicit_cast(index_sequence<Is...>) && { return type(cast_op<Ts>(std::move(std::get<Is>(subcasters)))...); }
1374

1375
    static constexpr bool load_impl(const sequence &, bool, index_sequence<>) { return true; }
Wenzel Jakob's avatar
Wenzel Jakob committed
1376

1377
    template <size_t... Is>
1378
    bool load_impl(const sequence &seq, bool convert, index_sequence<Is...>) {
1379
        for (bool r : {std::get<Is>(subcasters).load(seq[Is], convert)...})
Wenzel Jakob's avatar
Wenzel Jakob committed
1380
1381
1382
1383
1384
1385
            if (!r)
                return false;
        return true;
    }

    /* Implementation: Convert a C++ tuple into a Python tuple */
1386
1387
1388
1389
    template <typename T, size_t... Is>
    static handle cast_impl(T &&src, return_value_policy policy, handle parent, index_sequence<Is...>) {
        std::array<object, size> entries{{
            reinterpret_steal<object>(make_caster<Ts>::cast(std::get<Is>(std::forward<T>(src)), policy, parent))...
Wenzel Jakob's avatar
Wenzel Jakob committed
1390
        }};
Wenzel Jakob's avatar
Wenzel Jakob committed
1391
1392
1393
1394
        for (const auto &entry: entries)
            if (!entry)
                return handle();
        tuple result(size);
1395
        int counter = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
1396
1397
1398
        for (auto & entry: entries)
            PyTuple_SET_ITEM(result.ptr(), counter++, entry.release().ptr());
        return result.release();
Wenzel Jakob's avatar
Wenzel Jakob committed
1399
1400
    }

1401
    Tuple<make_caster<Ts>...> subcasters;
Wenzel Jakob's avatar
Wenzel Jakob committed
1402
1403
};

1404
1405
1406
template <typename T1, typename T2> class type_caster<std::pair<T1, T2>>
    : public tuple_caster<std::pair, T1, T2> {};

1407
1408
template <typename... Ts> class type_caster<std::tuple<Ts...>>
    : public tuple_caster<std::tuple, Ts...> {};
1409

1410
1411
1412
1413
1414
1415
1416
/// Helper class which abstracts away certain actions. Users can provide specializations for
/// custom holders, but it's only necessary if the type has a non-standard interface.
template <typename T>
struct holder_helper {
    static auto get(const T &p) -> decltype(p.get()) { return p.get(); }
};

Wenzel Jakob's avatar
Wenzel Jakob committed
1417
/// Type caster for holder types like std::shared_ptr, etc.
1418
1419
template <typename type, typename holder_type>
struct copyable_holder_caster : public type_caster_base<type> {
Wenzel Jakob's avatar
Wenzel Jakob committed
1420
public:
Wenzel Jakob's avatar
Wenzel Jakob committed
1421
    using base = type_caster_base<type>;
1422
1423
    static_assert(std::is_base_of<base, type_caster<type>>::value,
            "Holder classes are only supported for custom types");
Wenzel Jakob's avatar
Wenzel Jakob committed
1424
1425
1426
1427
    using base::base;
    using base::cast;
    using base::typeinfo;
    using base::value;
1428

1429
1430
    bool load(handle src, bool convert) {
        return base::template load_impl<copyable_holder_caster<type, holder_type>>(src, convert);
Wenzel Jakob's avatar
Wenzel Jakob committed
1431
1432
    }

1433
1434
1435
    explicit operator type*() { return this->value; }
    explicit operator type&() { return *(this->value); }
    explicit operator holder_type*() { return &holder; }
Wenzel Jakob's avatar
Wenzel Jakob committed
1436

1437
1438
1439
1440
1441
1442
1443
    // Workaround for Intel compiler bug
    // see pybind11 issue 94
    #if defined(__ICC) || defined(__INTEL_COMPILER)
    operator holder_type&() { return holder; }
    #else
    explicit operator holder_type&() { return holder; }
    #endif
Wenzel Jakob's avatar
Wenzel Jakob committed
1444

1445
1446
1447
1448
    static handle cast(const holder_type &src, return_value_policy, handle) {
        const auto *ptr = holder_helper<holder_type>::get(src);
        return type_caster_base<type>::cast_holder(ptr, &src);
    }
Wenzel Jakob's avatar
Wenzel Jakob committed
1449

1450
1451
1452
1453
1454
protected:
    friend class type_caster_generic;
    void check_holder_compat() {
        if (typeinfo->default_holder)
            throw cast_error("Unable to load a custom holder type from a default-holder instance");
Wenzel Jakob's avatar
Wenzel Jakob committed
1455
1456
    }

1457
1458
1459
1460
    bool load_value(const value_and_holder &v_h) {
        if (v_h.holder_constructed()) {
            value = v_h.value_ptr();
            holder = v_h.holder<holder_type>();
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
            return true;
        } else {
            throw cast_error("Unable to cast from non-held to held instance (T& to Holder<T>) "
#if defined(NDEBUG)
                             "(compile in debug mode for type information)");
#else
                             "of type '" + type_id<holder_type>() + "''");
#endif
        }
    }

Wenzel Jakob's avatar
Wenzel Jakob committed
1472
1473
1474
1475
1476
1477
    template <typename T = holder_type, detail::enable_if_t<!std::is_constructible<T, const T &, type*>::value, int> = 0>
    bool try_implicit_casts(handle, bool) { return false; }

    template <typename T = holder_type, detail::enable_if_t<std::is_constructible<T, const T &, type*>::value, int> = 0>
    bool try_implicit_casts(handle src, bool convert) {
        for (auto &cast : typeinfo->implicit_casts) {
1478
            copyable_holder_caster sub_caster(*cast.first);
Wenzel Jakob's avatar
Wenzel Jakob committed
1479
1480
1481
1482
1483
1484
            if (sub_caster.load(src, convert)) {
                value = cast.second(sub_caster.value);
                holder = holder_type(sub_caster.holder, (type *) value);
                return true;
            }
        }
1485
        return false;
Wenzel Jakob's avatar
Wenzel Jakob committed
1486
    }
1487

1488
    static bool try_direct_conversions(handle) { return false; }
1489

1490

Wenzel Jakob's avatar
Wenzel Jakob committed
1491
1492
1493
    holder_type holder;
};

1494
1495
/// Specialize for the common std::shared_ptr, so users don't need to
template <typename T>
1496
1497
1498
1499
class type_caster<std::shared_ptr<T>> : public copyable_holder_caster<T, std::shared_ptr<T>> { };

template <typename type, typename holder_type>
struct move_only_holder_caster {
1500
1501
1502
    static_assert(std::is_base_of<type_caster_base<type>, type_caster<type>>::value,
            "Holder classes are only supported for custom types");

1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
    static handle cast(holder_type &&src, return_value_policy, handle) {
        auto *ptr = holder_helper<holder_type>::get(src);
        return type_caster_base<type>::cast_holder(ptr, &src);
    }
    static PYBIND11_DESCR name() { return type_caster_base<type>::name(); }
};

template <typename type, typename deleter>
class type_caster<std::unique_ptr<type, deleter>>
    : public move_only_holder_caster<type, std::unique_ptr<type, deleter>> { };

template <typename type, typename holder_type>
1515
using type_caster_holder = conditional_t<is_copy_constructible<holder_type>::value,
1516
1517
                                         copyable_holder_caster<type, holder_type>,
                                         move_only_holder_caster<type, holder_type>>;
1518

1519
1520
template <typename T, bool Value = false> struct always_construct_holder { static constexpr bool value = Value; };

1521
/// Create a specialization for custom holder types (silently ignores std::shared_ptr)
1522
#define PYBIND11_DECLARE_HOLDER_TYPE(type, holder_type, ...) \
1523
1524
    namespace pybind11 { namespace detail { \
    template <typename type> \
1525
1526
    struct always_construct_holder<holder_type> : always_construct_holder<void, ##__VA_ARGS__>  { }; \
    template <typename type> \
1527
1528
1529
1530
    class type_caster<holder_type, enable_if_t<!is_shared_ptr<holder_type>::value>> \
        : public type_caster_holder<type, holder_type> { }; \
    }}

1531
// PYBIND11_DECLARE_HOLDER_TYPE holder types:
1532
template <typename base, typename holder> struct is_holder_type :
1533
1534
1535
1536
    std::is_base_of<detail::type_caster_holder<base, holder>, detail::type_caster<holder>> {};
// Specialization for always-supported unique_ptr holders:
template <typename base, typename deleter> struct is_holder_type<base, std::unique_ptr<base, deleter>> :
    std::true_type {};
1537

1538
1539
template <typename T> struct handle_type_name { static PYBIND11_DESCR name() { return _<T>(); } };
template <> struct handle_type_name<bytes> { static PYBIND11_DESCR name() { return _(PYBIND11_BYTES_NAME); } };
1540
1541
template <> struct handle_type_name<args> { static PYBIND11_DESCR name() { return _("*args"); } };
template <> struct handle_type_name<kwargs> { static PYBIND11_DESCR name() { return _("**kwargs"); } };
1542

1543
template <typename type>
1544
1545
1546
struct pyobject_caster {
    template <typename T = type, enable_if_t<std::is_same<T, handle>::value, int> = 0>
    bool load(handle src, bool /* convert */) { value = src; return static_cast<bool>(value); }
1547

1548
    template <typename T = type, enable_if_t<std::is_base_of<object, T>::value, int> = 0>
1549
1550
1551
    bool load(handle src, bool /* convert */) {
        if (!isinstance<type>(src))
            return false;
1552
        value = reinterpret_borrow<type>(src);
1553
1554
        return true;
    }
1555

Wenzel Jakob's avatar
Wenzel Jakob committed
1556
1557
    static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
        return src.inc_ref();
Wenzel Jakob's avatar
Wenzel Jakob committed
1558
    }
1559
    PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name());
Wenzel Jakob's avatar
Wenzel Jakob committed
1560
1561
};

1562
1563
1564
template <typename T>
class type_caster<T, enable_if_t<is_pyobject<T>::value>> : public pyobject_caster<T> { };

1565
1566
1567
1568
1569
1570
1571
1572
1573
// Our conditions for enabling moving are quite restrictive:
// At compile time:
// - T needs to be a non-const, non-pointer, non-reference type
// - type_caster<T>::operator T&() must exist
// - the type must be move constructible (obviously)
// At run-time:
// - if the type is non-copy-constructible, the object must be the sole owner of the type (i.e. it
//   must have ref_count() == 1)h
// If any of the above are not satisfied, we fall back to copying.
1574
1575
template <typename T> using move_is_plain_type = satisfies_none_of<T,
    std::is_void, std::is_pointer, std::is_reference, std::is_const
1576
>;
1577
template <typename T, typename SFINAE = void> struct move_always : std::false_type {};
1578
1579
template <typename T> struct move_always<T, enable_if_t<all_of<
    move_is_plain_type<T>,
1580
    negation<is_copy_constructible<T>>,
1581
    std::is_move_constructible<T>,
1582
    std::is_same<decltype(std::declval<make_caster<T>>().operator T&()), T&>
1583
>::value>> : std::true_type {};
1584
template <typename T, typename SFINAE = void> struct move_if_unreferenced : std::false_type {};
1585
1586
1587
1588
template <typename T> struct move_if_unreferenced<T, enable_if_t<all_of<
    move_is_plain_type<T>,
    negation<move_always<T>>,
    std::is_move_constructible<T>,
1589
    std::is_same<decltype(std::declval<make_caster<T>>().operator T&()), T&>
1590
1591
>::value>> : std::true_type {};
template <typename T> using move_never = none_of<move_always<T>, move_if_unreferenced<T>>;
1592

1593
1594
1595
1596
1597
1598
1599
1600
1601
// Detect whether returning a `type` from a cast on type's type_caster is going to result in a
// reference or pointer to a local variable of the type_caster.  Basically, only
// non-reference/pointer `type`s and reference/pointers from a type_caster_generic are safe;
// everything else returns a reference/pointer to a local variable.
template <typename type> using cast_is_temporary_value_reference = bool_constant<
    (std::is_reference<type>::value || std::is_pointer<type>::value) &&
    !std::is_base_of<type_caster_generic, make_caster<type>>::value
>;

1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
// When a value returned from a C++ function is being cast back to Python, we almost always want to
// force `policy = move`, regardless of the return value policy the function/method was declared
// with.  Some classes (most notably Eigen::Ref and related) need to avoid this, and so can do so by
// specializing this struct.
template <typename Return, typename SFINAE = void> struct return_value_policy_override {
    static return_value_policy policy(return_value_policy p) {
        return !std::is_lvalue_reference<Return>::value && !std::is_pointer<Return>::value
            ? return_value_policy::move : p;
    }
};

1613
// Basic python -> C++ casting; throws if casting fails
Jason Rhinelander's avatar
Jason Rhinelander committed
1614
template <typename T, typename SFINAE> type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &handle) {
1615
1616
1617
1618
1619
    if (!conv.load(handle, true)) {
#if defined(NDEBUG)
        throw cast_error("Unable to cast Python instance to C++ type (compile in debug mode for details)");
#else
        throw cast_error("Unable to cast Python instance of type " +
1620
            (std::string) str(handle.get_type()) + " to C++ type '" + type_id<T>() + "''");
1621
1622
#endif
    }
1623
1624
    return conv;
}
1625
1626
1627
1628
1629
1630
// Wrapper around the above that also constructs and returns a type_caster
template <typename T> make_caster<T> load_type(const handle &handle) {
    make_caster<T> conv;
    load_type(conv, handle);
    return conv;
}
1631
1632
1633

NAMESPACE_END(detail)

1634
// pytype -> C++ type
1635
1636
template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
T cast(const handle &handle) {
1637
1638
    using namespace detail;
    static_assert(!cast_is_temporary_value_reference<T>::value,
1639
            "Unable to cast type to reference: value is local to type caster");
1640
    return cast_op<T>(load_type<T>(handle));
Wenzel Jakob's avatar
Wenzel Jakob committed
1641
1642
}

1643
// pytype -> pytype (calls converting constructor)
1644
template <typename T, detail::enable_if_t<detail::is_pyobject<T>::value, int> = 0>
1645
T cast(const handle &handle) { return T(reinterpret_borrow<object>(handle)); }
1646

1647
// C++ type -> py::object
1648
1649
1650
template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
object cast(const T &value, return_value_policy policy = return_value_policy::automatic_reference,
            handle parent = handle()) {
Wenzel Jakob's avatar
Wenzel Jakob committed
1651
1652
    if (policy == return_value_policy::automatic)
        policy = std::is_pointer<T>::value ? return_value_policy::take_ownership : return_value_policy::copy;
1653
1654
    else if (policy == return_value_policy::automatic_reference)
        policy = std::is_pointer<T>::value ? return_value_policy::reference : return_value_policy::copy;
1655
    return reinterpret_steal<object>(detail::make_caster<T>::cast(value, policy, parent));
Wenzel Jakob's avatar
Wenzel Jakob committed
1656
1657
}

Wenzel Jakob's avatar
Wenzel Jakob committed
1658
template <typename T> T handle::cast() const { return pybind11::cast<T>(*this); }
1659
template <> inline void handle::cast() const { return; }
Wenzel Jakob's avatar
Wenzel Jakob committed
1660

1661
template <typename T>
1662
detail::enable_if_t<!detail::move_never<T>::value, T> move(object &&obj) {
1663
1664
1665
1666
1667
    if (obj.ref_count() > 1)
#if defined(NDEBUG)
        throw cast_error("Unable to cast Python instance to C++ rvalue: instance has multiple references"
            " (compile in debug mode for details)");
#else
1668
        throw cast_error("Unable to move from Python " + (std::string) str(obj.get_type()) +
1669
1670
1671
1672
                " instance to C++ " + type_id<T>() + " instance: instance has multiple references");
#endif

    // Move into a temporary and return that, because the reference may be a local value of `conv`
1673
    T ret = std::move(detail::load_type<T>(obj).operator T&());
1674
1675
1676
1677
1678
1679
1680
1681
    return ret;
}

// Calling cast() on an rvalue calls pybind::cast with the object rvalue, which does:
// - If we have to move (because T has no copy constructor), do it.  This will fail if the moved
//   object has multiple references, but trying to copy will fail to compile.
// - If both movable and copyable, check ref count: if 1, move; otherwise copy
// - Otherwise (not movable), copy.
1682
template <typename T> detail::enable_if_t<detail::move_always<T>::value, T> cast(object &&object) {
1683
1684
    return move<T>(std::move(object));
}
1685
template <typename T> detail::enable_if_t<detail::move_if_unreferenced<T>::value, T> cast(object &&object) {
1686
1687
1688
1689
1690
    if (object.ref_count() > 1)
        return cast<T>(object);
    else
        return move<T>(std::move(object));
}
1691
template <typename T> detail::enable_if_t<detail::move_never<T>::value, T> cast(object &&object) {
1692
1693
1694
1695
1696
1697
1698
1699
    return cast<T>(object);
}

template <typename T> T object::cast() const & { return pybind11::cast<T>(*this); }
template <typename T> T object::cast() && { return pybind11::cast<T>(std::move(*this)); }
template <> inline void object::cast() const & { return; }
template <> inline void object::cast() && { return; }

1700
1701
NAMESPACE_BEGIN(detail)

1702
1703
1704
1705
// Declared in pytypes.h:
template <typename T, enable_if_t<!is_pyobject<T>::value, int>>
object object_or_cast(T &&o) { return pybind11::cast(std::forward<T>(o)); }

1706
1707
1708
struct overload_unused {}; // Placeholder type for the unneeded (and dead code) static variable in the OVERLOAD_INT macro
template <typename ret_type> using overload_caster_t = conditional_t<
    cast_is_temporary_value_reference<ret_type>::value, make_caster<ret_type>, overload_unused>;
1709
1710
1711

// Trampoline use: for reference/pointer types to value-converted values, we do a value cast, then
// store the result in the given variable.  For other types, this is a no-op.
1712
template <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&o, make_caster<T> &caster) {
1713
    return cast_op<T>(load_type(caster, o));
1714
}
1715
template <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&, overload_unused &) {
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
    pybind11_fail("Internal error: cast_ref fallback invoked"); }

// Trampoline use: Having a pybind11::cast with an invalid reference type is going to static_assert, even
// though if it's in dead code, so we provide a "trampoline" to pybind11::cast that only does anything in
// cases where pybind11::cast is valid.
template <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_safe(object &&o) {
    return pybind11::cast<T>(std::move(o)); }
template <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_safe(object &&) {
    pybind11_fail("Internal error: cast_safe fallback invoked"); }
template <> inline void cast_safe<void>(object &&) {}

NAMESPACE_END(detail)
1728

1729
template <return_value_policy policy = return_value_policy::automatic_reference,
Wenzel Jakob's avatar
Wenzel Jakob committed
1730
          typename... Args> tuple make_tuple(Args&&... args_) {
1731
    constexpr size_t size = sizeof...(Args);
Wenzel Jakob's avatar
Wenzel Jakob committed
1732
    std::array<object, size> args {
1733
1734
        { reinterpret_steal<object>(detail::make_caster<Args>::cast(
            std::forward<Args>(args_), policy, nullptr))... }
Wenzel Jakob's avatar
Wenzel Jakob committed
1735
    };
1736
1737
    for (size_t i = 0; i < args.size(); i++) {
        if (!args[i]) {
1738
1739
1740
#if defined(NDEBUG)
            throw cast_error("make_tuple(): unable to convert arguments to Python object (compile in debug mode for details)");
#else
Ivan Smirnov's avatar
Ivan Smirnov committed
1741
            std::array<std::string, size> argtypes { {type_id<Args>()...} };
1742
1743
            throw cast_error("make_tuple(): unable to convert argument of type '" +
                argtypes[i] + "' to Python object");
1744
1745
1746
#endif
        }
    }
1747
    tuple result(size);
Wenzel Jakob's avatar
Wenzel Jakob committed
1748
    int counter = 0;
Wenzel Jakob's avatar
Wenzel Jakob committed
1749
    for (auto &arg_value : args)
1750
1751
1752
1753
        PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr());
    return result;
}

1754
/// \ingroup annotations
1755
/// Annotation for arguments
1756
struct arg {
1757
    /// Constructs an argument with the name of the argument; if null or omitted, this is a positional argument.
1758
    constexpr explicit arg(const char *name = nullptr) : name(name), flag_noconvert(false), flag_none(true) { }
1759
    /// Assign a value to this argument
1760
    template <typename T> arg_v operator=(T &&value) const;
1761
1762
    /// Indicate that the type should not be converted in the type caster
    arg &noconvert(bool flag = true) { flag_noconvert = flag; return *this; }
1763
1764
    /// Indicates that the argument should/shouldn't allow None (e.g. for nullable pointer args)
    arg &none(bool flag = true) { flag_none = flag; return *this; }
1765

1766
1767
    const char *name; ///< If non-null, this is a named kwargs argument
    bool flag_noconvert : 1; ///< If set, do not allow conversion (requires a supporting type caster!)
1768
    bool flag_none : 1; ///< If set (the default), allow None to be passed to this argument
1769
1770
};

1771
/// \ingroup annotations
1772
/// Annotation for arguments with values
1773
struct arg_v : arg {
1774
private:
1775
    template <typename T>
1776
1777
    arg_v(arg &&base, T &&x, const char *descr = nullptr)
        : arg(base),
1778
1779
1780
          value(reinterpret_steal<object>(
              detail::make_caster<T>::cast(x, return_value_policy::automatic, {})
          )),
1781
1782
1783
1784
1785
1786
          descr(descr)
#if !defined(NDEBUG)
        , type(type_id<T>())
#endif
    { }

1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
public:
    /// Direct construction with name, default, and description
    template <typename T>
    arg_v(const char *name, T &&x, const char *descr = nullptr)
        : arg_v(arg(name), std::forward<T>(x), descr) { }

    /// Called internally when invoking `py::arg("a") = value`
    template <typename T>
    arg_v(const arg &base, T &&x, const char *descr = nullptr)
        : arg_v(arg(base), std::forward<T>(x), descr) { }

    /// Same as `arg::noconvert()`, but returns *this as arg_v&, not arg&
    arg_v &noconvert(bool flag = true) { arg::noconvert(flag); return *this; }
1800
1801
1802

    /// Same as `arg::nonone()`, but returns *this as arg_v&, not arg&
    arg_v &none(bool flag = true) { arg::none(flag); return *this; }
1803
1804

    /// The default value
1805
    object value;
1806
    /// The (optional) description of the default value
1807
1808
    const char *descr;
#if !defined(NDEBUG)
1809
    /// The C++ type name of the default value (only available when compiled in debug mode)
1810
1811
1812
1813
1814
    std::string type;
#endif
};

template <typename T>
1815
arg_v arg::operator=(T &&value) const { return {std::move(*this), std::forward<T>(value)}; }
1816

Wenzel Jakob's avatar
Wenzel Jakob committed
1817
/// Alias for backward compatibility -- to be removed in version 2.0
1818
1819
1820
template <typename /*unused*/> using arg_t = arg_v;

inline namespace literals {
1821
1822
1823
/** \rst
    String literal version of `arg`
 \endrst */
1824
1825
1826
constexpr arg operator"" _a(const char *name, size_t) { return arg(name); }
}

1827
NAMESPACE_BEGIN(detail)
1828

1829
// forward declaration (definition in attr.h)
1830
1831
struct function_record;

1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
/// Internal data associated with a single function call
struct function_call {
    function_call(function_record &f, handle p); // Implementation in attr.h

    /// The function data:
    const function_record &func;

    /// Arguments passed to the function:
    std::vector<handle> args;

    /// The `convert` value the arguments should be loaded with
    std::vector<bool> args_convert;

    /// The parent, if any
    handle parent;
};


1850
1851
1852
/// Helper class which loads arguments for C++ functions called from Python
template <typename... Args>
class argument_loader {
1853
    using indices = make_index_sequence<sizeof...(Args)>;
1854

1855
1856
1857
1858
1859
1860
1861
1862
1863
    template <typename Arg> using argument_is_args   = std::is_same<intrinsic_t<Arg>, args>;
    template <typename Arg> using argument_is_kwargs = std::is_same<intrinsic_t<Arg>, kwargs>;
    // Get args/kwargs argument positions relative to the end of the argument list:
    static constexpr auto args_pos = constexpr_first<argument_is_args, Args...>() - (int) sizeof...(Args),
                        kwargs_pos = constexpr_first<argument_is_kwargs, Args...>() - (int) sizeof...(Args);

    static constexpr bool args_kwargs_are_last = kwargs_pos >= - 1 && args_pos >= kwargs_pos - 1;

    static_assert(args_kwargs_are_last, "py::args/py::kwargs are only permitted as the last argument(s) of a function");
Jason Rhinelander's avatar
Jason Rhinelander committed
1864

1865
public:
1866
1867
    static constexpr bool has_kwargs = kwargs_pos < 0;
    static constexpr bool has_args = args_pos < 0;
1868
1869
1870

    static PYBIND11_DESCR arg_names() { return detail::concat(make_caster<Args>::name()...); }

1871
1872
    bool load_args(function_call &call) {
        return load_impl_sequence(call, indices{});
1873
1874
    }

Dean Moldovan's avatar
Dean Moldovan committed
1875
    template <typename Return, typename Guard, typename Func>
1876
1877
    enable_if_t<!std::is_void<Return>::value, Return> call(Func &&f) && {
        return std::move(*this).template call_impl<Return>(std::forward<Func>(f), indices{}, Guard{});
1878
1879
    }

Dean Moldovan's avatar
Dean Moldovan committed
1880
    template <typename Return, typename Guard, typename Func>
1881
1882
    enable_if_t<std::is_void<Return>::value, void_type> call(Func &&f) && {
        std::move(*this).template call_impl<Return>(std::forward<Func>(f), indices{}, Guard{});
1883
1884
1885
1886
1887
        return void_type();
    }

private:

1888
    static bool load_impl_sequence(function_call &, index_sequence<>) { return true; }
1889
1890

    template <size_t... Is>
1891
    bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
1892
        for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
1893
1894
1895
1896
1897
            if (!r)
                return false;
        return true;
    }

Dean Moldovan's avatar
Dean Moldovan committed
1898
1899
    template <typename Return, typename Func, size_t... Is, typename Guard>
    Return call_impl(Func &&f, index_sequence<Is...>, Guard &&) {
1900
        return std::forward<Func>(f)(cast_op<Args>(std::move(std::get<Is>(argcasters)))...);
1901
1902
    }

1903
    std::tuple<make_caster<Args>...> argcasters;
1904
1905
};

1906
1907
1908
1909
1910
1911
/// Helper class which collects only positional arguments for a Python function call.
/// A fancier version below can collect any argument, but this one is optimal for simple calls.
template <return_value_policy policy>
class simple_collector {
public:
    template <typename... Ts>
1912
    explicit simple_collector(Ts &&...values)
1913
1914
1915
1916
1917
1918
1919
1920
1921
        : m_args(pybind11::make_tuple<policy>(std::forward<Ts>(values)...)) { }

    const tuple &args() const & { return m_args; }
    dict kwargs() const { return {}; }

    tuple args() && { return std::move(m_args); }

    /// Call a Python function and pass the collected arguments
    object call(PyObject *ptr) const {
1922
        PyObject *result = PyObject_CallObject(ptr, m_args.ptr());
1923
1924
        if (!result)
            throw error_already_set();
1925
        return reinterpret_steal<object>(result);
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
    }

private:
    tuple m_args;
};

/// Helper class which collects positional, keyword, * and ** arguments for a Python function call
template <return_value_policy policy>
class unpacking_collector {
public:
    template <typename... Ts>
1937
    explicit unpacking_collector(Ts &&...values) {
1938
1939
1940
1941
1942
1943
        // Tuples aren't (easily) resizable so a list is needed for collection,
        // but the actual function call strictly requires a tuple.
        auto args_list = list();
        int _[] = { 0, (process(args_list, std::forward<Ts>(values)), 0)... };
        ignore_unused(_);

1944
        m_args = std::move(args_list);
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
    }

    const tuple &args() const & { return m_args; }
    const dict &kwargs() const & { return m_kwargs; }

    tuple args() && { return std::move(m_args); }
    dict kwargs() && { return std::move(m_kwargs); }

    /// Call a Python function and pass the collected arguments
    object call(PyObject *ptr) const {
1955
        PyObject *result = PyObject_Call(ptr, m_args.ptr(), m_kwargs.ptr());
1956
1957
        if (!result)
            throw error_already_set();
1958
        return reinterpret_steal<object>(result);
1959
1960
1961
1962
1963
    }

private:
    template <typename T>
    void process(list &args_list, T &&x) {
1964
        auto o = reinterpret_steal<object>(detail::make_caster<T>::cast(std::forward<T>(x), policy, {}));
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
        if (!o) {
#if defined(NDEBUG)
            argument_cast_error();
#else
            argument_cast_error(std::to_string(args_list.size()), type_id<T>());
#endif
        }
        args_list.append(o);
    }

    void process(list &args_list, detail::args_proxy ap) {
1976
        for (const auto &a : ap)
1977
            args_list.append(a);
1978
1979
    }

1980
    void process(list &/*args_list*/, arg_v a) {
1981
1982
1983
1984
1985
1986
1987
        if (!a.name)
#if defined(NDEBUG)
            nameless_argument_error();
#else
            nameless_argument_error(a.type);
#endif

1988
        if (m_kwargs.contains(a.name)) {
1989
1990
1991
1992
1993
1994
#if defined(NDEBUG)
            multiple_values_error();
#else
            multiple_values_error(a.name);
#endif
        }
1995
        if (!a.value) {
1996
1997
1998
#if defined(NDEBUG)
            argument_cast_error();
#else
1999
            argument_cast_error(a.name, a.type);
2000
2001
#endif
        }
2002
        m_kwargs[a.name] = a.value;
2003
2004
2005
    }

    void process(list &/*args_list*/, detail::kwargs_proxy kp) {
2006
2007
        if (!kp)
            return;
2008
        for (const auto &k : reinterpret_borrow<dict>(kp)) {
2009
            if (m_kwargs.contains(k.first)) {
2010
2011
2012
#if defined(NDEBUG)
                multiple_values_error();
#else
2013
                multiple_values_error(str(k.first));
2014
2015
2016
2017
2018
2019
#endif
            }
            m_kwargs[k.first] = k.second;
        }
    }

2020
2021
2022
2023
2024
2025
2026
2027
2028
    [[noreturn]] static void nameless_argument_error() {
        throw type_error("Got kwargs without a name; only named arguments "
                         "may be passed via py::arg() to a python function call. "
                         "(compile in debug mode for details)");
    }
    [[noreturn]] static void nameless_argument_error(std::string type) {
        throw type_error("Got kwargs without a name of type '" + type + "'; only named "
                         "arguments may be passed via py::arg() to a python function call. ");
    }
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
    [[noreturn]] static void multiple_values_error() {
        throw type_error("Got multiple values for keyword argument "
                         "(compile in debug mode for details)");
    }

    [[noreturn]] static void multiple_values_error(std::string name) {
        throw type_error("Got multiple values for keyword argument '" + name + "'");
    }

    [[noreturn]] static void argument_cast_error() {
        throw cast_error("Unable to convert call argument to Python object "
                         "(compile in debug mode for details)");
    }

    [[noreturn]] static void argument_cast_error(std::string name, std::string type) {
        throw cast_error("Unable to convert call argument '" + name
                         + "' of type '" + type + "' to Python object");
    }

private:
    tuple m_args;
    dict m_kwargs;
};

/// Collect only positional arguments for a Python function call
template <return_value_policy policy, typename... Args,
2055
          typename = enable_if_t<all_of<is_positional<Args>...>::value>>
2056
simple_collector<policy> collect_arguments(Args &&...args) {
2057
    return simple_collector<policy>(std::forward<Args>(args)...);
2058
2059
2060
2061
}

/// Collect all arguments, including keywords and unpacking (only instantiated when needed)
template <return_value_policy policy, typename... Args,
2062
          typename = enable_if_t<!all_of<is_positional<Args>...>::value>>
2063
2064
2065
2066
2067
2068
2069
2070
unpacking_collector<policy> collect_arguments(Args &&...args) {
    // Following argument order rules for generalized unpacking according to PEP 448
    static_assert(
        constexpr_last<is_positional, Args...>() < constexpr_first<is_keyword_or_ds, Args...>()
        && constexpr_last<is_s_unpacking, Args...>() < constexpr_first<is_ds_unpacking, Args...>(),
        "Invalid function call: positional args must precede keywords and ** unpacking; "
        "* unpacking must precede ** unpacking"
    );
2071
    return unpacking_collector<policy>(std::forward<Args>(args)...);
2072
2073
}

2074
template <typename Derived>
2075
template <return_value_policy policy, typename... Args>
2076
2077
object object_api<Derived>::operator()(Args &&...args) const {
    return detail::collect_arguments<policy>(std::forward<Args>(args)...).call(derived().ptr());
Wenzel Jakob's avatar
Wenzel Jakob committed
2078
2079
}

2080
2081
2082
template <typename Derived>
template <return_value_policy policy, typename... Args>
object object_api<Derived>::call(Args &&...args) const {
2083
    return operator()<policy>(std::forward<Args>(args)...);
2084
2085
}

2086
2087
NAMESPACE_END(detail)

Wenzel Jakob's avatar
Wenzel Jakob committed
2088
2089
2090
2091
2092
#define PYBIND11_MAKE_OPAQUE(Type) \
    namespace pybind11 { namespace detail { \
        template<> class type_caster<Type> : public type_caster_base<Type> { }; \
    }}

2093
NAMESPACE_END(PYBIND11_NAMESPACE)