|
ROOT
Reference Guide |
|
Go to the documentation of this file.
76 typedef const void* DeclId_t;
79 CallWrapper(
TFunction*
f) : fDecl(
f->GetDeclId()), fName(
f->GetName()), fTF(
nullptr) {}
80 CallWrapper(DeclId_t fid,
const std::string&
n) : fDecl(fid), fName(
n), fTF(
nullptr) {}
82 if (fTF && fDecl == fTF->GetDeclId())
98 CallWrapper*
wrap =
new CallWrapper(
f);
103 static inline CallWrapper*
new_CallWrapper(CallWrapper::DeclId_t fid,
const std::string&
n)
105 CallWrapper*
wrap =
new CallWrapper(fid,
n);
122 {
"bool",
"char",
"signed char",
"unsigned char",
"wchar_t",
"short",
"unsigned short",
123 "int",
"unsigned int",
"long",
"unsigned long",
"long long",
"unsigned long long",
124 "float",
"double",
"long double",
"void",
125 "allocator",
"array",
"basic_string",
"complex",
"initializer_list",
"less",
"list",
126 "map",
"pair",
"set",
"vector"};
130 {
"auto_ptr",
"std::auto_ptr",
"shared_ptr",
"std::shared_ptr",
131 "unique_ptr",
"std::unique_ptr",
"weak_ptr",
"std::weak_ptr"};
146 const int SIGBUS = 0;
147 const int SIGSYS = 0;
148 const int SIGPIPE = 0;
149 const int SIGQUIT = 0;
150 const int SIGWINCH = 0;
151 const int SIGALRM = 0;
152 const int SIGCHLD = 0;
153 const int SIGURG = 0;
154 const int SIGUSR1 = 0;
155 const int SIGUSR2 = 0;
158 static struct Signalmap_t {
160 const char *fSigName;
162 { SIGBUS,
"bus error" },
163 { SIGSEGV,
"segmentation violation" },
164 { SIGSYS,
"bad argument to system call" },
165 { SIGPIPE,
"write on a pipe with no one to read it" },
166 { SIGILL,
"illegal instruction" },
167 { SIGABRT,
"abort" },
169 { SIGINT,
"interrupt" },
170 { SIGWINCH,
"window size change" },
171 { SIGALRM,
"alarm clock" },
172 { SIGCHLD,
"death of a child" },
173 { SIGURG,
"urgent data arrived on an I/O channel" },
174 { SIGFPE,
"floating point exception" },
175 { SIGTERM,
"termination signal" },
176 { SIGUSR1,
"user-defined signal 1" },
177 { SIGUSR2,
"user-defined signal 2" }
180 static void inline do_trace(
int sig) {
194 if (!getenv(
"CPPYY_CRASH_QUIET"))
206 class ApplicationStarter {
208 ApplicationStarter() {
230 const char* stl_names[] = {
"allocator",
"auto_ptr",
"bad_alloc",
"bad_cast",
231 "bad_exception",
"bad_typeid",
"basic_filebuf",
"basic_fstream",
"basic_ifstream",
232 "basic_ios",
"basic_iostream",
"basic_istream",
"basic_istringstream",
233 "basic_ofstream",
"basic_ostream",
"basic_ostringstream",
"basic_streambuf",
234 "basic_string",
"basic_stringbuf",
"basic_stringstream",
"binary_function",
235 "binary_negate",
"bitset",
"byte",
"char_traits",
"codecvt_byname",
"codecvt",
"collate",
236 "collate_byname",
"compare",
"complex",
"ctype_byname",
"ctype",
"default_delete",
237 "deque",
"divides",
"domain_error",
"equal_to",
"exception",
"forward_list",
"fpos",
238 "function",
"greater_equal",
"greater",
"gslice_array",
"gslice",
"hash",
"indirect_array",
239 "integer_sequence",
"invalid_argument",
"ios_base",
"istream_iterator",
"istreambuf_iterator",
240 "istrstream",
"iterator_traits",
"iterator",
"length_error",
"less_equal",
"less",
241 "list",
"locale",
"localedef utility",
"locale utility",
"logic_error",
"logical_and",
242 "logical_not",
"logical_or",
"map",
"mask_array",
"mem_fun",
"mem_fun_ref",
"messages",
243 "messages_byname",
"minus",
"modulus",
"money_get",
"money_put",
"moneypunct",
244 "moneypunct_byname",
"multimap",
"multiplies",
"multiset",
"negate",
"not_equal_to",
245 "num_get",
"num_put",
"numeric_limits",
"numpunct",
"numpunct_byname",
246 "ostream_iterator",
"ostreambuf_iterator",
"ostrstream",
"out_of_range",
247 "overflow_error",
"pair",
"plus",
"pointer_to_binary_function",
248 "pointer_to_unary_function",
"priority_queue",
"queue",
"range_error",
249 "raw_storage_iterator",
"reverse_iterator",
"runtime_error",
"set",
"shared_ptr",
250 "slice_array",
"slice",
"stack",
"string",
"strstream",
"strstreambuf",
251 "time_get_byname",
"time_get",
"time_put_byname",
"time_put",
"unary_function",
252 "unary_negate",
"unique_ptr",
"underflow_error",
"unordered_map",
"unordered_multimap",
253 "unordered_multiset",
"unordered_set",
"valarray",
"vector",
"weak_ptr",
"wstring"};
254 for (
auto&
name : stl_names)
259 if (getenv(
"CPPYY_OPT_LEVEL")) optLevel = atoi(getenv(
"CPPYY_OPT_LEVEL"));
261 std::ostringstream
s;
262 s <<
"#pragma cling optimize " << optLevel;
268 "#include <iostream>\n"
269 "#include <string>\n"
270 "#include <DllImport.h>\n"
271 "#include <vector>\n"
272 "#include <utility>";
276 if (!getenv(
"ROOTSYS"))
281 "namespace __cppyy_internal { template<class C1, class C2>"
282 " bool is_equal(const C1& c1, const C2& c2) { return (bool)(c1 == c2); } }");
284 "namespace __cppyy_internal { template<class C1, class C2>"
285 " bool is_not_equal(const C1& c1, const C2& c2) { return (bool)(c1 != c2); } }");
288 if (!getenv(
"CPPYY_NO_ROOT_FILTER")) {
289 gROOT->GetListOfGlobals(
true);
290 gROOT->GetListOfGlobalFunctions(
true);
291 std::set<std::string> initial;
304 gRootSOs.insert(
"libMathCore.dll ");
315 ~ApplicationStarter() {
320 } _applicationStarter;
329 assert((ClassRefs_t::size_type)scope <
g_classrefs.size());
335 CallWrapper*
wrap = ((CallWrapper*)method);
336 if (!
wrap->fTF ||
wrap->fTF->GetDeclId() !=
wrap->fDecl) {
346 char* cstr = (
char*)
malloc(cppstr.size()+1);
347 memcpy(cstr, cppstr.c_str(), cppstr.size()+1);
352 bool match_name(
const std::string& tname,
const std::string fname)
355 if (fname.rfind(tname, 0) == 0) {
356 if ((tname.size() == fname.size()) ||
357 (tname.size() < fname.size() && fname[tname.size()] ==
'<'))
366 std::string::size_type pos =
name.find(
'<');
367 if (pos != std::string::npos)
386 TCppType_t klass = find_memoized(cppitem_name);
390 std::string tclean = cppitem_name.compare(0, 2,
"::") == 0 ?
391 cppitem_name.substr(2, std::string::npos) : cppitem_name;
395 if (tclean.empty() )
return cppitem_name;
398 if (tclean[tclean.size()-1] ==
']')
399 tclean = tclean.substr(0, tclean.rfind(
'[')) +
"[]";
401 if (tclean.rfind(
"byte", 0) == 0 || tclean.rfind(
"std::byte", 0) == 0)
414 if (cppitem_name.rfind(
"__type_pack_element", 0) != std::string::npos) {
418 const char* str = cppitem_name.c_str();
419 char* endptr =
nullptr;
420 unsigned long index = strtoul(str+20, &endptr, 0);
422 std::string tmplvars{endptr};
423 auto start = tmplvars.find(
',') + 1;
424 auto end = tmplvars.find(
',', start);
427 end = tmplvars.find(
',', start);
428 if (end == std::string::npos) end = tmplvars.rfind(
'>');
432 std::string resolved = tmplvars.substr(start, end-start);
433 auto cpd = tmplvars.rfind(
'>');
434 if (cpd != std::string::npos && cpd+1 != tmplvars.size())
435 return resolved + tmplvars.substr(cpd+1, std::string::npos);
455 if (et_short.find(
"(anonymous") == std::string::npos) {
456 std::ostringstream decl;
458 for (
auto& itype : {
"unsigned int"}) {
459 decl <<
"std::is_same<"
461 <<
", std::underlying_type<"
463 <<
">::type>::value;";
467 std::string resugared;
468 if (et_short.size() != enum_type.size()) {
469 auto pos = enum_type.find(et_short);
470 if (pos != std::string::npos) {
471 resugared = enum_type.substr(0, pos) + itype;
472 if (pos+et_short.size() < enum_type.size())
473 resugared += enum_type.substr(pos+et_short.size(), std::string::npos);
476 if (resugared.empty()) resugared = itype;
484 int ipos = (
int)enum_type.size()-1;
485 for (; 0 <= ipos; --ipos) {
486 char c = enum_type[ipos];
487 if (isspace(
c))
continue;
488 if (isalnum(
c) ||
c ==
'_' ||
c ==
'>' ||
c ==
')')
break;
490 bool isConst = enum_type.find(
"const ", 6) != std::string::npos;
491 std::string restype = isConst ?
"const " :
"";
492 restype +=
"internal_enum_type_t"+enum_type.substr((std::string::size_type)ipos+1, std::string::npos);
501 if (result)
return result;
511 bool bHasAlias = sname != scope_name;
513 result = find_memoized(scope_name);
514 if (result)
return result;
519 if (b_scope_name_missclassified) {
520 result = find_memoized(
"std::"+scope_name);
524 if (b_sname_missclassified) {
525 if (!result) result = find_memoized(
"std::"+sname);
529 if (result)
return result;
545 if (b_scope_name_missclassified)
547 if (b_sname_missclassified)
555 return (
bool)
gInterpreter->CheckClassTemplate(template_name.c_str());
561 virtual ~AutoCastRTTI() {}
568 if (!cr.
GetClass() || !obj)
return klass;
575 volatile const char* raw =
nullptr;
578 AutoCastRTTI* pcst = (AutoCastRTTI*)obj;
579 raw =
typeid(*pcst).raw_name();
582 void* vfptr = *(
void**)((intptr_t)obj);
583 void* meta = (
void*)((intptr_t)*((
void**)((intptr_t)vfptr-
sizeof(
void*))));
584 if (*(intptr_t*)meta == 2) {
586 void* ptdescr = (
void*)((intptr_t)meta + 4*
sizeof(
unsigned long)+
sizeof(
void*));
587 if (ptdescr && *(
void**)ptdescr) {
588 auto rtti = *(std::type_info**)ptdescr;
589 raw = rtti->raw_name();
590 if (raw && raw[0] !=
'\0')
600 if (!raw || raw[0] ==
'\0')
602 }
catch (std::bad_typeid) {
608 if (clActual && clActual != cr.
GetClass()) {
629 if (dt)
return dt->
Size();
651 ClassInfo_t* ci =
gInterpreter->ClassInfo_Factory(type_name.c_str());
704 CallWrapper*
wrap = (CallWrapper*)method;
711 if (!(callf &&
gInterpreter->CallFunc_IsValid(callf))) {
717 std::cerr <<
"TODO: report unresolved function error to Python\n";
731 return wrap->fFaceptr;
737 bool runRelease =
false;
738 for (
size_t i = 0; i < nargs; ++i) {
739 switch (args[i].fTypeCode) {
746 vargs[i] = args[i].
fRef;
749 vargs[i] = (
void*)&args[i].fValue.fVoidp;
758 for (
size_t i = 0; i < nargs; ++i) {
759 if (args[i].fTypeCode ==
'X')
760 free(args[i].fValue.fVoidp);
768 CallWrapper*
wrap = (CallWrapper*)method;
774 bool runRelease =
false;
777 if (nargs) runRelease =
copy_args(args, nargs, smallbuf);
778 faceptr.
fGeneric(
self, (
int)nargs, smallbuf, result);
780 std::vector<void*> buf(nargs);
781 runRelease =
copy_args(args, nargs, buf.data());
782 faceptr.
fGeneric(
self, (
int)nargs, buf.data(), result);
789 bool runRelease =
false;
792 if (nargs) runRelease =
copy_args(args, nargs, (
void**)smallbuf);
793 faceptr.
fCtor((
void**)smallbuf, result, (
unsigned long)nargs);
795 std::vector<void*> buf(nargs);
796 runRelease =
copy_args(args, nargs, buf.data());
797 faceptr.
fCtor(buf.data(), result, (
unsigned long)nargs);
804 std::cerr <<
" DESTRUCTOR NOT IMPLEMENTED YET! " << std::endl;
816 if (
WrapperCall(method, nargs, args, (
void*)
self, &t))
821 #define CPPYY_IMP_CALL(typecode, rtype) \
822 rtype Cppyy::Call##typecode(TCppMethod_t method, TCppObject_t self, size_t nargs, void* args)\
824 return CallT<rtype>(method, self, nargs, args); \
829 if (!
WrapperCall(method, nargs, args, (
void*)
self,
nullptr))
854 char* cstr =
nullptr;
856 std::string* cppresult = (std::string*)
malloc(
sizeof(std::string));
857 if (
WrapperCall(method, nargs, args,
self, (
void*)cppresult)) {
859 *length = cppresult->size();
860 cppresult->std::string::~basic_string();
863 free((
void*)cppresult);
871 if (
WrapperCall(method, nargs, args,
nullptr, &obj))
945 if (type_name.empty())
return false;
947 if (tn_short.empty())
return false;
948 return gInterpreter->ClassInfo_IsEnum(tn_short.c_str());
957 for (std::string::size_type pos = 0; pos <
name.size(); ++pos) {
958 std::string::value_type
c =
name[pos];
967 else if (tpl_open == 0 && \
968 c ==
':' && pos+1 <
name.size() &&
name[pos+1] ==
':') {
970 return name.substr(0, pos-1);
982 std::string::size_type first_scope =
name.find(
':');
983 if (first_scope == std::string::npos)
984 return name.substr(0,
name.find(
'<'));
985 std::string::size_type first_templ =
name.find(
'<');
986 if (first_templ == std::string::npos)
987 return name.substr(0, first_scope);
988 return name.substr(0, std::min(first_templ, first_scope));
991 #define FILL_COLL(type, filter) { \
993 type* obj = nullptr; \
994 while ((obj = (type*)itr.Next())) { \
995 const char* nm = obj->GetName(); \
996 if (nm && nm[0] != '_' && !(obj->Property() & (filter))) { \
997 if (gInitialNames.find(nm) == gInitialNames.end()) \
998 cppnames.insert(nm); \
1003 std::set<std::string>& cppnames,
const char*
name,
bool nofilter =
false)
1005 if (!
name ||
name[0] ==
'_' || strstr(
name,
".h") != 0 || strncmp(
name,
"operator", 8) == 0)
1013 if (strncmp(
name,
"std::", 5) == 0) {
1016 if (strncmp(
name,
"__1::", 5) == 0)
name += 5;
1022 if (strncmp(
name, ns_scope.c_str(), ns_scope.size()) == 0)
1044 while ((ev = (
TEnvRec*)itr.Next())) {
1061 coll =
gROOT->GetListOfTypes();
1078 while ((obj = (
TFunction*)itr.Next())) {
1081 if (
nm &&
nm[0] !=
'_' && strstr(
nm,
"<") == 0 && strncmp(
nm,
"operator", 8) != 0) {
1083 cppnames.insert(
nm);
1095 coll =
gROOT->GetListOfGlobals();
1121 std::vector<Cppyy::TCppScope_t> res;
1137 res.reserve(
v.size());
1138 for (
auto uid :
v) {
1140 if (uscope) res.push_back(uscope);
1153 std::string clName = cr->
GetName();
1155 std::string::size_type pos = clName.substr(0, clName.find(
'<')).rfind(
"::");
1156 if (pos != std::string::npos)
1157 return clName.substr(pos+2, std::string::npos);
1169 return std::string(
"std::")+cr->
GetName();
1199 else if (nbases == 0)
1229 if (derived == base)
1239 const std::string& tn = cr->
GetName();
1250 if (!raw && !deref)
return true;
1263 return (!deref || *deref) && (!raw || *raw);
1282 if (derived == base || !(base && derived))
1283 return (ptrdiff_t)0;
1289 return (ptrdiff_t)0;
1291 ptrdiff_t offset = -1;
1298 std::ostringstream msg;
1299 msg <<
"failed offset calculation between " << cb->
GetName() <<
" and " << cd->
GetName();
1302 std::cerr <<
"Warning: " << msg.str() <<
'\n';
1306 return rerror ? (ptrdiff_t)offset : 0;
1312 return rerror ? (ptrdiff_t)offset : 0;
1314 return (ptrdiff_t)(direction < 0 ? -offset : offset);
1329 if (clName.find(
'<') != std::string::npos) {
1332 if (clName.find(
"std::", 0, 5) == std::string::npos && \
1335 clName =
"std::" + clName;
1337 std::ostringstream stmt;
1338 stmt <<
"template class " << clName <<
";";
1354 std::vector<TCppIndex_t> indices;
1402 const std::string&
name = ((CallWrapper*)method)->fName;
1404 if (
name.compare(0, 8,
"operator") != 0)
1406 return name.substr(0,
name.find(
'<'));
1415 std::string
name = ((CallWrapper*)method)->fName;
1434 return "constructor";
1435 std::string restype =
f->GetReturnTypeName();
1439 if (restype.find(
"int8_t") != std::string::npos)
1441 restype =
f->GetReturnTypeNormalizedName();
1442 if (restype ==
"(lambda)") {
1443 std::ostringstream
s;
1445 s <<
"__cling_internal::FT<decltype("
1448 if (i != 0)
s <<
", ";
1514 std::ostringstream sig;
1516 int nArgs =
f->GetNargs();
1517 if (maxargs != (
TCppIndex_t)-1) nArgs = std::min(nArgs, (
int)maxargs);
1518 for (
int iarg = 0; iarg < nArgs; ++iarg) {
1521 if (show_formalargs) {
1522 const char* argname = arg->
GetName();
1523 if (argname && argname[0] !=
'\0') sig <<
" " << argname;
1525 if (defvalue && defvalue[0] !=
'\0') sig <<
" = " << defvalue;
1527 if (iarg != nArgs-1) sig << (show_formalargs ?
", " :
",");
1540 std::ostringstream sig;
1541 sig <<
f->GetReturnTypeName() <<
" "
1542 << scName <<
"::" <<
f->GetName();
1578 return ((
THashList*)
gROOT->GetListOfFunctionTemplates())->At((
int)imeth)->GetName();
1586 assert(!
"should not be called unless GetNumTemplatedMethods() succeeded");
1607 return (
bool)
gROOT->GetFunctionTemplate(
name.c_str());
1623 if (
f && strstr(
f->GetName(),
"<"))
return true;
1628 if (((CallWrapper*)idx)->fName.find(
'<') != std::string::npos)
return true;
1649 TFunction* func =
nullptr; ClassInfo_t* cl =
nullptr;
1651 func =
gROOT->GetGlobalFunctionWithPrototype(
name.c_str(),
proto.c_str());
1697 if (
name.back() ==
'>') {
1698 auto pos =
name.find(
'<');
1699 if (pos != std::string::npos) {
1704 if (
name.size() < alt.size() && alt.find(
'<') == pos) {
1705 const std::string& partial =
name.substr(pos,
name.size()-1-pos);
1706 if (strncmp(partial.c_str(), alt.substr(pos, alt.size()-1-pos).c_str(), partial.size()) == 0)
1718 TCppType_t scope,
const std::string& lc,
const std::string& rc,
const std::string& opname)
1725 std::string
proto = lcname +
"&" + (rc.empty() ? rc : (
", " + rcname +
"&"));
1729 proto = lcname + (rc.empty() ? rc : (
", " + rcname));
1730 func =
gROOT->GetGlobalFunctionWithPrototype(opname.c_str(),
proto.c_str());
1737 proto = lcname + (rc.empty() ? rc : (
", " + rcname));
1818 if ((
int)idata < numDMs)
1828 return m->GetName();
1842 fullType.append(
"*");
1844 std::ostringstream
s;
1846 fullType.append(
s.str());
1858 std::string fullType =
m->GetFullTypeName();
1859 if (fullType !=
m->GetTrueTypeName()) {
1860 const std::string& trueName =
m->GetTrueTypeName();
1861 if (fullType.find(
"::") == std::string::npos && trueName.find(
"::") != std::string::npos)
1862 fullType = trueName;
1865 if ((
int)
m->GetArrayDim() > 1 || (!
m->IsBasic() &&
m->IsaPointer()))
1866 fullType.append(
"*");
1867 else if ((
int)
m->GetArrayDim() == 1) {
1868 std::ostringstream
s;
1869 s <<
'[' <<
m->GetMaxIndex(0) <<
']' << std::ends;
1870 fullType.append(
s.str());
1884 intptr_t addr = (intptr_t)
gInterpreter->ProcessLine((std::string(
"&")+gbl->
GetName()+
";").c_str());
1899 if (strchr(cr->
GetName(),
'<'))
1901 if ((intptr_t)
m->GetOffsetCint() == (intptr_t)-1)
1902 return (intptr_t)
gInterpreter->ProcessLine((std::string(
"&")+cr->
GetName()+
"::"+
m->GetName()+
";").c_str());
1904 return (intptr_t)
m->GetOffsetCint();
1908 return (intptr_t)-1;
1915 if (!gb) gb = (
TGlobal*)
gROOT->GetListOfGlobals(
true )->FindObject(
name.c_str());
1921 DataMemberInfo_t* t =
gInterpreter->DataMemberInfo_Factory(did,
nullptr);
1932 std::ostringstream
s;
1933 s <<
"auto __cppyy_internal_wrap_" <<
name <<
" = "
1934 "new __cling_internal::FT<decltype(" <<
name <<
")>::F"
1935 "{" <<
name <<
"};";
1938 (
"__cppyy_internal_wrap_"+
name).c_str());
2032 std::string ti =
m->GetTypeName();
2035 if (ti.rfind(
"(anonymous)") != std::string::npos)
2040 if (ti.rfind(cr->
GetName(), 0) != std::string::npos) {
2041 std::string::size_type
s = strlen(cr->
GetName())+2;
2042 if (
s < ti.size()) {
2063 return m->GetMaxIndex(dimension);
2095 return (
long long)ecst->
GetValue();
2157 #define CPPYY_HANDLE_EXCEPTION \
2158 catch (std::exception& e) { \
2159 cppyy_exctype_t* etype = (cppyy_exctype_t*)((Parameter*)args+nargs); \
2160 *etype = (cppyy_exctype_t)2; \
2161 *((char**)(etype+1)) = cppstring_to_cstring(e.what()); \
2164 cppyy_exctype_t* etype = (cppyy_exctype_t*)((Parameter*)args+nargs); \
2165 *etype = (cppyy_exctype_t)1; \
2166 *((char**)(etype+1)) = \
2167 cppstring_to_cstring("unhandled, unknown C++ exception"); \
2178 return (
unsigned char)
Cppyy::CallB(method, (
void*)
self, nargs, args);
2180 return (
unsigned char)-1;
2185 return (
char)
Cppyy::CallC(method, (
void*)
self, nargs, args);
2192 return (
short)
Cppyy::CallH(method, (
void*)
self, nargs, args);
2199 return (
int)
Cppyy::CallI(method, (
void*)
self, nargs, args);
2206 return (
long)
Cppyy::CallL(method, (
void*)
self, nargs, args);
2213 return (
long long)
Cppyy::CallLL(method, (
void*)
self, nargs, args);
2215 return (
long long)-1;
2220 return (
float)
Cppyy::CallF(method, (
void*)
self, nargs, args);
2227 return (
double)
Cppyy::CallD(method, (
void*)
self, nargs, args);
2234 return (
long double)
Cppyy::CallLD(method, (
void*)
self, nargs, args);
2236 return (
long double)-1;
2245 return (
void*)
Cppyy::CallR(method, (
void*)
self, nargs, args);
2247 return (
void*)
nullptr;
2253 return Cppyy::CallS(method, (
void*)
self, nargs, args, lsz);
2255 return (
char*)
nullptr;
2320 std::set<std::string> cppnames;
2322 const char** c_cppnames = (
const char**)
malloc(cppnames.size()*
sizeof(
const char*));
2324 for (
const auto&
name : cppnames) {
2328 *count = cppnames.size();
2341 for (
int i = 0; i < (
int)uv.size(); ++i) llresult[i] = uv[i];
2408 for (
int i = 0; i < (
int)result.size(); ++i) llresult[i] = result[i];
2409 llresult[result.size()] = -1;
2574 return (
void*)(result == 0 || result == 1 );
2577 #if defined(_MSC_VER)
2579 return _strtoi64(str, NULL, 0);
2584 return _strtoui64(str, NULL, 0);
2589 return strtoll(str, NULL, 0);
2594 return strtoull(str, NULL, 0);
2608 *lsz = ((std::string*)ptr)->size();
2609 return ((std::string*)ptr)->data();
2617 return (
double)*(
long double*)p;
2621 *(
long double*)p =
d;
2625 return (
int)(*(std::vector<bool>*)ptr)[idx];
2629 (*(std::vector<bool>*)ptr)[idx] = (
bool)value;
RPY_EXPORTED TCppIndex_t GetNumTemplatedMethods(TCppScope_t scope)
int cppyy_is_enum(const char *type_name)
const TEnumConstant * GetConstant(const char *name) const
int cppyy_compile(const char *code)
char * cppyy_datamember_name(cppyy_scope_t scope, int datamember_index)
int cppyy_method_num_args(cppyy_method_t method)
RPY_EXPORTED bool IsStaticData(TCppScope_t scope, TCppIndex_t idata)
static CallWrapper * new_CallWrapper(TFunction *f)
RPY_EXPORTED void CallV(TCppMethod_t method, TCppObject_t self, size_t nargs, void *args)
RPY_EXPORTED std::string GetMethodFullName(TCppMethod_t)
const TList * GetListOfAllPublicMethods(Bool_t load=kTRUE)
Returns a list of all public methods of this class and its base classes.
static bool copy_args(Parameter *args, size_t nargs, void **vargs)
const char * GetName() const
Returns name of object.
char * cppyy_resolve_enum(const char *enum_type)
char * cppyy_scoped_final_name(cppyy_type_t type)
RPY_EXPORTED bool IsEnumData(TCppScope_t scope, TCppIndex_t idata)
RPY_EXPORTED std::string ResolveEnum(const std::string &enum_type)
cppyy_scope_t * cppyy_get_using_namespaces(cppyy_scope_t scope)
ptrdiff_t cppyy_base_offset(cppyy_type_t derived, cppyy_type_t base, cppyy_object_t address, int direction)
std::string GetTypeNormalizedName() const
Get the normalized name of the return type.
RPY_EXPORTED TCppIndex_t GetDatamemberIndex(TCppScope_t scope, const std::string &name)
void * cppyy_allocate_function_args(int nargs)
size_t cppyy_function_arg_sizeof()
void cppyy_vectorbool_setitem(cppyy_object_t ptr, int idx, int value)
RPY_EXPORTED std::string GetDatamemberType(TCppScope_t scope, TCppIndex_t idata)
TClass * GetActualClass(const void *object) const
Return a pointer the the real class of the object.
Long64_t GetValue() const
const char * GetFullTypeName() const
Get full type description of typedef, e,g.: "class TDirectory*".
RPY_EXPORTED TCppMethod_t GetMethodTemplate(TCppScope_t scope, const std::string &name, const std::string &proto)
static GlobalVars_t g_globalvars
void(* DelFunc_t)(void *)
RPY_EXPORTED bool Compile(const std::string &code)
virtual TObject * FindObject(const char *name) const
Find an object in this list using its name.
RPY_EXPORTED std::string GetMethodArgType(TCppMethod_t, TCppIndex_t iarg)
virtual const char * GetFullTypeName() const
Get full type description of global variable, e,g.: "class TDirectory*".
int cppyy_is_protecteddata(cppyy_type_t type, cppyy_index_t datamember_index)
std::vector< TGlobal * > GlobalVars_t
cppyy_type_t cppyy_actual_class(cppyy_type_t klass, cppyy_object_t obj)
int cppyy_is_abstract(cppyy_type_t type)
RPY_EXPORTED bool GetSmartPtrInfo(const std::string &, TCppType_t *raw, TCppMethod_t *deref)
virtual Int_t GetMaxIndex(Int_t dim) const
Return maximum index for array dimension "dim".
virtual void StackTrace()
Print a stack trace.
Long_t Property() const
Returns the properties of the TClass as a bit field stored as a Long_t value.
std::string ShortType(const char *typeDesc, int mode)
Return the absolute type of typeDesc.
RPY_EXPORTED size_t SizeOf(TCppType_t klass)
cppyy_object_t cppyy_stdstring2stdstring(cppyy_object_t ptr)
Each ROOT method (see TMethod) has a linked list of its arguments.
static uint64_t sum(uint64_t i)
char * cppyy_datamember_type(cppyy_scope_t scope, int datamember_index)
static void release_args(Parameter *args, size_t nargs)
virtual Long_t Property() const
Get property description word. For meaning of bits see EProperty.
RPY_EXPORTED TCppFuncAddr_t GetFunctionAddress(TCppMethod_t method, bool check_enabled=true)
unsigned long cppyy_exctype_t
unsigned char cppyy_call_b(cppyy_method_t method, cppyy_object_t self, int nargs, void *args)
char cppyy_call_c(cppyy_method_t method, cppyy_object_t self, int nargs, void *args)
static std::map< Cppyy::TCppType_t, bool > sHasOperatorDelete
RPY_EXPORTED bool IsStaticMethod(TCppMethod_t method)
char * cppyy_get_templated_method_name(cppyy_scope_t scope, cppyy_index_t imeth)
TList * GetListOfFunctionTemplates(Bool_t load=kTRUE)
Return TListOfFunctionTemplates for a class.
long double cppyy_call_ld(cppyy_method_t method, cppyy_object_t self, int nargs, void *args)
RPY_EXPORTED bool IsSubtype(TCppType_t derived, TCppType_t base)
RPY_EXPORTED std::vector< TCppScope_t > GetUsingNamespaces(TCppScope_t)
Long_t ClassProperty() const
Return the C++ property of this class, eg.
Each class (see TClass) has a linked list of its base class(es).
Bool_t IsLoaded() const
Return true if the shared library of this class is currently in the a process's memory.
static constexpr double s
static const ClassRefs_t::size_type GLOBAL_HANDLE
static std::set< std::string > gSmartPtrTypes
RPY_EXPORTED std::string GetMethodArgName(TCppMethod_t, TCppIndex_t iarg)
RPY_EXPORTED TCppIndex_t GetMethodReqArgs(TCppMethod_t)
static TDataMember * GetDataMemberByIndex(TClassRef cr, int idata)
cppyy_index_t * cppyy_method_indices_from_name(cppyy_scope_t scope, const char *name)
virtual Int_t GetArrayDim() const
Return number of array dimensions.
All ROOT classes may have RTTI (run time type identification) support added.
double cppyy_longdouble2double(void *p)
RPY_EXPORTED std::string ResolveName(const std::string &cppitem_name)
int cppyy_is_publicdata(cppyy_type_t type, cppyy_index_t datamember_index)
int cppyy_is_publicmethod(cppyy_method_t method)
RPY_EXPORTED std::string GetTemplatedMethodName(TCppScope_t scope, TCppIndex_t imeth)
cppyy_scope_t cppyy_get_scope(const char *scope_name)
RPY_EXPORTED long CallL(TCppMethod_t method, TCppObject_t self, size_t nargs, void *args)
virtual void HandleException(int sig)=0
int cppyy_is_subtype(cppyy_type_t derived, cppyy_type_t base)
static T CallT(Cppyy::TCppMethod_t method, Cppyy::TCppObject_t self, size_t nargs, void *args)
int cppyy_exists_method_template(cppyy_scope_t scope, const char *name)
static TFunction * m2f(Cppyy::TCppMethod_t method)
RPY_EXPORTED bool IsDestructor(TCppMethod_t method)
cppyy_object_t cppyy_charp2stdstring(const char *str, size_t sz)
int cppyy_is_staticdata(cppyy_type_t type, cppyy_index_t datamember_index)
Long_t Property() const
Get property description word. For meaning of bits see EProperty.
int cppyy_has_virtual_destructor(cppyy_type_t type)
cppyy_object_t cppyy_construct(cppyy_type_t type)
TClass * GetBaseClass(const char *classname)
Return pointer to the base class "classname".
void cppyy_add_smartptr_type(const char *type_name)
TList * GetListOfEnums(Bool_t load=kTRUE)
Return a list containing the TEnums of a class.
Long_t Property() const
Get property description word. For meaning of bits see EProperty.
RPY_EXPORTED void AddSmartPtrType(const std::string &)
RPY_EXPORTED int GetDimensionSize(TCppScope_t scope, TCppIndex_t idata, int dimension)
static void cond_add(Cppyy::TCppScope_t scope, const std::string &ns_scope, std::set< std::string > &cppnames, const char *name, bool nofilter=false)
static Name2ClassRefIndex_t g_name2classrefidx
virtual int Load(const char *module, const char *entry="", Bool_t system=kFALSE)
Load a shared library.
Global variables class (global variables are obtained from CINT).
TFunctionTemplate * GetFunctionTemplate(const char *name)
RPY_EXPORTED std::string GetMethodSignature(TCppMethod_t, bool show_formalargs, TCppIndex_t maxargs=(TCppIndex_t) -1)
RPY_EXPORTED bool IsSmartPtr(TCppType_t type)
double cppyy_call_d(cppyy_method_t method, cppyy_object_t self, int nargs, void *args)
RPY_EXPORTED TCppIndex_t GetMethodNumArgs(TCppMethod_t)
void cppyy_destruct(cppyy_type_t type, cppyy_object_t self)
int cppyy_method_is_template(cppyy_scope_t scope, cppyy_index_t idx)
static std::string outer_no_template(const std::string &name)
int cppyy_is_staticmethod(cppyy_method_t method)
TClass * GetClass() const
TList * GetListOfMethods(Bool_t load=kTRUE)
Return list containing the TMethods of a class.
RPY_EXPORTED bool IsConstData(TCppScope_t scope, TCppIndex_t idata)
intptr_t cppyy_datamember_offset(cppyy_scope_t scope, int datamember_index)
std::vector< TClassRef > ClassRefs_t
void cppyy_destructor(cppyy_type_t klass, cppyy_object_t self)
const char * GetFullTypeName() const
Get full type description of method argument, e.g.: "class TDirectory*".
int cppyy_method_req_args(cppyy_method_t method)
static std::set< std::string > gRootSOs
virtual Int_t IndexOf(const TObject *obj) const
Return index of object in collection.
char * cppyy_method_arg_default(cppyy_method_t method, int arg_index)
RPY_EXPORTED TCppType_t GetActualClass(TCppType_t klass, TCppObject_t obj)
RPY_EXPORTED void GetAllCppNames(TCppScope_t scope, std::set< std::string > &cppnames)
RPY_EXPORTED bool IsProtectedData(TCppScope_t scope, TCppIndex_t idata)
RPY_EXPORTED bool IsBuiltin(const std::string &type_name)
RPY_EXPORTED bool IsConstructor(TCppMethod_t method)
ROOT::DelFunc_t GetDelete() const
Return the wrapper around delete ThiObject.
static bool WrapperCall(Cppyy::TCppMethod_t method, size_t nargs, void *args_, void *self, void *result)
char * cppyy_method_mangled_name(cppyy_method_t method)
static constexpr double L
RPY_EXPORTED std::string GetBaseName(TCppType_t type, TCppIndex_t ibase)
virtual const char * GetName() const
Returns name of object.
RPY_EXPORTED TCppObject_t Allocate(TCppType_t type)
RPY_EXPORTED bool HasVirtualDestructor(TCppType_t type)
RPY_EXPORTED bool IsProtectedMethod(TCppMethod_t method)
RPY_EXPORTED TCppScope_t GetScope(const std::string &scope_name)
virtual TObject * At(Int_t idx) const
Returns the object at position idx. Returns 0 if idx is out of range.
static std::map< std::string, std::string > resolved_enum_types
TMethod * GetMethodWithPrototype(const char *method, const char *proto, Bool_t objectIsConst=kFALSE, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch)
Find the method with a given prototype.
RPY_EXPORTED bool ExistsMethodTemplate(TCppScope_t scope, const std::string &name)
std::string GetReturnTypeNormalizedName() const
Get the normalized name of the return type.
static bool gEnableFastPath
A collection of TDataMember objects designed for fast access given a DeclId_t and for keep track of T...
RPY_EXPORTED std::vector< TCppIndex_t > GetMethodIndicesFromName(TCppScope_t scope, const std::string &name)
void * cppyy_call_r(cppyy_method_t method, cppyy_object_t self, int nargs, void *args)
R__EXTERN void Throw(int code)
If an exception context has been set (using the TRY and RETRY macros) jump back to where it was set.
Long_t Property() const
Get property description word. For meaning of bits see EProperty.
RPY_EXPORTED intptr_t GetDatamemberOffset(TCppScope_t scope, TCppIndex_t idata)
std::string CleanType(const char *typeDesc, int mode=0, const char **tail=0)
Cleanup type description, redundant blanks removed and redundant tail ignored return *tail = pointer ...
Basic data type descriptor (datatype information is obtained from CINT).
RPY_EXPORTED bool IsPublicMethod(TCppMethod_t method)
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
RPY_EXPORTED long long GetEnumDataValue(TCppEnum_t, TCppIndex_t idata)
void * New(ENewType defConstructor=kClassNew, Bool_t quiet=kFALSE) const
Return a pointer to a newly allocated object of this class.
int cppyy_is_const_data(cppyy_scope_t scope, cppyy_index_t idata)
int cppyy_num_datamembers(cppyy_scope_t scope)
TList * GetListOfBases()
Return list containing the TBaseClass(es) of a class.
RPY_EXPORTED bool HasComplexHierarchy(TCppType_t type)
RPY_EXPORTED void * CallR(TCppMethod_t method, TCppObject_t self, size_t nargs, void *args)
char * cppyy_method_result_type(cppyy_method_t method)
static Bool_t Initialized()
Return kTRUE if the TROOT object has been initialized.
static std::set< std::string > g_builtins
char * cppyy_method_signature_max(cppyy_method_t method, int show_formalargs, int maxargs)
The TEnum class implements the enum type.
cppyy_object_t cppyy_call_o(cppyy_method_t method, cppyy_object_t self, int nargs, void *args, cppyy_type_t result_type)
RPY_EXPORTED bool IsTemplate(const std::string &template_name)
char * cppyy_resolve_name(const char *cppitem_name)
RPY_EXPORTED std::string GetMethodArgDefault(TCppMethod_t, TCppIndex_t iarg)
RPY_EXPORTED TCppScope_t gGlobalScope
static std::vector< CallWrapper * > gWrapperHolder
#define CPPYY_HANDLE_EXCEPTION
static TInterpreter::CallFuncIFacePtr_t GetCallFunc(Cppyy::TCppMethod_t method)
int cppyy_is_template(const char *template_name)
TMethod * GetMethod(const char *method, const char *params, Bool_t objectIsConst=kFALSE)
Find the best method (if there is one) matching the parameters.
The TEnumConstant class implements the constants of the enum type.
RPY_EXPORTED bool IsNamespace(TCppScope_t scope)
RPY_EXPORTED unsigned char CallB(TCppMethod_t method, TCppObject_t self, size_t nargs, void *args)
RPY_EXPORTED void CallDestructor(TCppType_t type, TCppObject_t self)
int cppyy_is_const_method(cppyy_method_t method)
char * cppyy_method_prototype(cppyy_scope_t scope, cppyy_method_t method, int show_formalargs)
char * cppyy_final_name(cppyy_type_t type)
const char * GetDefault() const
Get default value of method argument.
RPY_EXPORTED bool IsTemplatedConstructor(TCppScope_t scope, TCppIndex_t imeth)
CPyCppyy::Parameter Parameter
std::map< std::string, ClassRefs_t::size_type > Name2ClassRefIndex_t
SEXP wrap(const TString &s)
char * cppyy_method_full_name(cppyy_method_t method)
virtual void * GetAddress() const
Return address of global.
int cppyy_has_complex_hierarchy(cppyy_type_t type)
char * cppyy_method_arg_name(cppyy_method_t method, int arg_index)
#define CPPYY_IMP_CALL(typecode, rtype)
int cppyy_is_templated_constructor(cppyy_scope_t scope, cppyy_index_t imeth)
void cppyy_free(void *ptr)
static bool match_name(const std::string &tname, const std::string fname)
RPY_EXPORTED std::string GetMethodPrototype(TCppScope_t scope, TCppMethod_t, bool show_formalargs)
int cppyy_datamember_index(cppyy_scope_t scope, const char *name)
RPY_EXPORTED bool IsPublicData(TCppScope_t scope, TCppIndex_t idata)
cppyy_scope_t cppyy_type_t
RPY_EXPORTED TCppObject_t CallO(TCppMethod_t method, TCppObject_t self, size_t nargs, void *args, TCppType_t result_type)
static TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE)
Static method returning pointer to TClass of the specified class name.
cppyy_object_t cppyy_allocate(cppyy_type_t type)
TList * GetListOfUsingDataMembers(Bool_t load=kTRUE)
Return list containing the TDataMembers of using declarations of a class.
ClassInfo_t * GetClassInfo() const
char * cppyy_method_name(cppyy_method_t method)
double cppyy_call_nld(cppyy_method_t method, cppyy_object_t self, int nargs, void *args)
RPY_EXPORTED TCppIndex_t GetNumDatamembers(TCppScope_t scope)
long cppyy_call_l(cppyy_method_t method, cppyy_object_t self, int nargs, void *args)
int cppyy_is_smartptr(cppyy_type_t type)
RPY_EXPORTED void Destruct(TCppType_t type, TCppObject_t instance)
Int_t GetNargs() const
Number of function arguments.
RPY_EXPORTED std::string GetScopedFinalName(TCppType_t type)
RPY_EXPORTED char CallC(TCppMethod_t method, TCppObject_t self, size_t nargs, void *args)
RPY_EXPORTED float CallF(TCppMethod_t method, TCppObject_t self, size_t nargs, void *args)
typedef void((*Func_t)())
static std::map< TDictionary::DeclId_t, CallWrapper * > gMethodTemplates
int cppyy_is_enum_data(cppyy_scope_t scope, cppyy_index_t idata)
Long_t ExtraProperty() const
Get property description word. For meaning of bits see EProperty.
RPY_EXPORTED Long64_t CallLL(TCppMethod_t method, TCppObject_t self, size_t nargs, void *args)
short cppyy_call_h(cppyy_method_t method, cppyy_object_t self, int nargs, void *args)
int cppyy_get_dimension_size(cppyy_scope_t scope, cppyy_index_t idata, int dimension)
RPY_EXPORTED bool IsConstMethod(TCppMethod_t)
void cppyy_double2longdouble(double d, void *p)
cppyy_method_t cppyy_get_method_template(cppyy_scope_t scope, const char *name, const char *proto)
RPY_EXPORTED TCppIndex_t GetNumEnumData(TCppEnum_t)
R__EXTERN TSystem * gSystem
RPY_EXPORTED TCppIndex_t GetNumBases(TCppType_t type)
int cppyy_get_num_templated_methods(cppyy_scope_t scope)
static Roo_reg_AGKInteg1D instance
void cppyy_deallocate(cppyy_type_t type, cppyy_object_t self)
RPY_EXPORTED short CallH(TCppMethod_t method, TCppObject_t self, size_t nargs, void *args)
A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum t...
RPY_EXPORTED int CallI(TCppMethod_t method, TCppObject_t self, size_t nargs, void *args)
size_t cppyy_size_of_klass(cppyy_type_t klass)
RPY_EXPORTED void Deallocate(TCppType_t type, TCppObject_t instance)
static std::set< std::string > gInitialNames
static bool is_missclassified_stl(const std::string &name)
virtual const char * GetMangledName() const
Returns the mangled name as defined by CINT, or 0 in case of error.
R__EXTERN Int_t gErrorIgnoreLevel
RPY_EXPORTED std::string GetFinalName(TCppType_t type)
R__EXTERN TExceptionHandler * gExceptionHandler
cppyy_funcaddr_t cppyy_function_address(cppyy_method_t method)
static char * cppstring_to_cstring(const std::string &cppstr)
RPY_EXPORTED LongDouble_t CallLD(TCppMethod_t method, TCppObject_t self, size_t nargs, void *args)
virtual void Exit(int code, Bool_t mode=kTRUE)
Exit the application.
void cppyy_deallocate_function_args(void *args)
RPY_EXPORTED TCppMethod_t GetMethod(TCppScope_t scope, TCppIndex_t imeth)
int cppyy_is_protectedmethod(cppyy_method_t method)
int cppyy_is_destructor(cppyy_method_t method)
RPY_EXPORTED TCppEnum_t GetEnum(TCppScope_t scope, const std::string &enum_name)
TList * GetListOfDataMembers(Bool_t load=kTRUE)
Return list containing the TDataMembers of a class.
cppyy_method_t cppyy_get_method(cppyy_scope_t scope, cppyy_index_t idx)
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
unsigned long long cppyy_strtoull(const char *str)
void cppyy_call_v(cppyy_method_t method, cppyy_object_t self, int nargs, void *args)
TClass instances represent classes, structs and namespaces in the ROOT type system.
RPY_EXPORTED double CallD(TCppMethod_t method, TCppObject_t self, size_t nargs, void *args)
RPY_EXPORTED bool IsEnum(const std::string &type_name)
int cppyy_call_i(cppyy_method_t method, cppyy_object_t self, int nargs, void *args)
RPY_EXPORTED std::string GetEnumDataName(TCppEnum_t, TCppIndex_t idata)
void Destructor(void *obj, Bool_t dtorOnly=kFALSE)
Explicitly call destructor for object.
static ClassRefs_t g_classrefs(1)
RPY_EXPORTED ptrdiff_t GetBaseOffset(TCppType_t derived, TCppType_t base, TCppObject_t address, int direction, bool rerror=false)
RPY_EXPORTED void DeallocateFunctionArgs(void *args)
RPY_EXPORTED TCppIndex_t GetGlobalOperator(TCppType_t scope, const std::string &lc, const std::string &rc, const std::string &op)
long long cppyy_call_ll(cppyy_method_t method, cppyy_object_t self, int nargs, void *args)
int cppyy_num_bases(cppyy_type_t type)
char * cppyy_method_signature(cppyy_method_t method, int show_formalargs)
RPY_EXPORTED TCppObject_t Construct(TCppType_t type)
union CPyCppyy::Parameter::Value fValue
const char * GetValue() const
RPY_EXPORTED bool IsMethodTemplate(TCppScope_t scope, TCppIndex_t imeth)
RPY_EXPORTED bool IsAbstract(TCppType_t type)
#define FILL_COLL(type, filter)
RPY_EXPORTED std::string GetMethodName(TCppMethod_t)
size_t cppyy_function_arg_typeoffset()
int cppyy_num_methods(cppyy_scope_t scope)
TClassRef is used to implement a permanent reference to a TClass object.
RPY_EXTERN void * cppyy_load_dictionary(const char *lib_name)
std::string ResolveTypedef(const char *tname, bool resolveAll=false)
R__EXTERN ExceptionContext_t * gException
char * cppyy_base_name(cppyy_type_t type, int base_index)
size_t cppyy_size_of_type(const char *type_name)
Collection abstract base class.
float cppyy_call_f(cppyy_method_t method, cppyy_object_t self, int nargs, void *args)
RPY_EXPORTED std::string GetDatamemberName(TCppScope_t scope, TCppIndex_t idata)
RPY_EXPORTED TCppObject_t CallConstructor(TCppMethod_t method, TCppType_t type, size_t nargs, void *args)
RPY_EXPORTED TCppIndex_t GetNumMethods(TCppScope_t scope)
virtual const char * GetName() const
Returns name of object.
cppyy_index_t cppyy_get_global_operator(cppyy_scope_t scope, cppyy_scope_t lc, cppyy_scope_t rc, const char *op)
cppyy_object_t cppyy_constructor(cppyy_method_t method, cppyy_type_t klass, int nargs, void *args)
static constexpr double nm
RPY_EXPORTED std::string GetMethodMangledName(TCppMethod_t)
RPY_EXPORTED std::string GetMethodResultType(TCppMethod_t)
RPY_EXPORTED bool IsComplete(const std::string &type_name)
int cppyy_smartptr_info(const char *name, cppyy_type_t *raw, cppyy_method_t *deref)
static struct Signalmap_t gSignalMap[kMAXSIGNALS]
long long cppyy_strtoll(const char *str)
RPY_EXPORTED size_t GetFunctionArgTypeoffset()
virtual TObject * FindObject(const char *name) const
Find an object in this collection using its name.
int cppyy_is_constructor(cppyy_method_t method)
RPY_EXPORTED size_t GetFunctionArgSizeof()
char * cppyy_call_s(cppyy_method_t method, cppyy_object_t self, int nargs, void *args, size_t *lsz)
RPY_EXPORTED void * AllocateFunctionArgs(size_t nargs)
Global functions class (global functions are obtained from CINT).
int cppyy_vectorbool_getitem(cppyy_object_t ptr, int idx)
static TClassRef & type_from_handle(Cppyy::TCppScope_t scope)
Int_t Size() const
Get size of basic typedef'ed type.
char * cppyy_method_arg_type(cppyy_method_t method, int arg_index)
static std::set< std::string > gSTLNames
static const ClassRefs_t::size_type STD_HANDLE
const char * cppyy_stdstring2charp(cppyy_object_t ptr, size_t *lsz)
const char ** cppyy_get_all_cpp_names(cppyy_scope_t scope, size_t *count)
Dictionary for function template This class describes one single function template.
static std::string outer_with_template(const std::string &name)
RPY_EXPORTED char * CallS(TCppMethod_t method, TCppObject_t self, size_t nargs, void *args, size_t *length)
int cppyy_is_namespace(cppyy_scope_t scope)