29#if (__cplusplus > 201402L) || (defined(_MSC_VER) && _MSVC_LANG > 201402L)
36#if PY_VERSION_HEX < 0x03000000
37#if defined(__GNUC__) && !defined(__APPLE__)
38# if __GNUC__ > 4 && __has_include("codecvt")
61 static std::regex
s_fnptr(
"\\((\\w*:*)*\\*&*\\)");
66#if PY_VERSION_HEX < 0x030e0000
67#if PY_VERSION_HEX < 0x03000000
69#elif PY_VERSION_HEX < 0x03080000
119#define ct_c_uint32 10
122#define ct_c_longlong 13
123#define ct_c_ulonglong 14
125#define ct_c_double 16
126#define ct_c_longdouble 17
127#define ct_c_char_p 18
128#define ct_c_wchar_p 19
129#define ct_c_void_p 20
130#define ct_c_fcomplex 21
131#define ct_c_complex 22
132#define ct_c_pointer 23
133#define ct_c_funcptr 24
139 "c_bool",
"c_char",
"c_wchar",
"c_byte",
"c_ubyte",
"c_short",
"c_ushort",
"c_uint16",
140 "c_int",
"c_uint",
"c_uint32",
"c_long",
"c_ulong",
"c_longlong",
"c_ulonglong",
141 "c_float",
"c_double",
"c_longdouble",
142 "c_char_p",
"c_wchar_p",
"c_void_p",
"c_fcomplex",
"c_complex",
143 "_Pointer",
"_CFuncPtr" };
217#if PY_VERSION_HEX < 0x30d0000
277 if (!
holder)
return false;
291 if (!
holder)
return false;
382#define CPPYY_PYLONG_AS_TYPE(name, type, limit_low, limit_high) \
383static inline type CPyCppyy_PyLong_As##name(PyObject* pyobject) \
385 if (!(PyLong_Check(pyobject) || PyInt_Check(pyobject))) { \
386 if (pyobject == CPyCppyy::gDefaultObject) \
388 PyErr_SetString(PyExc_TypeError, #type" conversion expects an integer object");\
391 long l = PyLong_AsLong(pyobject); \
392 if (l < limit_low || limit_high < l) { \
393 PyErr_Format(PyExc_ValueError, "integer %ld out of range for "#type, l);\
446 para.fValue.fVoidp =
nullptr;
452 para.fValue.fVoidp =
nullptr;
455 "could not convert argument to buffer or nullptr");
460 para.fTypeCode =
'p';
513 para.fValue.fVoidp =
pytmp->GetObjectRaw();
514 para.fTypeCode =
'V';
547#define CPPYY_IMPL_BASIC_CONVERTER_BODY(name, type, stype, ctype, F1, F2, tc)\
549 type val = (type)F2(pyobject); \
550 if (val == (type)-1 && PyErr_Occurred()) { \
551 static PyTypeObject* ctypes_type = nullptr; \
552 if (!ctypes_type) { \
553 auto error = CPyCppyy::Utility::FetchPyError(); \
554 ctypes_type = GetCTypesType(ct_##ctype); \
555 CPyCppyy::Utility::RestorePyError(error); \
557 if (Py_TYPE(pyobject) == ctypes_type) { \
559 val = *((type*)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr); \
560 } else if (pyobject == CPyCppyy::gDefaultObject) { \
566 para.fValue.f##name = val; \
567 para.fTypeCode = tc; \
570#define CPPYY_IMPL_BASIC_CONVERTER_METHODS(name, type, stype, ctype, F1, F2) \
571PyObject* CPyCppyy::name##Converter::FromMemory(void* address) \
573 return F1((stype)*((type*)address)); \
576bool CPyCppyy::name##Converter::ToMemory( \
577 PyObject* value, void* address, PyObject* ) \
579 type s = (type)F2(value); \
580 if (s == (type)-1 && PyErr_Occurred()) { \
581 if (value == CPyCppyy::gDefaultObject) { \
587 *((type*)address) = (type)s; \
591#define CPPYY_IMPL_BASIC_CONVERTER_NI(name, type, stype, ctype, F1, F2, tc) \
592bool CPyCppyy::name##Converter::SetArg( \
593 PyObject* pyobject, Parameter& para, CallContext* ctxt) \
595 if (!StrictBool(pyobject, ctxt)) \
597 CPPYY_IMPL_BASIC_CONVERTER_BODY(name, type, stype, ctype, F1, F2, tc) \
599CPPYY_IMPL_BASIC_CONVERTER_METHODS(name, type, stype, ctype, F1, F2)
601#define CPPYY_IMPL_BASIC_CONVERTER_IB(name, type, stype, ctype, F1, F2, tc) \
602bool CPyCppyy::name##Converter::SetArg( \
603 PyObject* pyobject, Parameter& para, CallContext* ctxt) \
605 if (!ImplicitBool(pyobject, ctxt)) \
607 CPPYY_IMPL_BASIC_CONVERTER_BODY(name, type, stype, ctype, F1, F2, tc) \
609CPPYY_IMPL_BASIC_CONVERTER_METHODS(name, type, stype, ctype, F1, F2)
611#define CPPYY_IMPL_BASIC_CONVERTER_NB(name, type, stype, ctype, F1, F2, tc) \
612bool CPyCppyy::name##Converter::SetArg( \
613 PyObject* pyobject, Parameter& para, CallContext* ) \
615 if (PyBool_Check(pyobject)) \
617 CPPYY_IMPL_BASIC_CONVERTER_BODY(name, type, stype, ctype, F1, F2, tc) \
619CPPYY_IMPL_BASIC_CONVERTER_METHODS(name, type, stype, ctype, F1, F2)
645 "integer to character: value %d not in range [%d,%d]",
lchar, low, high);
655#define CPPYY_IMPL_REFCONVERTER_FROM_MEMORY(name, ctype) \
656PyObject* CPyCppyy::name##RefConverter::FromMemory(void* ptr) \
659 PyTypeObject* ctypes_type = GetCTypesType(ct_##ctype); \
660 if (!ctypes_type) { \
661 PyErr_SetString(PyExc_RuntimeError, "no ctypes available"); \
664 PyObject* ref = ctypes_type->tp_new(ctypes_type, nullptr, nullptr); \
665 ((CPyCppyy_tagCDataObject*)ref)->b_ptr = (char*)ptr; \
666 ((CPyCppyy_tagCDataObject*)ref)->b_needsfree = 0; \
671#define CPPYY_IMPL_BASIC_CONST_REFCONVERTER(name, type, ctype, F1) \
672bool CPyCppyy::Const##name##RefConverter::SetArg( \
673 PyObject* pyobject, Parameter& para, CallContext* ) \
675 type val = (type)F1(pyobject); \
676 if (val == (type)-1 && PyErr_Occurred()) { \
677 if (pyobject == CPyCppyy::gDefaultObject) { \
683 para.fValue.f##name = val; \
684 para.fRef = ¶.fValue.f##name; \
685 para.fTypeCode = 'r'; \
688CPPYY_IMPL_REFCONVERTER_FROM_MEMORY(Const##name, ctype)
691#define CPPYY_IMPL_BASIC_CONST_CHAR_REFCONVERTER(name, type, ctype, low, high)\
692bool CPyCppyy::Const##name##RefConverter::SetArg( \
693 PyObject* pyobject, Parameter& para, CallContext* ) \
696 type val = (type)ExtractChar(pyobject, #type, low, high); \
697 if (val == (type)-1 && PyErr_Occurred()) \
699 para.fValue.fLong = val; \
700 para.fTypeCode = 'l'; \
703CPPYY_IMPL_REFCONVERTER_FROM_MEMORY(Const##name, ctype)
707#define CPPYY_IMPL_BASIC_CHAR_CONVERTER(name, type, low, high) \
708bool CPyCppyy::name##Converter::SetArg( \
709 PyObject* pyobject, Parameter& para, CallContext* ) \
712 long val = ExtractChar(pyobject, #type, low, high); \
713 if (val == -1 && PyErr_Occurred()) \
715 para.fValue.fLong = val; \
716 para.fTypeCode = 'l'; \
720PyObject* CPyCppyy::name##Converter::FromMemory(void* address) \
723 return CPyCppyy_PyText_FromFormat("%c", *((type*)address)); \
726bool CPyCppyy::name##Converter::ToMemory( \
727 PyObject* value, void* address, PyObject* ) \
730 const char* cstr = nullptr; \
731 if (PyBytes_Check(value)) \
732 PyBytes_AsStringAndSize(value, (char**)&cstr, &len); \
734 cstr = CPyCppyy_PyText_AsStringAndSize(value, &len); \
737 PyErr_Format(PyExc_TypeError, #type" expected, got string of size %zd", len);\
740 *((type*)address) = (type)cstr[0]; \
743 long l = PyLong_AsLong(value); \
744 if (l == -1 && PyErr_Occurred()) { \
745 if (value == CPyCppyy::gDefaultObject) { \
751 if (!(low <= l && l <= high)) { \
752 PyErr_Format(PyExc_ValueError, \
753 "integer to character: value %ld not in range [%d,%d]", l, low, high);\
756 *((type*)address) = (type)l; \
770#if PY_VERSION_HEX < 0x03000000
773 para.fTypeCode =
'V';
780 para.fTypeCode =
'V';
785 para.fTypeCode =
'V';
814bool CPyCppyy::IntRefConverter::SetArg(
818#if PY_VERSION_HEX < 0x03000000
821 para.fTypeCode =
'V';
826#if PY_VERSION_HEX >= 0x02050000
829 para.fTypeCode =
'V';
836 if (
para.fValue.fVoidp && buflen) {
837 para.fTypeCode =
'V';
841#if PY_VERSION_HEX < 0x02050000
850#define CPPYY_IMPL_REFCONVERTER(name, ctype, type, code) \
851bool CPyCppyy::name##RefConverter::SetArg( \
852 PyObject* pyobject, Parameter& para, CallContext* ) \
855 if (Py_TYPE(pyobject) == GetCTypesType(ct_##ctype)) { \
856 para.fValue.fVoidp = (void*)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr;\
857 para.fTypeCode = 'V'; \
860 bool res = CArraySetArg(pyobject, para, code, sizeof(type)); \
862 PyErr_SetString(PyExc_TypeError, "use ctypes."#ctype" for pass-by-ref of "#type);\
865 para.fTypeCode = 'V'; \
868CPPYY_IMPL_REFCONVERTER_FROM_MEMORY(name, ctype)
912PyObject* CPyCppyy::UCharAsIntConverter::FromMemory(
void* address)
920bool CPyCppyy::WCharConverter::SetArg(
932 para.fValue.fLong = (long)val;
933 para.fTypeCode =
'U';
937PyObject* CPyCppyy::WCharConverter::FromMemory(
void* address)
952 *((
wchar_t*)address) = val;
957bool CPyCppyy::Char16Converter::SetArg(
967 if (!
bstr)
return false;
971 para.fValue.fLong = (long)val;
972 para.fTypeCode =
'U';
976PyObject* CPyCppyy::Char16Converter::FromMemory(
void* address)
989 if (!
bstr)
return false;
997bool CPyCppyy::Char32Converter::SetArg(
1007 if (!
bstr)
return false;
1011 para.fValue.fLong = (long)val;
1012 para.fTypeCode =
'U';
1016PyObject* CPyCppyy::Char32Converter::FromMemory(
void* address)
1029 if (!
bstr)
return false;
1057bool CPyCppyy::ULongConverter::SetArg(
1067 para.fTypeCode =
'L';
1071PyObject* CPyCppyy::ULongConverter::FromMemory(
void* address)
1084 u = (
unsigned long)0;
1088 *((
unsigned long*)address) =
u;
1093PyObject* CPyCppyy::UIntConverter::FromMemory(
void* address)
1111 *((
unsigned int*)address) = (
unsigned int)
u;
1128bool CPyCppyy::ComplexDConverter::SetArg(
1136 para.fTypeCode =
'V';
1143PyObject* CPyCppyy::ComplexDConverter::FromMemory(
void* address)
1145 std::complex<double>*
dc = (std::complex<double>*)address;
1153 std::complex<double>*
dc = (std::complex<double>*)address;
1158 return this->InstanceConverter::ToMemory(
value, address,
ctxt);
1162bool CPyCppyy::DoubleRefConverter::SetArg(
1166#if PY_VERSION_HEX < 0x03000000
1169 para.fTypeCode =
'V';
1174#if PY_VERSION_HEX >= 0x02050000
1177 para.fTypeCode =
'V';
1184 if (
para.fValue.fVoidp && buflen) {
1185 para.fTypeCode =
'V';
1189#if PY_VERSION_HEX < 0x02050000
1211bool CPyCppyy::LLongConverter::SetArg(
1221 para.fTypeCode =
'q';
1225PyObject* CPyCppyy::LLongConverter::FromMemory(
void* address)
1247bool CPyCppyy::ULLongConverter::SetArg(
1257 para.fTypeCode =
'Q';
1261PyObject* CPyCppyy::ULLongConverter::FromMemory(
void* address)
1283bool CPyCppyy::CStringConverter::SetArg(
1295 para.fTypeCode =
'V';
1306 if (!
ctxt->fPyContext) {
1317 para.fTypeCode =
'p';
1321PyObject* CPyCppyy::CStringConverter::FromMemory(
void* address)
1324 if (address && *(
void**)address) {
1328 if (*(
void**)address == (
void*)
fBuffer.data())
1345 if (!
cstr)
return false;
1354 void*
ptrval = *(
void**)address;
1357 *(
void**)address = (
void*)
fBuffer.data();
1367 *(
void**)address = (
void*)
cstr;
1382bool CPyCppyy::WCStringConverter::SetArg(
1398 para.fTypeCode =
'p';
1402PyObject* CPyCppyy::WCStringConverter::FromMemory(
void* address)
1405 if (address && *(
wchar_t**)address) {
1406 if (
fMaxSize != std::wstring::npos)
1429 if (
fMaxSize != std::wstring::npos)
1435 if (res == -1)
return false;
1440#define CPYCPPYY_WIDESTRING_CONVERTER(name, type, encode, decode, snull) \
1441bool CPyCppyy::name##Converter::SetArg( \
1442 PyObject* pyobject, Parameter& para, CallContext* ) \
1445 PyObject* bstr = encode(pyobject); \
1446 if (!bstr) return false; \
1448 Py_ssize_t len = PyBytes_GET_SIZE(bstr) - sizeof(type) ; \
1449 fBuffer = (type*)realloc(fBuffer, len + sizeof(type)); \
1450 memcpy(fBuffer, PyBytes_AS_STRING(bstr) + sizeof(type) , len); \
1453 fBuffer[len/sizeof(type)] = snull; \
1454 para.fValue.fVoidp = (void*)fBuffer; \
1455 para.fTypeCode = 'p'; \
1459PyObject* CPyCppyy::name##Converter::FromMemory(void* address) \
1462 if (address && *(type**)address) { \
1463 if (fMaxSize != std::wstring::npos) \
1464 return decode(*(const char**)address, (Py_ssize_t)fMaxSize*sizeof(type), nullptr, nullptr);\
1465 return decode(*(const char**)address, \
1466 std::char_traits<type>::length(*(type**)address)*sizeof(type), nullptr, nullptr);\
1471 return decode((const char*)&w, 0, nullptr, nullptr); \
1474bool CPyCppyy::name##Converter::ToMemory(PyObject* value, void* address, PyObject* )\
1477 PyObject* bstr = encode(value); \
1478 if (!bstr) return false; \
1480 Py_ssize_t len = PyBytes_GET_SIZE(bstr) - sizeof(type) ; \
1481 Py_ssize_t maxbytes = (Py_ssize_t)fMaxSize*sizeof(type); \
1484 if (fMaxSize != std::wstring::npos && maxbytes < len) { \
1485 PyErr_Warn(PyExc_RuntimeWarning, (char*)"string too long for "#type" array (truncated)");\
1489 memcpy(*((void**)address), PyBytes_AS_STRING(bstr) + sizeof(type) , len);\
1492 if (len/sizeof(type) < fMaxSize) (*(type**)address)[len/sizeof(type)] = snull;\
1500bool CPyCppyy::NonConstCStringConverter::SetArg(
1513PyObject* CPyCppyy::NonConstCStringConverter::FromMemory(
void* address)
1518 return this->CStringConverter::FromMemory(address);
1534 address = (
void*)val;
1562 para.fValue.fVoidp =
pyobj->GetObject();
1563 para.fTypeCode =
'p';
1568 if (GetAddressSpecialCase(
pyobject,
para.fValue.fVoidp)) {
1569 para.fTypeCode =
'p';
1577 para.fValue.fVoidp = (
void*)((CPyCppyy_tagCDataObject*)
pyobject)->b_ptr;
1578 para.fTypeCode =
'V';
1584 void** payload = (
void**)((CPyCppyy_tagCDataObject*)
pyobject)->b_ptr;
1586 para.fValue.fVoidp = *payload;
1587 para.fTypeCode =
'p';
1596 if (
para.fValue.fVoidp && buflen != 0) {
1597 para.fTypeCode =
'p';
1609 if (!address || *(
uintptr_t*)address == 0) {
1627 *(
void**)address =
pyobj->GetObject();
1632 void* ptr =
nullptr;
1633 if (GetAddressSpecialCase(
value, ptr)) {
1634 *(
void**)address = ptr;
1639 void* buf =
nullptr;
1641 if (!buf || buflen == 0)
1644 *(
void**)address = buf;
1686#define CPPYY_IMPL_ARRAY_CONVERTER(name, ctype, type, code, suffix) \
1687CPyCppyy::name##ArrayConverter::name##ArrayConverter(cdims_t dims) : \
1689 fIsFixed = dims ? fShape[0] != UNKNOWN_SIZE : false; \
1692bool CPyCppyy::name##ArrayConverter::SetArg( \
1693 PyObject* pyobject, Parameter& para, CallContext* ctxt) \
1696 bool convOk = false; \
1699 if (fShape.ndim() == 2) { \
1700 if (Py_TYPE(pyobject) == GetCTypesPtrType(ct_##ctype)) { \
1701 para.fValue.fVoidp = (void*)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr;\
1702 para.fTypeCode = 'p'; \
1704 } else if (Py_TYPE(pyobject) == GetCTypesType(ct_c_void_p)) { \
1706 para.fValue.fVoidp = (void*)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr;\
1707 para.fTypeCode = 'p'; \
1709 } else if (LowLevelView_Check(pyobject) && \
1710 ((LowLevelView*)pyobject)->fBufInfo.ndim == 2 && \
1711 strchr(((LowLevelView*)pyobject)->fBufInfo.format, code)) { \
1712 para.fValue.fVoidp = ((LowLevelView*)pyobject)->get_buf(); \
1713 para.fTypeCode = 'p'; \
1720 PyTypeObject* ctypes_type = GetCTypesType(ct_##ctype); \
1721 if (Py_TYPE(pyobject) == ctypes_type) { \
1722 para.fValue.fVoidp = (void*)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr;\
1723 para.fTypeCode = 'p'; \
1725 } else if (Py_TYPE(pyobject) == GetCTypesPtrType(ct_##ctype)) { \
1726 para.fValue.fVoidp = (void*)((CPyCppyy_tagCDataObject*)pyobject)->b_ptr;\
1727 para.fTypeCode = 'V'; \
1729 } else if (IsPyCArgObject(pyobject)) { \
1730 CPyCppyy_tagPyCArgObject* carg = (CPyCppyy_tagPyCArgObject*)pyobject;\
1731 if (carg->obj && Py_TYPE(carg->obj) == ctypes_type) { \
1732 para.fValue.fVoidp = (void*)((CPyCppyy_tagCDataObject*)carg->obj)->b_ptr;\
1733 para.fTypeCode = 'p'; \
1741 bool ismulti = fShape.ndim() > 1; \
1742 convOk = CArraySetArg(pyobject, para, code, ismulti ? sizeof(void*) : sizeof(type), true);\
1746 if (convOk) SetLifeLine(ctxt->fPyContext, pyobject, (intptr_t)this); \
1751PyObject* CPyCppyy::name##ArrayConverter::FromMemory(void* address) \
1754 return CreateLowLevelView##suffix((type**)address, fShape); \
1755 return CreateLowLevelView##suffix(*(type**)address, fShape); \
1758bool CPyCppyy::name##ArrayConverter::ToMemory( \
1759 PyObject* value, void* address, PyObject* ctxt) \
1761 if (fShape.ndim() <= 1 || fIsFixed) { \
1762 void* buf = nullptr; \
1763 Py_ssize_t buflen = Utility::GetBuffer(value, code, sizeof(type), buf);\
1764 return ToArrayFromBuffer<type>(value, address, ctxt, buf, buflen, fShape, fIsFixed);\
1766 void* buf = nullptr; \
1767 Py_ssize_t buflen = Utility::GetBuffer(value, code, sizeof(void*), buf);\
1768 if (buflen == 0) return false; \
1769 *(type**)address = (type*)buf; \
1770 SetLifeLine(ctxt, value, (intptr_t)address); \
1780#if (__cplusplus > 201402L) || (defined(_MSC_VER) && _MSVC_LANG > 201402L)
1805bool CPyCppyy::CStringArrayConverter::SetArg(
1813 para.fTypeCode =
'V';
1817#if PY_VERSION_HEX >= 0x03000000
1825 if (
len == (
size_t)-1) {
1831 for (
size_t i = 0; i <
len; ++i) {
1849 para.fTypeCode =
'p';
1858PyObject* CPyCppyy::CStringArrayConverter::FromMemory(
void* address)
1876 return SCharArrayConverter::ToMemory(
value, address,
ctxt);
1880PyObject* CPyCppyy::NonConstCStringArrayConverter::FromMemory(
void* address)
1894 para.fValue.fVoidp =
nullptr;
1895 para.fTypeCode =
'p';
1910#if PY_VERSION_HEX < 0x03030000
1920 const char*
cstr =
nullptr;
1922 if (
cstr) buffer = T{
cstr, (
typename T::size_type)
len};
1930#define CPPYY_IMPL_STRING_AS_PRIMITIVE_CONVERTER(name, type, F1, F2) \
1931CPyCppyy::name##Converter::name##Converter(bool keepControl) : \
1932 InstanceConverter(Cppyy::GetScope(#type), keepControl) {} \
1934bool CPyCppyy::name##Converter::SetArg( \
1935 PyObject* pyobject, Parameter& para, CallContext* ctxt) \
1937 if (CPyCppyy_PyUnicodeAsBytes2Buffer(pyobject, fBuffer)) { \
1938 para.fValue.fVoidp = &fBuffer; \
1939 para.fTypeCode = 'V'; \
1944 if (!(PyInt_Check(pyobject) || PyLong_Check(pyobject))) { \
1945 bool result = InstanceConverter::SetArg(pyobject, para, ctxt); \
1946 para.fTypeCode = 'V'; \
1953PyObject* CPyCppyy::name##Converter::FromMemory(void* address) \
1956 return InstanceConverter::FromMemory(address); \
1957 auto* empty = new type(); \
1958 return BindCppObjectNoCast(empty, fClass, CPPInstance::kIsOwner); \
1961bool CPyCppyy::name##Converter::ToMemory( \
1962 PyObject* value, void* address, PyObject* ctxt) \
1964 if (CPyCppyy_PyUnicodeAsBytes2Buffer(value, *((type*)address))) \
1966 return InstanceConverter::ToMemory(value, address, ctxt); \
1972CPyCppyy::STLWStringConverter::STLWStringConverter(
bool keepControl) :
1975bool CPyCppyy::STLWStringConverter::SetArg(
1983 para.fTypeCode =
'V';
1986#if PY_VERSION_HEX < 0x03000000
1989 std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>>
cnv;
1993 if (!
pyu)
return false;
1999 para.fTypeCode =
'V';
2006 para.fTypeCode =
'V';
2013PyObject* CPyCppyy::STLWStringConverter::FromMemory(
void* address)
2025 wchar_t* buf =
new wchar_t[
len+1];
2027 *((std::wstring*)address) = std::wstring(buf,
len);
2031 return InstanceConverter::ToMemory(
value, address,
ctxt);
2035#if (__cplusplus > 201402L) || (defined(_MSC_VER) && _MSVC_LANG > 201402L)
2036CPyCppyy::STLStringViewConverter::STLStringViewConverter(
bool keepControl) :
2039bool CPyCppyy::STLStringViewConverter::SetArg(
2046 para.fTypeCode =
'V';
2057 fBuffer = std::string_view(
cstr, (std::string_view::size_type)
len);
2059 para.fTypeCode =
'V';
2072 void* ptr =
pyobj->GetObject();
2078 fBuffer = *((std::string*)ptr);
2080 para.fTypeCode =
'V';
2088PyObject* CPyCppyy::STLStringViewConverter::FromMemory(
void* address)
2091 return InstanceConverter::FromMemory(address);
2092 auto* empty =
new std::string_view();
2096bool CPyCppyy::STLStringViewConverter::ToMemory(
2100 if (InstanceConverter::ToMemory(
value, address,
ctxt))
2108 *
reinterpret_cast<std::string_view*
>(address) = \
2109 std::string_view(
cstr, (std::string_view::size_type)
len);
2118bool CPyCppyy::STLStringMoveConverter::SetArg(
2147template <
bool ISCONST>
2154 if (GetAddressSpecialCase(
pyobject,
para.fValue.fVoidp)) {
2155 para.fTypeCode =
'p';
2175 para.fValue.fVoidp =
pyobj->GetObject();
2182 para.fTypeCode =
'p';
2190template <
bool ISCONST>
2200template <
bool ISCONST>
2206 void* ptr =
nullptr;
2207 if (GetAddressSpecialCase(
value, ptr)) {
2208 *(
void**)address = ptr;
2221 *(
void**)address =
pyobj->GetObject();
2231bool CPyCppyy::InstanceConverter::SetArg(
2240 para.fValue.fVoidp =
pyobj->GetObject();
2241 if (!
para.fValue.fVoidp)
2249 para.fTypeCode =
'V';
2258PyObject* CPyCppyy::InstanceConverter::FromMemory(
void* address)
2272#if PY_VERSION_HEX >= 0x03080000
2288bool CPyCppyy::InstanceRefConverter::SetArg(
2303 if (
pyobj->IsSmart()) {
2306 para.fValue.fVoidp =
pyobj->GetObjectRaw();
2314 para.fValue.fVoidp =
pyobj->GetObject();
2321 if (!
para.fValue.fVoidp) {
2332 para.fTypeCode =
'V';
2344PyObject* CPyCppyy::InstanceRefConverter::FromMemory(
void* address)
2350bool CPyCppyy::InstanceMoveConverter::SetArg(
2381template <
bool ISREFERENCE>
2382bool CPyCppyy::InstancePtrPtrConverter<ISREFERENCE>::SetArg(
2390 para.fValue.fVoidp =
nullptr;
2391 para.fTypeCode =
'p';
2404 para.fValue.fVoidp =
pyobj->GetObjectRaw();
2406 para.fValue.fVoidp = &
pyobj->GetObjectRaw();
2415template <
bool ISREFERENCE>
2416PyObject* CPyCppyy::InstancePtrPtrConverter<ISREFERENCE>::FromMemory(
void* address)
2423template <
bool ISREFERENCE>
2424bool CPyCppyy::InstancePtrPtrConverter<ISREFERENCE>::ToMemory(
2432 *(
void**)address =
nullptr;
2447 *(
void**)address =
pyobj->GetObject();
2459 template class CPyCppyy::InstancePtrPtrConverter<true>;
2460 template class CPyCppyy::InstancePtrPtrConverter<false>;
2464bool CPyCppyy::InstanceArrayConverter::SetArg(
2483 para.fTypeCode =
'p';
2491PyObject* CPyCppyy::InstanceArrayConverter::FromMemory(
void* address)
2498bool CPyCppyy::InstanceArrayConverter::ToMemory(
2505 "access to C-arrays of objects not yet implemented!");
2512bool CPyCppyy::STLIteratorConverter::SetArg(
2520 para.fValue.fVoidp =
pyobj->GetObject();
2521 para.fTypeCode =
'V';
2527bool CPyCppyy::VoidPtrRefConverter::SetArg(
2533 para.fValue.fVoidp = &
pyobj->GetObjectRaw();
2534 para.fTypeCode =
'V';
2542CPyCppyy::VoidPtrPtrConverter::VoidPtrPtrConverter(
cdims_t dims) :
2548bool CPyCppyy::VoidPtrPtrConverter::SetArg(
2555 para.fValue.fVoidp = &
pyobj->GetObjectRaw();
2556 para.fTypeCode =
'p';
2562 para.fTypeCode =
'p';
2572 if (
para.fValue.fVoidp && buflen != 0) {
2573 para.fTypeCode =
'p';
2581PyObject* CPyCppyy::VoidPtrPtrConverter::FromMemory(
void* address)
2584 if (!address || *(ptrdiff_t*)address == 0) {
2594bool CPyCppyy::PyObjectConverter::SetArg(
2599 para.fTypeCode =
'p';
2603PyObject* CPyCppyy::PyObjectConverter::FromMemory(
void* address)
2639 auto key =
ipos->second.second;
2657 const_cast<char*
>(
"internal_WrapperCacheEraser"),
2673 if (!
ol->fMethodInfo ||
ol->fMethodInfo->fMethods.empty())
2677 for (
auto&
m :
ol->fMethodInfo->fMethods) {
2682 void*
fptr = (
void*)
m->GetFunctionAddress();
2692 std::string fullname =
pytmpl->fTI->fCppName;
2693 if (
pytmpl->fTemplateArgs)
2747 std::ostringstream
wname;
2751 std::ostringstream code;
2752 code <<
"namespace __cppyy_internal {\n "
2754 for (
int i = 0; i <
nArgs; ++i) {
2755 code <<
argtypes[i] <<
" arg" << i;
2756 if (i !=
nArgs-1) code <<
", ";
2767 code <<
" PyObject** ref = (PyObject**)" << (intptr_t)ref <<
";\n"
2768 " PyObject* pyresult = nullptr;\n"
2769 " if (*ref) pyresult = PyObject_CallFunctionObjArgs(*ref";
2770 for (
int i = 0; i <
nArgs; ++i)
2771 code <<
", pyargs[" << i <<
"]";
2772 code <<
", NULL);\n"
2773 " else PyErr_SetString(PyExc_TypeError, \"callable was deleted\");\n";
2805bool CPyCppyy::FunctionPointerConverter::SetArg(
2810 para.fValue.fVoidp =
nullptr;
2811 para.fTypeCode =
'p';
2820 para.fTypeCode =
'p';
2827PyObject* CPyCppyy::FunctionPointerConverter::FromMemory(
void* address)
2838bool CPyCppyy::FunctionPointerConverter::ToMemory(
2843 *((
void**)address) =
nullptr;
2851 *((
void**)address) =
fptr;
2860bool CPyCppyy::StdFunctionConverter::SetArg(
2874 PyObject* func = this->FunctionPointerConverter::FromMemory(&
para.fValue.fVoidp);
2887PyObject* CPyCppyy::StdFunctionConverter::FromMemory(
void* address)
2902bool CPyCppyy::SmartPtrConverter::SetArg(
2929 para.fValue.fVoidp =
pyobj->GetSmartObject();
2944 para.fValue.fVoidp =
pyobj->GetObject();
2975 pyobj->PythonOwns();
2986 para.fTypeCode =
'V';
2993PyObject* CPyCppyy::SmartPtrConverter::FromMemory(
void* address)
3006#if PY_VERSION_HEX >= 0x03080000
3025#if defined (_LIBCPP_INITIALIZER_LIST) || defined(__GNUC__)
3028 typedef size_t size_type;
3029 typedef void* iterator;
3033#elif defined (_MSC_VER)
3036 typedef char* iterator;
3041#define NO_KNOWN_INITIALIZER_LIST 1
3046CPyCppyy::InitializerListConverter::InitializerListConverter(
Cppyy::TCppType_t klass, std::string
const &value_type)
3048 : InstanceConverter{
klass},
3055CPyCppyy::InitializerListConverter::~InitializerListConverter()
3063void CPyCppyy::InitializerListConverter::Clear() {
3066#if defined (_LIBCPP_INITIALIZER_LIST) || defined(__GNUC__)
3067 for (faux_initlist::size_type i = 0; i <
fake->_M_len; ++i) {
3068#elif defined (_MSC_VER)
3080bool CPyCppyy::InitializerListConverter::SetArg(
3083#ifdef NO_KNOWN_INITIALIZER_LIST
3103 void* buf =
nullptr;
3107 if (buf && buflen) {
3112#if defined (_LIBCPP_INITIALIZER_LIST) || defined(__GNUC__)
3113 fake->_M_len = (faux_initlist::size_type)buflen;
3114#elif defined (_MSC_VER)
3129#if defined (_LIBCPP_INITIALIZER_LIST) || defined(__GNUC__)
3130 fake->_M_len = (faux_initlist::size_type)
len;
3131 for (faux_initlist::size_type i = 0; i <
fake->_M_len; ++i) {
3132#elif defined (_MSC_VER)
3155 if (
memloc) entries += 1;
3158 "default ctor needed for initializer list of objects");
3175#if defined (_LIBCPP_INITIALIZER_LIST) || defined(__GNUC__)
3176 fake->_M_len = (faux_initlist::size_type)entries;
3177#elif defined (_MSC_VER)
3190 para.fTypeCode =
'V';
3211 if (
cpd ==
"**" ||
cpd ==
"*[]" ||
cpd ==
"&*")
3213 else if (
cpd ==
"*&")
3219 else if (
cpd ==
"&")
3221 else if (
cpd ==
"&&")
3247 return (
h->second)(
dims);
3257 return (
h->second)(
dims);
3268 return (
h->second)(
dims);
3275 return (
h->second)(
dims);
3279 if (
cpd.compare(0, 3,
"*[]") == 0) {
3293 for (
int i = 2; i < (
newdim-1); ++i)
3299 return (
h->second)(
dims);
3302 }
else if (!
cpd.empty() && (std::string::size_type)std::count(
cpd.
begin(),
cpd.
end(),
'*') ==
cpd.size()) {
3308 }
else if (2 <=
cpd.size() && (std::string::size_type)std::count(
cpd.
begin(),
cpd.
end(),
'[') ==
cpd.size() / 2) {
3312 return (
h->second)(
dims);
3316 if (
realType.compare(0, 16,
"initializer_list") == 0) {
3328 if (pos == 0 || pos == 5 ||
3329 pos == 6 || pos == 11 ) {
3339 if (
pos1 != std::string::npos &&
pos2 != std::string::npos) {
3343 return new StdFunctionConverter(
cnv,
3345 }
else if (
cnv->HasState())
3357 }
else if (
cpd ==
"&") {
3367 static STLIteratorConverter
c;
3377 auto pos1 =
sm.position(0);
3379 result =
new FunctionPointerConverter(
3388 return (
h->second)(
dims);
3390 result =
new NotImplementedConverter();
3398 if (
cpd.size() == 2 &&
cpd !=
"&&")
3399 result =
new VoidPtrPtrConverter(
dims.ndim());
3400 else if (!
cpd.empty())
3403 result =
new NotImplementedConverter();
3413 if (
p &&
p->HasState())
3471#define STRINGVIEW "basic_string_view<char,char_traits<char> >"
3472#define WSTRING1 "std::basic_string<wchar_t>"
3473#define WSTRING2 "std::basic_string<wchar_t,std::char_traits<wchar_t>,std::allocator<wchar_t>>"
3477#define CCOMPLEX_D "_Complex double"
3478#define CCOMPLEX_F "_Complex float"
3480#define CCOMPLEX_D "_C_double_complex"
3481#define CCOMPLEX_F "_C_float_complex"
3484static struct InitConvFactories_t {
3486 InitConvFactories_t() {
3491 gf[
"bool"] = (
cf_t)+[](
cdims_t) {
static BoolConverter
c{};
return &
c; };
3492 gf[
"const bool&"] = (
cf_t)+[](
cdims_t) {
static ConstBoolRefConverter
c{};
return &
c; };
3493 gf[
"bool&"] = (
cf_t)+[](
cdims_t) {
static BoolRefConverter
c{};
return &
c; };
3494 gf[
"char"] = (
cf_t)+[](
cdims_t) {
static CharConverter
c{};
return &
c; };
3495 gf[
"const char&"] = (
cf_t)+[](
cdims_t) {
static ConstCharRefConverter
c{};
return &
c; };
3496 gf[
"char&"] = (
cf_t)+[](
cdims_t) {
static CharRefConverter
c{};
return &
c; };
3497 gf[
"signed char&"] = (
cf_t)+[](
cdims_t) {
static SCharRefConverter
c{};
return &
c; };
3498 gf[
"unsigned char"] = (
cf_t)+[](
cdims_t) {
static UCharConverter
c{};
return &
c; };
3499 gf[
"const unsigned char&"] = (
cf_t)+[](
cdims_t) {
static ConstUCharRefConverter
c{};
return &
c; };
3500 gf[
"unsigned char&"] = (
cf_t)+[](
cdims_t) {
static UCharRefConverter
c{};
return &
c; };
3501 gf[
"SCharAsInt"] = (
cf_t)+[](
cdims_t) {
static SCharAsIntConverter
c{};
return &
c; };
3502 gf[
"UCharAsInt"] = (
cf_t)+[](
cdims_t) {
static UCharAsIntConverter
c{};
return &
c; };
3503 gf[
"wchar_t"] = (
cf_t)+[](
cdims_t) {
static WCharConverter
c{};
return &
c; };
3504 gf[
"char16_t"] = (
cf_t)+[](
cdims_t) {
static Char16Converter
c{};
return &
c; };
3505 gf[
"char32_t"] = (
cf_t)+[](
cdims_t) {
static Char32Converter
c{};
return &
c; };
3506 gf[
"wchar_t&"] = (
cf_t)+[](
cdims_t) {
static WCharRefConverter
c{};
return &
c; };
3507 gf[
"char16_t&"] = (
cf_t)+[](
cdims_t) {
static Char16RefConverter
c{};
return &
c; };
3508 gf[
"char32_t&"] = (
cf_t)+[](
cdims_t) {
static Char32RefConverter
c{};
return &
c; };
3509 gf[
"int8_t"] = (
cf_t)+[](
cdims_t) {
static Int8Converter
c{};
return &
c; };
3510 gf[
"const int8_t&"] = (
cf_t)+[](
cdims_t) {
static ConstInt8RefConverter
c{};
return &
c; };
3511 gf[
"int8_t&"] = (
cf_t)+[](
cdims_t) {
static Int8RefConverter
c{};
return &
c; };
3512 gf[
"int16_t"] = (
cf_t)+[](
cdims_t) {
static Int16Converter
c{};
return &
c; };
3513 gf[
"const int16_t&"] = (
cf_t)+[](
cdims_t) {
static ConstInt16RefConverter
c{};
return &
c; };
3514 gf[
"int16_t&"] = (
cf_t)+[](
cdims_t) {
static Int16RefConverter
c{};
return &
c; };
3515 gf[
"int32_t"] = (
cf_t)+[](
cdims_t) {
static Int32Converter
c{};
return &
c; };
3516 gf[
"const int32_t&"] = (
cf_t)+[](
cdims_t) {
static ConstInt32RefConverter
c{};
return &
c; };
3517 gf[
"int32_t&"] = (
cf_t)+[](
cdims_t) {
static Int32RefConverter
c{};
return &
c; };
3518 gf[
"uint8_t"] = (
cf_t)+[](
cdims_t) {
static UInt8Converter
c{};
return &
c; };
3519 gf[
"const uint8_t&"] = (
cf_t)+[](
cdims_t) {
static ConstUInt8RefConverter
c{};
return &
c; };
3520 gf[
"uint8_t&"] = (
cf_t)+[](
cdims_t) {
static UInt8RefConverter
c{};
return &
c; };
3521 gf[
"uint16_t"] = (
cf_t)+[](
cdims_t) {
static UInt16Converter
c{};
return &
c; };
3522 gf[
"const uint16_t&"] = (
cf_t)+[](
cdims_t) {
static ConstUInt16RefConverter
c{};
return &
c; };
3523 gf[
"uint16_t&"] = (
cf_t)+[](
cdims_t) {
static UInt16RefConverter
c{};
return &
c; };
3524 gf[
"uint32_t"] = (
cf_t)+[](
cdims_t) {
static UInt32Converter
c{};
return &
c; };
3525 gf[
"const uint32_t&"] = (
cf_t)+[](
cdims_t) {
static ConstUInt32RefConverter
c{};
return &
c; };
3526 gf[
"uint32_t&"] = (
cf_t)+[](
cdims_t) {
static UInt32RefConverter
c{};
return &
c; };
3527 gf[
"short"] = (
cf_t)+[](
cdims_t) {
static ShortConverter
c{};
return &
c; };
3528 gf[
"const short&"] = (
cf_t)+[](
cdims_t) {
static ConstShortRefConverter
c{};
return &
c; };
3529 gf[
"short&"] = (
cf_t)+[](
cdims_t) {
static ShortRefConverter
c{};
return &
c; };
3530 gf[
"unsigned short"] = (
cf_t)+[](
cdims_t) {
static UShortConverter
c{};
return &
c; };
3531 gf[
"const unsigned short&"] = (
cf_t)+[](
cdims_t) {
static ConstUShortRefConverter
c{};
return &
c; };
3532 gf[
"unsigned short&"] = (
cf_t)+[](
cdims_t) {
static UShortRefConverter
c{};
return &
c; };
3533 gf[
"int"] = (
cf_t)+[](
cdims_t) {
static IntConverter
c{};
return &
c; };
3534 gf[
"int&"] = (
cf_t)+[](
cdims_t) {
static IntRefConverter
c{};
return &
c; };
3535 gf[
"const int&"] = (
cf_t)+[](
cdims_t) {
static ConstIntRefConverter
c{};
return &
c; };
3536 gf[
"unsigned int"] = (
cf_t)+[](
cdims_t) {
static UIntConverter
c{};
return &
c; };
3537 gf[
"const unsigned int&"] = (
cf_t)+[](
cdims_t) {
static ConstUIntRefConverter
c{};
return &
c; };
3538 gf[
"unsigned int&"] = (
cf_t)+[](
cdims_t) {
static UIntRefConverter
c{};
return &
c; };
3539 gf[
"long"] = (
cf_t)+[](
cdims_t) {
static LongConverter
c{};
return &
c; };
3540 gf[
"long&"] = (
cf_t)+[](
cdims_t) {
static LongRefConverter
c{};
return &
c; };
3541 gf[
"const long&"] = (
cf_t)+[](
cdims_t) {
static ConstLongRefConverter
c{};
return &
c; };
3542 gf[
"unsigned long"] = (
cf_t)+[](
cdims_t) {
static ULongConverter
c{};
return &
c; };
3543 gf[
"const unsigned long&"] = (
cf_t)+[](
cdims_t) {
static ConstULongRefConverter
c{};
return &
c; };
3544 gf[
"unsigned long&"] = (
cf_t)+[](
cdims_t) {
static ULongRefConverter
c{};
return &
c; };
3545 gf[
"long long"] = (
cf_t)+[](
cdims_t) {
static LLongConverter
c{};
return &
c; };
3546 gf[
"const long long&"] = (
cf_t)+[](
cdims_t) {
static ConstLLongRefConverter
c{};
return &
c; };
3547 gf[
"long long&"] = (
cf_t)+[](
cdims_t) {
static LLongRefConverter
c{};
return &
c; };
3548 gf[
"unsigned long long"] = (
cf_t)+[](
cdims_t) {
static ULLongConverter
c{};
return &
c; };
3549 gf[
"const unsigned long long&"] = (
cf_t)+[](
cdims_t) {
static ConstULLongRefConverter
c{};
return &
c; };
3550 gf[
"unsigned long long&"] = (
cf_t)+[](
cdims_t) {
static ULLongRefConverter
c{};
return &
c; };
3552 gf[
"float"] = (
cf_t)+[](
cdims_t) {
static FloatConverter
c{};
return &
c; };
3553 gf[
"const float&"] = (
cf_t)+[](
cdims_t) {
static ConstFloatRefConverter
c{};
return &
c; };
3554 gf[
"float&"] = (
cf_t)+[](
cdims_t) {
static FloatRefConverter
c{};
return &
c; };
3555 gf[
"double"] = (
cf_t)+[](
cdims_t) {
static DoubleConverter
c{};
return &
c; };
3556 gf[
"double&"] = (
cf_t)+[](
cdims_t) {
static DoubleRefConverter
c{};
return &
c; };
3557 gf[
"const double&"] = (
cf_t)+[](
cdims_t) {
static ConstDoubleRefConverter
c{};
return &
c; };
3558 gf[
"long double"] = (
cf_t)+[](
cdims_t) {
static LDoubleConverter
c{};
return &
c; };
3559 gf[
"const long double&"] = (
cf_t)+[](
cdims_t) {
static ConstLDoubleRefConverter
c{};
return &
c; };
3560 gf[
"long double&"] = (
cf_t)+[](
cdims_t) {
static LDoubleRefConverter
c{};
return &
c; };
3561 gf[
"std::complex<double>"] = (
cf_t)+[](
cdims_t) {
return new ComplexDConverter{}; };
3562 gf[
"const std::complex<double>&"] = (
cf_t)+[](
cdims_t) {
return new ComplexDConverter{}; };
3563 gf[
"void"] = (
cf_t)+[](
cdims_t) {
static VoidConverter
c{};
return &
c; };
3566 gf[
"bool ptr"] = (
cf_t)+[](
cdims_t d) {
return new BoolArrayConverter{
d}; };
3567 gf[
"signed char ptr"] = (
cf_t)+[](
cdims_t d) {
return new SCharArrayConverter{
d}; };
3569 gf[
"const unsigned char*"] = (
cf_t)+[](
cdims_t d) {
return new UCharArrayConverter{
d}; };
3570 gf[
"unsigned char ptr"] = (
cf_t)+[](
cdims_t d) {
return new UCharArrayConverter{
d}; };
3571 gf[
"SCharAsInt*"] =
gf[
"signed char ptr"];
3572 gf[
"SCharAsInt[]"] =
gf[
"signed char ptr"];
3573 gf[
"UCharAsInt*"] =
gf[
"unsigned char ptr"];
3574 gf[
"UCharAsInt[]"] =
gf[
"unsigned char ptr"];
3575#if (__cplusplus > 201402L) || (defined(_MSC_VER) && _MSVC_LANG > 201402L)
3578 gf[
"int8_t ptr"] = (
cf_t)+[](
cdims_t d) {
return new Int8ArrayConverter{
d}; };
3579 gf[
"int16_t ptr"] = (
cf_t)+[](
cdims_t d) {
return new Int16ArrayConverter{
d}; };
3580 gf[
"int32_t ptr"] = (
cf_t)+[](
cdims_t d) {
return new Int32ArrayConverter{
d}; };
3581 gf[
"uint8_t ptr"] = (
cf_t)+[](
cdims_t d) {
return new UInt8ArrayConverter{
d}; };
3582 gf[
"uint16_t ptr"] = (
cf_t)+[](
cdims_t d) {
return new UInt16ArrayConverter{
d}; };
3583 gf[
"uint32_t ptr"] = (
cf_t)+[](
cdims_t d) {
return new UInt32ArrayConverter{
d}; };
3584 gf[
"short ptr"] = (
cf_t)+[](
cdims_t d) {
return new ShortArrayConverter{
d}; };
3585 gf[
"unsigned short ptr"] = (
cf_t)+[](
cdims_t d) {
return new UShortArrayConverter{
d}; };
3586 gf[
"int ptr"] = (
cf_t)+[](
cdims_t d) {
return new IntArrayConverter{
d}; };
3587 gf[
"unsigned int ptr"] = (
cf_t)+[](
cdims_t d) {
return new UIntArrayConverter{
d}; };
3588 gf[
"long ptr"] = (
cf_t)+[](
cdims_t d) {
return new LongArrayConverter{
d}; };
3589 gf[
"unsigned long ptr"] = (
cf_t)+[](
cdims_t d) {
return new ULongArrayConverter{
d}; };
3590 gf[
"long long ptr"] = (
cf_t)+[](
cdims_t d) {
return new LLongArrayConverter{
d}; };
3591 gf[
"unsigned long long ptr"] = (
cf_t)+[](
cdims_t d) {
return new ULLongArrayConverter{
d}; };
3592 gf[
"float ptr"] = (
cf_t)+[](
cdims_t d) {
return new FloatArrayConverter{
d}; };
3593 gf[
"double ptr"] = (
cf_t)+[](
cdims_t d) {
return new DoubleArrayConverter{
d}; };
3594 gf[
"long double ptr"] = (
cf_t)+[](
cdims_t d) {
return new LDoubleArrayConverter{
d}; };
3595 gf[
"std::complex<float> ptr"] = (
cf_t)+[](
cdims_t d) {
return new ComplexFArrayConverter{
d}; };
3596 gf[
"std::complex<double> ptr"] = (
cf_t)+[](
cdims_t d) {
return new ComplexDArrayConverter{
d}; };
3600 gf[
"signed char"] =
gf[
"char"];
3601 gf[
"const signed char&"] =
gf[
"const char&"];
3602#if (__cplusplus > 201402L) || (defined(_MSC_VER) && _MSVC_LANG > 201402L)
3603 gf[
"std::byte"] =
gf[
"uint8_t"];
3604 gf[
"byte"] =
gf[
"uint8_t"];
3605 gf[
"const std::byte&"] =
gf[
"const uint8_t&"];
3606 gf[
"const byte&"] =
gf[
"const uint8_t&"];
3607 gf[
"std::byte&"] =
gf[
"uint8_t&"];
3608 gf[
"byte&"] =
gf[
"uint8_t&"];
3610 gf[
"std::int8_t"] =
gf[
"int8_t"];
3611 gf[
"const std::int8_t&"] =
gf[
"const int8_t&"];
3612 gf[
"std::int8_t&"] =
gf[
"int8_t&"];
3613 gf[
"std::uint8_t"] =
gf[
"uint8_t"];
3614 gf[
"const std::uint8_t&"] =
gf[
"const uint8_t&"];
3615 gf[
"std::uint8_t&"] =
gf[
"uint8_t&"];
3616 gf[
"internal_enum_type_t"] =
gf[
"int"];
3617 gf[
"internal_enum_type_t&"] =
gf[
"int&"];
3618 gf[
"const internal_enum_type_t&"] =
gf[
"const int&"];
3619 gf[
"internal_enum_type_t ptr"] =
gf[
"int ptr"];
3621 gf[
"__int64"] =
gf[
"long long"];
3622 gf[
"const __int64&"] =
gf[
"const long long&"];
3623 gf[
"__int64&"] =
gf[
"long long&"];
3624 gf[
"__int64 ptr"] =
gf[
"long long ptr"];
3625 gf[
"unsigned __int64"] =
gf[
"unsigned long long"];
3626 gf[
"const unsigned __int64&"] =
gf[
"const unsigned long long&"];
3627 gf[
"unsigned __int64&"] =
gf[
"unsigned long long&"];
3628 gf[
"unsigned __int64 ptr"] =
gf[
"unsigned long long ptr"];
3636 gf[
"nullptr_t"] = (
cf_t)+[](
cdims_t) {
static NullptrConverter
c{};
return &
c;};
3637 gf[
"const char*"] = (
cf_t)+[](
cdims_t) {
return new CStringConverter{}; };
3638 gf[
"const signed char*"] =
gf[
"const char*"];
3639 gf[
"const char*&&"] =
gf[
"const char*"];
3640 gf[
"const char[]"] = (
cf_t)+[](
cdims_t) {
return new CStringConverter{}; };
3642 gf[
"char[]"] = (
cf_t)+[](
cdims_t d) {
return new NonConstCStringArrayConverter{
d,
true}; };
3643 gf[
"signed char*"] =
gf[
"char*"];
3644 gf[
"wchar_t*"] = (
cf_t)+[](
cdims_t) {
return new WCStringConverter{}; };
3645 gf[
"char16_t*"] = (
cf_t)+[](
cdims_t) {
return new CString16Converter{}; };
3647 gf[
"char32_t*"] = (
cf_t)+[](
cdims_t) {
return new CString32Converter{}; };
3650 gf[
"char16_t**"] =
gf[
"char16_t*"];
3651 gf[
"char32_t**"] =
gf[
"char32_t*"];
3653 gf[
"char**"] =
gf[
"const char**"];
3654 gf[
"const char*[]"] = (
cf_t)+[](
cdims_t d) {
return new CStringArrayConverter{
d,
false}; };
3655 gf[
"char*[]"] = (
cf_t)+[](
cdims_t d) {
return new NonConstCStringArrayConverter{
d,
false}; };
3656 gf[
"char ptr"] =
gf[
"char*[]"];
3657 gf[
"std::string"] = (
cf_t)+[](
cdims_t) {
return new STLStringConverter{}; };
3658 gf[
"const std::string&"] =
gf[
"std::string"];
3659 gf[
"string"] =
gf[
"std::string"];
3660 gf[
"const string&"] =
gf[
"std::string"];
3661 gf[
"std::string&&"] = (
cf_t)+[](
cdims_t) {
return new STLStringMoveConverter{}; };
3662 gf[
"string&&"] =
gf[
"std::string&&"];
3663#if (__cplusplus > 201402L) || (defined(_MSC_VER) && _MSVC_LANG > 201402L)
3666 gf[
"std::string_view&"] =
gf[
"std::string_view"];
3667 gf[
"const std::string_view&"] =
gf[
"std::string_view"];
3670 gf[
"std::wstring"] = (
cf_t)+[](
cdims_t) {
return new STLWStringConverter{}; };
3673 gf[
"const std::wstring&"] =
gf[
"std::wstring"];
3676 gf[
"void*&"] = (
cf_t)+[](
cdims_t) {
static VoidPtrRefConverter
c{};
return &
c; };
3677 gf[
"void**"] = (
cf_t)+[](
cdims_t d) {
return new VoidPtrPtrConverter{
d}; };
3678 gf[
"void ptr"] =
gf[
"void**"];
3679 gf[
"PyObject*"] = (
cf_t)+[](
cdims_t) {
static PyObjectConverter
c{};
return &
c; };
3680 gf[
"_object*"] =
gf[
"PyObject*"];
static Py_ssize_t CPyCppyy_PyUnicode_AsWideChar(PyObject *pyobj, wchar_t *w, Py_ssize_t size)
#define PyBytes_AS_STRING
#define PyBytes_AsStringAndSize
#define CPyCppyy_PyText_FromStringAndSize
#define CPyCppyy_PyUnicode_GET_SIZE
#define PY_SSIZE_T_FORMAT
static void * CPyCppyy_PyCapsule_GetPointer(PyObject *capsule, const char *)
#define CPyCppyy_PyText_AsString
#define CPyCppyy_PyText_GET_SIZE
#define CPyCppyy_PyCapsule_CheckExact
static PyObject * PyObject_CallMethodOneArg(PyObject *obj, PyObject *name, PyObject *arg)
static const char * CPyCppyy_PyText_AsStringAndSize(PyObject *pystr, Py_ssize_t *size)
static PyObject * PyObject_CallMethodNoArgs(PyObject *obj, PyObject *name)
#define CPyCppyy_PyText_FromString
#define CPyCppyy_PyText_Check
static bool StrictBool(PyObject *pyobject, CPyCppyy::CallContext *ctxt)
static unsigned short CPyCppyy_PyLong_AsUShort(PyObject *pyobject)
static int32_t CPyCppyy_PyLong_AsInt32(PyObject *pyobject)
static std::array< PyTypeObject *, 27 > gCTypesTypes
static std::map< void *, PyObject ** > sWrapperReference
static bool CPyCppyy_PyLong_AsBool(PyObject *pyobject)
static bool IsPyCArgObject(PyObject *pyobject)
static PyObject * WrapperCacheEraser(PyObject *, PyObject *pyref)
static bool CPyCppyy_PyUnicodeAsBytes2Buffer(PyObject *pyobject, T &buffer)
#define CPPYY_IMPL_STRING_AS_PRIMITIVE_CONVERTER(name, type, F1, F2)
#define CPPYY_IMPL_BASIC_CHAR_CONVERTER(name, type, low, high)
static std::array< PyTypeObject *, 27 > gCTypesPtrTypes
#define CPPYY_IMPL_BASIC_CONST_CHAR_REFCONVERTER(name, type, ctype, low, high)
static bool SetLifeLine(PyObject *holder, PyObject *target, intptr_t ref)
static PY_LONG_LONG CPyCppyy_PyLong_AsStrictLongLong(PyObject *pyobject)
static std::map< RetSigKey_t, std::map< PyObject *, void * > > sWrapperLookup
static bool ImplicitBool(PyObject *pyobject, CPyCppyy::CallContext *ctxt)
static bool CArraySetArg(PyObject *pyobject, CPyCppyy::Parameter ¶, char tc, int size, bool check=true)
static int ExtractChar(PyObject *pyobject, const char *tname, int low, int high)
static bool HasLifeLine(PyObject *holder, intptr_t ref)
static uint32_t CPyCppyy_PyLong_AsUInt32(PyObject *pyobject)
const Py_ssize_t MOVE_REFCOUNT_CUTOFF
static PyTypeObject * GetCTypesPtrType(int nidx)
static std::map< PyObject *, std::pair< void *, RetSigKey_t > > sWrapperWeakRefs
#define CPYCPPYY_WIDESTRING_CONVERTER(name, type, encode, decode, snull)
static int8_t CPyCppyy_PyLong_AsInt8(PyObject *pyobject)
#define CPPYY_IMPL_BASIC_CONVERTER_IB(name, type, stype, ctype, F1, F2, tc)
static CPyCppyy::Converter * selectInstanceCnv(Cppyy::TCppScope_t klass, const std::string &cpd, CPyCppyy::cdims_t dims, bool isConst, bool control)
static CPyCppyy::CPPInstance * GetCppInstance(PyObject *pyobject, Cppyy::TCppType_t klass=(Cppyy::TCppType_t) 0, bool accept_rvalue=false)
static PyMethodDef gWrapperCacheEraserMethodDef
#define CPPYY_IMPL_BASIC_CONST_REFCONVERTER(name, type, ctype, F1)
static std::array< const char *, 27 > gCTypesNames
static uint8_t CPyCppyy_PyLong_AsUInt8(PyObject *pyobject)
static short CPyCppyy_PyLong_AsShort(PyObject *pyobject)
static long CPyCppyy_PyLong_AsStrictLong(PyObject *pyobject)
#define CPPYY_IMPL_ARRAY_CONVERTER(name, ctype, type, code, suffix)
#define CPPYY_IMPL_BASIC_CONVERTER_NB(name, type, stype, ctype, F1, F2, tc)
#define CPPYY_IMPL_REFCONVERTER(name, ctype, type, code)
#define CPPYY_IMPL_BASIC_CONVERTER_NI(name, type, stype, ctype, F1, F2, tc)
static PyTypeObject * GetCTypesType(int nidx)
bool PyUnstable_Object_IsUniqueReferencedTemporary(PyObject *pyobject)
static CPyCppyy::CPPInstance * ConvertImplicit(Cppyy::TCppType_t klass, PyObject *pyobject, CPyCppyy::Parameter ¶, CPyCppyy::CallContext *ctxt, bool manage=true)
static int CPyCppyy_PyLong_AsStrictInt(PyObject *pyobject)
static int16_t CPyCppyy_PyLong_AsInt16(PyObject *pyobject)
static std::map< RetSigKey_t, std::vector< void * > > sWrapperFree
static bool IsCTypesArrayOrPointer(PyObject *pyobject)
static unsigned int sWrapperCounter
static uint16_t CPyCppyy_PyLong_AsUInt16(PyObject *pyobject)
#define CPPYY_PYLONG_AS_TYPE(name, type, limit_low, limit_high)
static void * PyFunction_AsCPointer(PyObject *pyobject, const std::string &rettype, const std::string &signature)
#define CPPYY_IMPL_REFCONVERTER_FROM_MEMORY(name, ctype)
unsigned long long PY_ULONG_LONG
std::string fValueTypeName
Cppyy::TCppType_t fValueType
Cppyy::TCppType_t fSmartPtrType
Cppyy::TCppType_t fUnderlyingType
std::string::size_type fMaxSize
std::vector< Converter * > fConverters
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t target
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t UChar_t len
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
virtual bool SetArg(PyObject *, Parameter &, CallContext *=nullptr)=0
virtual bool ToMemory(PyObject *value, void *address, PyObject *ctxt=nullptr)
virtual PyObject * FromMemory(void *address)
bool ToMemory(PyObject *value, void *address, PyObject *ctxt=nullptr) override
bool SetArg(PyObject *, Parameter &, CallContext *=nullptr) override
PyObject * FromMemory(void *address) override
static bool RegisterPyObject(CPPInstance *pyobj, void *cppobj)
PyObject * FromMemory(void *address) override
virtual bool GetAddressSpecialCase(PyObject *pyobject, void *&address)
bool ToMemory(PyObject *value, void *address, PyObject *ctxt=nullptr) override
bool SetArg(PyObject *, Parameter &, CallContext *=nullptr) override
Internal::TypedIter< T, decltype(std::begin(std::declval< Range_t >())), isDynamic > iterator
const_iterator begin() const
const_iterator end() const
std::string clean_type(const std::string &cppname, bool template_strip=true, bool const_strip=true)
std::string compound(const std::string &name)
std::vector< std::string > extract_arg_types(const std::string &sig)
void ConstructCallbackPreamble(const std::string &retType, const std::vector< std::string > &argtypes, std::ostringstream &code)
void ConstructCallbackReturn(const std::string &retType, int nArgs, std::ostringstream &code)
void RestorePyError(PyError_t &error)
Py_ssize_t GetBuffer(PyObject *pyobject, char tc, int size, void *&buf, bool check=true)
PyObject * FuncPtr2StdFunction(const std::string &retType, const std::string &signature, void *address)
bool IsSTLIterator(const std::string &classname)
unsigned long PyLongOrInt_AsULong(PyObject *pyobject)
Converter *(* cf_t)(cdims_t d)
PyObject * gDefaultObject
PyObject * GetScopeProxy(Cppyy::TCppScope_t)
bool TupleOfInstances_CheckExact(T *object)
PyObject * CreateScopeProxy(Cppyy::TCppScope_t, const unsigned flags=0)
bool RefFloat_CheckExact(T *object)
bool CPPExcInstance_Check(T *object)
bool NoImplicit(CallContext *ctxt)
static ConvFactories_t gConvFactories
PyObject * CreateLowLevelView(bool *, cdims_t shape)
PyObject * BindCppObjectNoCast(Cppyy::TCppObject_t object, Cppyy::TCppType_t klass, const unsigned flags=0)
bool CPPOverload_Check(T *object)
bool RefInt_CheckExact(T *object)
PyObject * CreateLowLevelViewString(char **, cdims_t shape)
bool CPPScope_Check(T *object)
CPYCPPYY_EXTERN bool RegisterConverter(const std::string &name, ConverterFactory_t)
static const dim_t UNKNOWN_SIZE
static std::regex s_fnptr("\\((\\w*:*)*\\*&*\\)")
bool AllowImplicit(CallContext *ctxt)
bool UseStrictOwnership(CallContext *ctxt)
PY_ULONG_LONG PyLongOrInt_AsULong64(PyObject *pyobject)
bool CPPInstance_Check(T *object)
PyObject * BindCppObjectArray(Cppyy::TCppObject_t address, Cppyy::TCppType_t klass, cdims_t dims)
PyObject * CreatePointerView(void *ptr, cdims_t shape=0)
PyObject * gNullPtrObject
bool IsConstructor(uint64_t flags)
CPYCPPYY_EXTERN bool RegisterConverterAlias(const std::string &name, const std::string &target)
CPYCPPYY_EXTERN Converter * CreateConverter(const std::string &name, cdims_t=0)
PyObject * BindCppObject(Cppyy::TCppObject_t object, Cppyy::TCppType_t klass, const unsigned flags=0)
CPYCPPYY_EXTERN void DestroyConverter(Converter *p)
bool TemplateProxy_Check(T *object)
std::map< std::string, cf_t > ConvFactories_t
CPYCPPYY_EXTERN bool UnregisterConverter(const std::string &name)
RPY_EXPORTED ptrdiff_t GetBaseOffset(TCppType_t derived, TCppType_t base, TCppObject_t address, int direction, bool rerror=false)
RPY_EXPORTED size_t SizeOf(TCppType_t klass)
RPY_EXPORTED std::vector< TCppIndex_t > GetMethodIndicesFromName(TCppScope_t scope, const std::string &name)
RPY_EXPORTED bool Compile(const std::string &code, bool silent=false)
RPY_EXPORTED void CallDestructor(TCppType_t type, TCppObject_t self)
RPY_EXPORTED bool IsSubtype(TCppType_t derived, TCppType_t base)
RPY_EXPORTED TCppMethod_t GetMethodTemplate(TCppScope_t scope, const std::string &name, const std::string &proto)
RPY_EXPORTED TCppObject_t Construct(TCppType_t type, void *arena=nullptr)
RPY_EXPORTED bool GetSmartPtrInfo(const std::string &, TCppType_t *raw, TCppMethod_t *deref)
RPY_EXPORTED std::string ResolveName(const std::string &cppitem_name)
RPY_EXPORTED TCppMethod_t GetMethod(TCppScope_t scope, TCppIndex_t imeth)
RPY_EXPORTED bool IsSmartPtr(TCppType_t type)
RPY_EXPORTED TCppScope_t GetScope(const std::string &scope_name)
RPY_EXPORTED TCppFuncAddr_t GetFunctionAddress(TCppMethod_t method, bool check_enabled=true)
RooArgList L(Args_t &&... args)
static ECallFlags sMemoryPolicy
PyObject_HEAD char * b_ptr
PyObject_HEAD void * pffi_type
union CPyCppyy_tagPyCArgObject::@199 value