59 #include "RConfigure.h" 60 #include "compiledata.h" 75 #include "clang/AST/ASTContext.h" 76 #include "clang/AST/Decl.h" 77 #include "clang/AST/DeclarationName.h" 78 #include "clang/AST/GlobalDecl.h" 79 #include "clang/AST/RecordLayout.h" 80 #include "clang/AST/RecursiveASTVisitor.h" 81 #include "clang/AST/Type.h" 82 #include "clang/Basic/SourceLocation.h" 83 #include "clang/Basic/Specifiers.h" 84 #include "clang/Basic/TargetInfo.h" 85 #include "clang/CodeGen/ModuleBuilder.h" 86 #include "clang/Frontend/CompilerInstance.h" 87 #include "clang/Frontend/FrontendDiagnostic.h" 88 #include "clang/Lex/HeaderSearch.h" 89 #include "clang/Lex/Preprocessor.h" 90 #include "clang/Sema/Lookup.h" 91 #include "clang/Sema/Sema.h" 92 #include "clang/Parse/Parser.h" 94 #include "cling/Interpreter/ClangInternalState.h" 95 #include "cling/Interpreter/DynamicLibraryManager.h" 96 #include "cling/Interpreter/Interpreter.h" 97 #include "cling/Interpreter/LookupHelper.h" 98 #include "cling/Interpreter/Value.h" 99 #include "cling/Interpreter/Transaction.h" 100 #include "cling/MetaProcessor/MetaProcessor.h" 101 #include "cling/Utils/AST.h" 102 #include "cling/Utils/SourceNormalization.h" 103 #include "cling/Interpreter/Exception.h" 105 #include "llvm/IR/GlobalValue.h" 106 #include "llvm/IR/Module.h" 108 #include "llvm/Support/DynamicLibrary.h" 109 #include "llvm/Support/raw_ostream.h" 110 #include "llvm/Support/Path.h" 123 #include <unordered_map> 136 #include <mach-o/dyld.h> 143 #if defined(__CYGWIN__) 144 #include <sys/cygwin.h> 145 #define HMODULE void * 147 __declspec(dllimport)
void * __stdcall GetCurrentProcess();
148 __declspec(dllimport)
bool __stdcall EnumProcessModules(
void *,
void **,
unsigned long,
unsigned long *);
149 __declspec(dllimport)
unsigned long __stdcall GetModuleFileNameExW(
void *,
void *,
wchar_t *,
unsigned long);
154 #if defined(_MSC_VER) 156 # define STDIN_FILENO 0 158 #ifndef STDOUT_FILENO 159 # define STDOUT_FILENO 1 161 #ifndef STDERR_FILENO 162 # define STDERR_FILENO 2 171 #undef GetModuleFileName 172 #define RTLD_DEFAULT ((void *)::GetModuleHandle(NULL)) 173 #define dlsym(library, function_name) ::GetProcAddress((HMODULE)library, function_name) 174 #define dlopen(library_name, flags) ::LoadLibrary(library_name) 175 #define dlclose(library) ::FreeLibrary((HMODULE)library) 176 #define R__DLLEXPORT __declspec(dllexport) 184 class TCling_UnloadMarker {
186 ~TCling_UnloadMarker() {
192 static TCling_UnloadMarker gTClingUnloadMarker;
201 return D->getDeclContext();
204 return llvm::dyn_cast<clang::NamespaceDecl>(DC);
207 return llvm::dyn_cast<clang::RecordDecl>(DC);
210 return DC->dumpDeclContext();
219 return ((clang::Decl*)D)->dump();
222 if (clang::NamedDecl* ND = llvm::dyn_cast<clang::NamedDecl>(D)) {
225 llvm::raw_string_ostream OS(name);
226 ND->getNameForDiagnostic(OS, D->getASTContext().getPrintingPolicy(),
229 printf(
"%s\n", name.c_str());
237 return D->isInvalidDecl();
241 assert(info && info->
IsValid());
242 return info->
GetDecl()->isInvalidDecl();
246 using namespace clang;
247 using namespace ROOT;
250 static const std::string gInterpreterClassDef = R
"ICF( 252 #define ClassDef(name, id) \ 253 _ClassDefInterp_(name,id,virtual,) \ 254 static int DeclFileLine() { return __LINE__; } 256 #define ClassDefNV(name, id) \ 257 _ClassDefInterp_(name,id,,) \ 258 static int DeclFileLine() { return __LINE__; } 259 #undef ClassDefOverride 260 #define ClassDefOverride(name, id) \ 261 _ClassDefInterp_(name,id,,override) \ 262 static int DeclFileLine() { return __LINE__; } 265 static const std::string gNonInterpreterClassDef = R
"ICF( 266 #define __ROOTCLING__ 1 268 #define ClassDef(name,id) \ 269 _ClassDef_(name,id,virtual,) \ 270 static int DeclFileLine() { return __LINE__; } 272 #define ClassDefNV(name, id)\ 273 _ClassDef_(name,id,,)\ 274 static int DeclFileLine() { return __LINE__; } 275 #undef ClassDefOverride 276 #define ClassDefOverride(name, id)\ 277 _ClassDef_(name,id,,override)\ 278 static int DeclFileLine() { return __LINE__; } 282 static const std::string gClassDefInterpMacro = R
"ICF( 287 #define _ClassDefInterp_(name,id,virtual_keyword, overrd) \ 290 static TClass *Class() { static TClass* sIsA = 0; if (!sIsA) sIsA = TClass::GetClass(#name); return sIsA; } \ 291 static const char *Class_Name() { return #name; } \ 292 static Version_t Class_Version() { return id; } \ 293 static TClass *Dictionary() { return 0; } \ 294 virtual_keyword TClass *IsA() const overrd { return name::Class(); } \ 295 virtual_keyword void ShowMembers(TMemberInspector&insp) const overrd { ::ROOT::Class_ShowMembers(name::Class(), this, insp); } \ 296 virtual_keyword void Streamer(TBuffer&) overrd { ::Error("Streamer", "Cannot stream interpreted class."); } \ 297 void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { name::Streamer(ClassDef_StreamerNVirtual_b); } \ 298 static const char *DeclFileName() { return __FILE__; } \ 299 static int ImplFileLine() { return 0; } \ 300 static const char *ImplFileName() { return __FILE__; } 311 class EnumVisitor :
public RecursiveASTVisitor<EnumVisitor> {
313 llvm::SmallVector<EnumDecl*,128> &fClassEnums;
315 EnumVisitor(llvm::SmallVector<EnumDecl*,128> &enums) : fClassEnums(enums)
318 bool TraverseStmt(Stmt*) {
323 bool shouldVisitTemplateInstantiations()
const {
return true; }
325 bool TraverseClassTemplateDecl(ClassTemplateDecl*) {
330 bool TraverseClassTemplatePartialSpecializationDecl(ClassTemplatePartialSpecializationDecl*) {
335 bool VisitEnumDecl(EnumDecl *TEnumD) {
336 if (!TEnumD->getDeclContext()->isDependentContext())
337 fClassEnums.push_back(TEnumD);
356 static vector<const NamedDecl*> updateList;
359 if (entered) topLevel =
kFALSE;
374 updateList.push_back(TD);
377 while (!updateList.empty()) {
379 updateList.pop_back();
386 const clang::Decl* D =
static_cast<const clang::Decl*
>(enumObj->
GetDeclId());
387 if(
const clang::EnumDecl* ED = dyn_cast<clang::EnumDecl>(D)) {
389 for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin(),
390 EDE = ED->enumerator_end(); EDI != EDE; ++EDI) {
392 std::string constbuf;
393 if (
const NamedDecl* END = llvm::dyn_cast<NamedDecl>(*EDI)) {
394 PrintingPolicy Policy((*EDI)->getASTContext().getPrintingPolicy());
395 llvm::raw_string_ostream stream(constbuf);
397 Policy.AnonymousTagLocations =
false;
398 (END)->getNameForDiagnostic(stream, Policy,
false);
400 const char* constantName = constbuf.c_str();
404 const llvm::APSInt valAPSInt = (*EDI)->getInitVal();
405 if (valAPSInt.isSigned()) {
406 value = valAPSInt.getSExtValue();
408 value = valAPSInt.getZExtValue();
415 DataMemberInfo_t* dmInfo = (DataMemberInfo_t*) tcDmInfo;
419 enumConstant =
new TEnumConstant(dmInfo, constantName, value, enumObj);
426 globals->
Add(enumConstant);
439 const clang::Decl* D =
static_cast<const clang::Decl*
>(VD);
441 if (
const EnumDecl* ED = llvm::dyn_cast<EnumDecl>(D)) {
443 PrintingPolicy Policy(ED->getASTContext().getPrintingPolicy());
444 llvm::raw_string_ostream stream(buf);
446 Policy.AnonymousTagLocations =
false;
447 ED->getNameForDiagnostic(stream, Policy,
false);
453 const char*
name = buf.c_str();
454 enumType =
new TEnum(name, VD, cl);
455 UpdateEnumConstants(enumType, cl);
464 const clang::Decl* D =
static_cast<const clang::Decl*
>(DV);
466 if (!D->isCanonicalDecl() && !isa<clang::NamespaceDecl>(D)
467 && !dyn_cast<clang::RecordDecl>(D))
return;
469 if (isa<clang::FunctionDecl>(D->getDeclContext())
470 || isa<clang::TagDecl>(D->getDeclContext()))
474 if (
const clang::CXXRecordDecl* RD = dyn_cast<clang::CXXRecordDecl>(D)) {
475 if (RD->getDescribedClassTemplate())
477 }
else if (
const clang::FunctionDecl* FD = dyn_cast<clang::FunctionDecl>(D)) {
478 if (FD->getDescribedFunctionTemplate())
482 if (
const RecordDecl *TD = dyn_cast<RecordDecl>(D)) {
483 if (TD->isCanonicalDecl() || TD->isThisDeclarationADefinition())
486 else if (
const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
488 if (
const TagDecl *TD = dyn_cast<TagDecl>(D)) {
492 }
else if (
const NamespaceDecl* NSD = dyn_cast<NamespaceDecl>(D)) {
500 if (
const NamespaceDecl* NCtx = dyn_cast<NamespaceDecl>(ND->getDeclContext())) {
501 if (NCtx->getIdentifier()) {
504 std::string NCtxName;
505 PrintingPolicy Policy(NCtx->getASTContext().getPrintingPolicy());
506 llvm::raw_string_ostream stream(NCtxName);
508 Policy.AnonymousTagLocations =
false;
509 NCtx->getNameForDiagnostic(stream, Policy,
true);
513 modifiedTClasses.insert(cl);
520 if (!isa<TranslationUnitDecl>(ND->getDeclContext()))
524 if (isa<EnumDecl>(ND))
529 if (!(isa<VarDecl>(ND)))
533 if (
gROOT->GetListOfGlobals()->FindObject(ND->getNameAsString().c_str()))
537 gROOT->GetListOfGlobals()->Add(
new TGlobal((DataMemberInfo_t *)
539 cast<ValueDecl>(ND), 0)));
566 const char* canonicalName) {
568 ((
TCling*)
gCling)->LibraryLoaded(dyLibHandle, canonicalName);
572 const char* canonicalName) {
574 ((
TCling*)
gCling)->LibraryUnloaded(dyLibHandle, canonicalName);
580 return ((
TCling*)
gCling)->GetObjectAddress(Name, LookupCtx);
589 cling::DynamicLibraryManager::ExposeHiddenSharedLibrarySymbols(interpLibHandle);
590 return new TCling(
"C++",
"cling C++ Interpreter");
612 return ((
TCling*)
gCling)->GetClassSharedLibs(className);
624 return ((
TCling*)
gCling)->IsAutoLoadNamespaceCandidate(nsDecl);
629 string file(fileName);
635 string &args,
string &io,
string &fname)
637 string file(fileName);
638 TString f, amode, arguments, aclicio;
640 mode = amode.
Data(); args = arguments.Data();
641 io = aclicio.
Data(); fname = f.
Data();
651 char *__unDName(
char *demangled,
const char *mangled,
int out_len,
652 void * (* pAlloc )(
size_t),
void (* pFree )(
void *),
653 unsigned short int flags);
665 using namespace clang;
666 if (NamespaceDecl* nsd = llvm::dyn_cast<NamespaceDecl>(decl)){
670 if (ClassTemplateDecl* ctd = llvm::dyn_cast<ClassTemplateDecl>(decl)){
682 return ((
TCling*)
gCling)->LazyFunctionCreatorAutoload(mangled_name);
691 const std::vector<std::string> &headers,
692 const std::vector<std::string> &fwdDecls,
693 const std::vector<std::string> &unknown)
699 if (classes.empty()) {
703 const std::string& className = classes[0];
705 TString fileName =
"AutoDict_";
706 std::string::const_iterator sIt;
707 for (sIt = className.begin(); sIt != className.end(); sIt++) {
708 if (*sIt ==
'<' || *sIt ==
'>' ||
709 *sIt ==
' ' || *sIt ==
'*' ||
710 *sIt ==
',' || *sIt ==
'&' ||
718 if (classes.size() > 1) {
720 std::vector<std::string>::const_iterator it = classes.begin();
721 while ((++it) != classes.end()) {
722 for (
UInt_t cursor = 0; cursor != it->length(); ++cursor) {
723 chk = chk * 3 + it->at(cursor);
736 static const std::set<std::string> sSTLTypes {
737 "vector",
"list",
"forward_list",
"deque",
"map",
"unordered_map",
"multimap",
738 "unordered_multimap",
"set",
"unordered_set",
"multiset",
"unordered_multiset",
739 "queue",
"priority_queue",
"stack",
"iterator"};
740 std::vector<std::string>::const_iterator it;
741 std::string fileContent(
"");
742 for (it = headers.begin(); it != headers.end(); ++it) {
743 fileContent +=
"#include \"" + *it +
"\"\n";
745 for (it = unknown.begin(); it != unknown.end(); ++it) {
751 while (dirbase.Length() && dirbase !=
"." 752 && dirbase !=
"include" && dirbase !=
"inc" 753 && dirbase !=
"prec_stl") {
757 fileContent +=
TString(
"#include \"") + header +
"\"\n";
760 for (it = fwdDecls.begin(); it != fwdDecls.end(); ++it) {
761 fileContent +=
"class " + *it +
";\n";
763 fileContent +=
"#ifdef __CINT__ \n";
764 fileContent +=
"#pragma link C++ nestedclasses;\n";
765 fileContent +=
"#pragma link C++ nestedtypedefs;\n";
766 for (it = classes.begin(); it != classes.end(); ++it) {
768 size_t posTemplate = n.find(
'<');
769 std::set<std::string>::const_iterator iSTLType = sSTLTypes.end();
770 if (posTemplate != std::string::npos) {
771 n.erase(posTemplate, std::string::npos);
772 if (n.compare(0, 5,
"std::") == 0) {
775 iSTLType = sSTLTypes.find(n);
777 fileContent +=
"#pragma link C++ class ";
778 fileContent += *it +
"+;\n" ;
779 fileContent +=
"#pragma link C++ class ";
780 if (iSTLType != sSTLTypes.end()) {
784 fileContent += *it +
"::*;\n" ;
789 fileContent += *it +
"::*+;\n" ;
791 std::string oprLink(
"#pragma link C++ operators ");
795 if (iSTLType != sSTLTypes.end()) {
797 fileContent +=
"#ifdef G__VECTOR_HAS_CLASS_ITERATOR\n";
799 fileContent += oprLink +
"::iterator;\n";
800 fileContent += oprLink +
"::const_iterator;\n";
801 fileContent += oprLink +
"::reverse_iterator;\n";
803 fileContent +=
"#endif\n";
807 fileContent +=
"#endif\n";
811 filePointer = fopen(fileName,
"w");
812 if (filePointer ==
NULL) {
818 fprintf(filePointer,
"%s", fileContent.c_str());
834 const std::vector<std::string> &headers,
835 const std::vector<std::string> &fwdDecls,
836 const std::vector<std::string> &unknown)
842 std::vector<std::string> classes;
843 classes.push_back(className);
871 void exceptionErrorHandler(
void * ,
872 const std::string& reason,
874 throw std::runtime_error(std::string(
">>> Interpreter compilation error:\n") + reason);
888 class clangDiagSuppr {
890 clangDiagSuppr(clang::DiagnosticsEngine& diag): fDiagEngine(diag){
891 fOldDiagValue = fDiagEngine.getIgnoreAllWarnings();
892 fDiagEngine.setIgnoreAllWarnings(
true);
896 fDiagEngine.setIgnoreAllWarnings(fOldDiagValue);
899 clang::DiagnosticsEngine& fDiagEngine;
921 unsigned long offset = 0;
922 if (strncmp(tname.c_str(),
"const ", 6) == 0) {
925 unsigned long end = tname.length();
926 while( end && (tname[end-1]==
'&' || tname[end-1]==
'*' || tname[end-1]==
']') ) {
927 if ( tname[end-1]==
']' ) {
929 while ( end && tname[end-1]!=
'[' ) --end;
933 std::string innerbuf;
935 if (end != tname.length()) {
936 innerbuf = tname.substr(offset,end-offset);
937 inner = innerbuf.c_str();
939 inner = tname.c_str()+offset;
943 if (
gROOT->GetListOfClasses()->FindObject(inner)
955 newname =
"Long64_t";
957 newname =
"ULong64_t";
959 if (strcmp(inner,newname) == 0) {
962 if (offset) result =
"const ";
964 if ( end != tname.length() ) {
965 result += tname.substr(end,tname.length()-end);
967 if (result == tname) result.clear();
973 if (lastPos != inner)
977 const auto enName = lastPos;
978 const auto scopeNameSize = ((
Long64_t)lastPos - (
Long64_t)inner) /
sizeof(decltype(*lastPos)) - 2;
979 char *scopeName =
new char[scopeNameSize + 1];
980 strncpy(scopeName, inner, scopeNameSize);
981 scopeName[scopeNameSize] =
'\0';
983 if (
auto scope = static_cast<TClass *>(
gROOT->GetListOfClasses()->FindObject(scopeName))) {
984 auto enumTable =
dynamic_cast<const THashList *
>(scope->GetListOfEnums(
false));
985 if (enumTable && enumTable->THashList::FindObject(enName))
return true;
989 auto listOfEnums = scope->GetListOfEnums();
991 auto enumTable =
dynamic_cast<const THashList *
>(listOfEnums);
992 if (enumTable && enumTable->THashList::FindObject(enName))
return true;
999 auto enumTable =
dynamic_cast<const THashList *
>(
gROOT->GetListOfEnums());
1000 if (enumTable && enumTable->THashList::FindObject(inner))
return true;
1016 fContent.reserve(size);
1023 return fContent.c_str();
1031 bool notPresent = fLinesHashSet.emplace(fHashFunc(str)).second;
1042 :
TInterpreter(name, title), fGlobalsListSerial(-1), fInterpreter(0),
1043 fMetaProcessor(0), fNormalizedCtxt(0), fPrevLoadedDynLibInfo(0),
1044 fClingCallbacks(0), fAutoLoadCallBack(0),
1045 fTransactionCount(0), fHeaderParsingOnDemand(true), fIsAutoParsingSuspended(
kFALSE)
1048 bool fromRootCling = dlsym(RTLD_DEFAULT,
"usedToIdentifyRootClingByDlSym");
1050 llvm::install_fatal_error_handler(&exceptionErrorHandler);
1054 std::vector<std::string> clingArgsStorage;
1055 clingArgsStorage.push_back(
"cling4root");
1057 std::string interpInclude;
1059 if (!fromRootCling) {
1063 clingArgsStorage.push_back(interpInclude);
1065 std::string pchFilename = interpInclude.substr(2) +
"/allDict.cxx.pch";
1069 clingArgsStorage.push_back(
"-include-pch");
1070 clingArgsStorage.push_back(pchFilename);
1075 clingArgsStorage.push_back(
"-Wno-undefined-inline");
1076 clingArgsStorage.push_back(
"-fsigned-char");
1079 std::vector<const char*> interpArgs;
1080 for (std::vector<std::string>::const_iterator iArg = clingArgsStorage.begin(),
1081 eArg = clingArgsStorage.end(); iArg != eArg; ++iArg)
1082 interpArgs.push_back(iArg->c_str());
1087 extraArgs && *extraArgs; ++extraArgs) {
1088 if (!strcmp(*extraArgs,
"-resource-dir")) {
1090 llvmResourceDir = *(++extraArgs);
1092 interpArgs.push_back(*extraArgs);
1096 fInterpreter =
new cling::Interpreter(interpArgs.size(),
1098 llvmResourceDir.c_str());
1100 if (!fromRootCling) {
1117 fInterpreter->getCI()->getPreprocessorOpts().DisablePCHValidation =
true;
1121 fInterpreter->getCI()->getLangOpts().SpellChecking =
false;
1127 static llvm::raw_fd_ostream fMPOuts (STDOUT_FILENO,
false);
1133 if (fromRootCling) {
1135 "#include <string>\n" 1136 "using std::string;");
1139 + gClassDefInterpMacro +
"\n" 1140 + gInterpreterClassDef +
"\n" 1141 +
"#undef ClassImp\n" 1142 "#define ClassImp(X)\n" 1143 "#include <string>\n" 1144 "using namespace std;");
1172 if (!fromRootCling) {
1179 std::unique_ptr<TClingCallbacks>
1202 #if defined(R__MUST_REVISIT) 1203 #if R__MUST_REVISIT(6,2) 1204 Warning(
"~TCling",
"Interface not available yet.");
1205 #ifdef R__COMPLETE_MEM_TERMINATION 1226 #if defined(__CYGWIN__) && defined(__GNUC__) 1228 #elif defined(G__WIN32) 1229 MEMORY_BASIC_INFORMATION mbi;
1230 if (!VirtualQuery (
func, &mbi,
sizeof (mbi)))
1235 HMODULE hMod = (HMODULE) mbi.AllocationBase;
1236 TTHREAD_TLS_ARRAY(
char, MAX_PATH, moduleName);
1238 if (!GetModuleFileNameA (hMod, moduleName,
sizeof (moduleName)))
1245 if (dladdr((
void*)
func,&info)==0) {
1250 return info.dli_fname;
1262 auto setFactory = []() {
1266 static bool doneFactory = setFactory();
1275 const char** headers,
1276 void (*triggerFunc)())
const {
1284 searchPath = llvm::sys::path::parent_path(libraryName);
1304 if (
gROOT->IsRootFile(pcmFileName)) {
1308 ::Info(
"TCling::LoadPCM",
"Loading ROOT PCM %s", pcmFileName.
Data());
1315 TFile *pcmFile =
new TFile(pcmFileName+
"?filetype=pcm",
"READ");
1323 (listOfKeys->GetSize() == 0) ||
1325 (listOfKeys->GetSize() == 1) &&
1326 !strcmp(((
TKey*)listOfKeys->At(0))->
GetName(),
"EMPTY")
1337 ::Info(
"TCling::LoadPCM",
"reading protoclasses for %s \n",pcmFileName.
Data());
1339 pcmFile->
GetObject(
"__ProtoClasses", protoClasses);
1342 for (
auto obj : *protoClasses) {
1352 for (
auto proto : *protoClasses) {
1361 ::Error(
"TCling::LoadPCM",
"Inconsistent TClassTable for %s",
1373 protoClasses->Clear();
1374 delete protoClasses;
1378 pcmFile->
GetObject(
"__Typedefs", dataTypes);
1380 for (
auto typedf: *dataTypes)
1381 gROOT->GetListOfTypes()->Add(typedf);
1390 auto listOfGlobals =
gROOT->GetListOfGlobals();
1391 auto listOfEnums =
dynamic_cast<THashList*
>(
gROOT->GetListOfEnums());
1393 for (
auto selEnum: *enums){
1394 const char* enumScope = selEnum->
GetTitle();
1395 const char* enumName = selEnum->GetName();
1396 if (strcmp(enumScope,
"") == 0){
1399 if (!listOfEnums->THashList::FindObject(enumName)){
1400 ((
TEnum*) selEnum)->SetClass(
nullptr);
1401 listOfEnums->Add(selEnum);
1403 for (
auto enumConstant: *static_cast<TEnum*>(selEnum)->GetConstants()){
1404 if (!listOfGlobals->FindObject(enumConstant)){
1405 listOfGlobals->Add(enumConstant);
1413 if (!nsTClassEntry){
1416 auto listOfEnums = nsTClassEntry->
fEnums.load();
1427 if (listOfEnums && !listOfEnums->THashList::FindObject(enumName)){
1428 ((
TEnum*) selEnum)->SetClass(nsTClassEntry);
1429 listOfEnums->Add(selEnum);
1442 ::Info(
"TCling::LoadPCM",
"Loading clang PCM %s", pcmFileName.
Data());
1456 using namespace clang;
1458 class ExtLexicalStorageAdder:
public RecursiveASTVisitor<ExtLexicalStorageAdder>{
1463 bool VisitRecordDecl(clang::RecordDecl* rcd){
1465 Info(
"ExtLexicalStorageAdder",
1466 "Adding external lexical storage to class %s",
1467 rcd->getNameAsString().c_str());
1468 auto reDeclPtr = rcd->getMostRecentDecl();
1470 reDeclPtr->setHasExternalLexicalStorage();
1471 }
while ((reDeclPtr = reDeclPtr->getPreviousDecl()));
1491 const char** headers,
1492 const char** includePaths,
1493 const char* payloadCode,
1494 const char* fwdDeclsCode,
1495 void (*triggerFunc)(),
1497 const char** classesHeaders)
1500 static const bool fromRootCling = dlsym(RTLD_DEFAULT,
"usedToIdentifyRootClingByDlSym");
1504 if (fromRootCling)
return;
1508 bool isACLiC =
false;
1509 if (hasHeaderParsingOnDemand &&
1510 strstr(modulename,
"_ACLiC_dict") !=
nullptr){
1512 Info(
"TCling::RegisterModule",
1513 "Header parsing on demand is active but this is an Aclic library. Disabling it for this library.");
1514 hasHeaderParsingOnDemand =
false;
1531 for (
const char** inclPath = includePaths; *inclPath; ++inclPath) {
1534 cling::Transaction*
T = 0;
1536 for (
auto& fwdDeclArgToSkipPair : fwdDeclsArgToSkip){
1537 const std::string& fwdDecl = fwdDeclArgToSkipPair.first;
1538 const int nArgsToSkip = fwdDeclArgToSkipPair.second;
1540 assert(cling::Interpreter::kSuccess == compRes &&
1541 "A fwd declaration could not be compiled");
1542 if (compRes!=cling::Interpreter::kSuccess){
1543 Warning(
"TCling::RegisterModule",
1544 "Problems in declaring string '%s' were encountered.",
1559 TString code = gNonInterpreterClassDef;
1560 code += payloadCode;
1569 void* dyLibHandle = dlopen(dyLibName, RTLD_LAZY | RTLD_GLOBAL);
1572 char dyLibError[1000];
1573 FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
NULL, GetLastError(),
1574 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), dyLibError,
1575 sizeof(dyLibError),
NULL);
1578 const char* dyLibError = dlerror();
1582 ::Info(
"TCling::RegisterModule",
1583 "Cannot open shared library %s for dictionary %s:\n %s",
1584 dyLibName, modulename, dyLibError);
1593 if (hasHeaderParsingOnDemand && fwdDeclsCode){
1596 std::string fwdDeclsCodeLessEnums;
1600 std::string fwdDeclsLine;
1601 std::istringstream fwdDeclsCodeStr(fwdDeclsCode);
1602 std::vector<std::string> scope;
1603 while (std::getline(fwdDeclsCodeStr, fwdDeclsLine)) {
1604 if (fwdDeclsLine.find(
"namespace ") == 0
1605 || fwdDeclsLine.find(
"inline namespace ") == 0) {
1607 scope.push_back(fwdDeclsLine.substr(10,
1608 fwdDeclsLine.length() - 10 - 2));
1609 }
else if (fwdDeclsLine ==
"}") {
1611 }
else if (fwdDeclsLine.find(
"enum __attribute__((annotate(\"") == 0) {
1612 clang::DeclContext* DC = 0;
1613 for (
auto &&aScope: scope) {
1614 DC = cling::utils::Lookup::Namespace(&
fInterpreter->getSema(), aScope.c_str(), DC);
1620 if (scope.empty() || DC) {
1622 size_t posEnumName = fwdDeclsLine.find(
"\"))) ", 32);
1623 R__ASSERT(posEnumName != std::string::npos &&
"Inconsistent enum fwd decl!");
1625 while (isspace(fwdDeclsLine[posEnumName]))
1627 size_t posEnumNameEnd = fwdDeclsLine.find(
" : ", posEnumName);
1628 R__ASSERT(posEnumNameEnd != std::string::npos &&
"Inconsistent enum fwd decl (end)!");
1629 while (isspace(fwdDeclsLine[posEnumNameEnd]))
1633 std::string enumName = fwdDeclsLine.substr(posEnumName,
1634 posEnumNameEnd - posEnumName + 1);
1636 if (clang::NamedDecl* enumDecl
1637 = cling::utils::Lookup::Named(&
fInterpreter->getSema(),
1638 enumName.c_str(), DC)) {
1641 R__ASSERT(llvm::dyn_cast<clang::EnumDecl>(enumDecl) &&
"not an enum decl!");
1647 fwdDeclsCodeLessEnums += fwdDeclsLine +
"\n";
1651 if (fwdDeclsCodeLessEnums.size() != 0){
1652 auto compRes =
fInterpreter->declare(fwdDeclsCodeLessEnums, &T);
1653 assert(cling::Interpreter::kSuccess == compRes &&
1654 "The forward declarations could not be compiled");
1655 if (compRes!=cling::Interpreter::kSuccess){
1656 Warning(
"TCling::RegisterModule",
1657 "Problems in compiling forward declarations for module %s: '%s'",
1658 modulename, fwdDeclsCodeLessEnums.c_str()) ;
1666 ExtLexicalStorageAdder elsa;
1667 for (
auto dciIt = T->decls_begin();dciIt!=T->decls_end();dciIt++){
1668 cling::Transaction::DelayCallInfo& dci = *dciIt;
1669 for(
auto dit = dci.m_DGR.begin(); dit != dci.m_DGR.end(); ++dit) {
1670 clang::Decl* declPtr = *dit;
1671 elsa.TraverseDecl(declPtr);
1685 for (
const char** classesHeader = classesHeaders; *classesHeader; ++classesHeader) {
1686 temp=*classesHeader;
1688 size_t theTemplateHash = 0;
1689 bool addTemplate =
false;
1690 size_t posTemplate = temp.find(
'<');
1691 if (posTemplate != std::string::npos) {
1693 std::string templateName = temp.substr(0, posTemplate);
1699 for (
const char** classesHeader_inner = classesHeader; 0!=strcmp(*classesHeader_inner,
"@"); ++classesHeader_inner,++classesHeader){
1701 if (payloadCode == *classesHeader_inner ){
1703 if (addTemplate)
fPayloads.insert(theTemplateHash);
1706 Info(
"TCling::RegisterModule",
1707 "Adding a header for %s", temp.c_str());
1713 addTemplate =
false;
1720 if (strcmp(modulename,
"libCore")!=0 && strcmp(modulename,
"libRint")!=0
1721 && strcmp(modulename,
"libThread")!=0 && strcmp(modulename,
"libRIO")!=0
1722 && strcmp(modulename,
"libcomplexDict")!=0 && strcmp(modulename,
"libdequeDict")!=0
1723 && strcmp(modulename,
"liblistDict")!=0 && strcmp(modulename,
"libforward_listDict")!=0
1724 && strcmp(modulename,
"libvectorDict")!=0
1725 && strcmp(modulename,
"libmapDict")!=0 && strcmp(modulename,
"libmultimap2Dict")!=0
1726 && strcmp(modulename,
"libmap2Dict")!=0 && strcmp(modulename,
"libmultimapDict")!=0
1727 && strcmp(modulename,
"libsetDict")!=0 && strcmp(modulename,
"libmultisetDict")!=0
1728 && strcmp(modulename,
"libunordered_setDict")!=0 && strcmp(modulename,
"libunordered_multisetDict")!=0
1729 && strcmp(modulename,
"libunordered_mapDict")!=0 && strcmp(modulename,
"libunordered_multimapDict")!=0
1730 && strcmp(modulename,
"libvalarrayDict")!=0
1731 && strcmp(modulename,
"G__GenVector32")!=0 && strcmp(modulename,
"G__Smatrix32")!=0
1735 if (!
LoadPCM(pcmFileName, headers, triggerFunc)) {
1736 ::Error(
"TCling::RegisterModule",
"cannot find dictionary module %s",
1741 bool oldValue =
false;
1749 clangDiagSuppr diagSuppr(
fInterpreter->getSema().getDiagnostics());
1751 #if defined(R__MUST_REVISIT) 1752 #if R__MUST_REVISIT(6,2) 1753 Warning(
"TCling::RegisterModule",
"Diagnostics suppression should be gone by now.");
1757 if (!hasHeaderParsingOnDemand){
1760 const cling::Transaction* watermark =
fInterpreter->getLastTransaction();
1761 cling::Interpreter::CompilationResult compRes =
fInterpreter->parseForModule(code.
Data());
1767 assert(cling::Interpreter::kSuccess == compRes &&
1768 "Payload code of a dictionary could not be parsed correctly.");
1769 if (compRes!=cling::Interpreter::kSuccess) {
1770 Warning(
"TCling::RegisterModule",
1771 "Problems declaring payload for module %s.", modulename) ;
1780 if (!hasHeaderParsingOnDemand) {
1807 if (!hasHeaderParsingOnDemand) {
1810 "#undef __ROOTCLING__\n" 1811 + gInterpreterClassDef +
1818 dlclose(dyLibHandle);
1840 typedef std::vector<std::pair<TClass*,DictFuncPtr_t> >::iterator iterator;
1846 if ( i->first == oldcl ) {
1868 const char* input_line,
1869 cling::Interpreter::CompilationResult& compRes,
1873 return metaProcessor->process(input_line, compRes, result);
1875 catch (cling::InvalidDerefException&
ex)
1877 Error(
"HandleInterpreterException",
"%s.\n%s", ex.what(),
"Execution of your code was aborted.");
1887 if (
auto ie = dynamic_cast<const cling::InterpreterException*>(&e)) {
1919 gROOT->SetLineIsProcessing();
1923 gROOT->SetLineHasBeenProcessed();
1936 gROOT->SetLineIsProcessing();
1938 struct InterpreterFlagsRAII_t {
1940 bool fWasDynamicLookupEnabled;
1942 InterpreterFlagsRAII_t(cling::Interpreter* interp):
1944 fWasDynamicLookupEnabled(interp->isDynamicLookupEnabled())
1946 fInterpreter->enableDynamicLookup(
true);
1948 ~InterpreterFlagsRAII_t() {
1949 fInterpreter->enableDynamicLookup(fWasDynamicLookupEnabled);
1950 gROOT->SetLineHasBeenProcessed();
1959 cling::Interpreter::CompilationResult compRes = cling::Interpreter::kSuccess;
1960 if (!strncmp(sLine.
Data(),
".L", 2) || !strncmp(sLine.
Data(),
".x", 2) ||
1961 !strncmp(sLine.
Data(),
".X", 2)) {
1969 aclicMode, arguments, io);
1970 if (aclicMode.
Length()) {
1972 R__ASSERT(aclicMode[0]==
'+' &&
"ACLiC mode must start with a +");
1974 if (aclicMode[1]==
'+') {
1980 compRes = cling::Interpreter::kFailure;
1982 if (strncmp(sLine.
Data(),
".L", 2) != 0) {
1985 if (arguments.Length()==0) {
1994 mod_line =
function + arguments + io;
1995 cling::MetaProcessor::MaybeRedirectOutputRAII RAII(
fMetaProcessor);
2001 size_t unnamedMacroOpenCurly;
2004 std::string codeline;
2005 std::ifstream in(fname);
2007 std::getline(in, codeline);
2008 code += codeline +
"\n";
2010 unnamedMacroOpenCurly
2011 = cling::utils::isUnnamedMacro(code,
fInterpreter->getCI()->getLangOpts());
2015 cling::MetaProcessor::MaybeRedirectOutputRAII RAII(
fMetaProcessor);
2016 if (unnamedMacroOpenCurly != std::string::npos) {
2018 unnamedMacroOpenCurly);
2028 if (0!=strncmp(sLine.
Data(),
".autodict ",10) && sLine !=
".autodict") {
2031 cling::MetaProcessor::MaybeRedirectOutputRAII RAII(
fMetaProcessor);
2034 bool isInclusionDirective = sLine.
Contains(
"\n#include") || sLine.
BeginsWith(
"#include");
2035 if (isInclusionDirective) {
2043 if (result.isValid())
2052 case cling::Interpreter::kSuccess: *error =
kNoError;
break;
2053 case cling::Interpreter::kFailure: *error =
kRecoverable;
break;
2054 case cling::Interpreter::kMoreInputExpected: *error =
kProcessing;
break;
2057 if (compRes == cling::Interpreter::kSuccess
2059 && !result.isVoid())
2061 gROOT->SetLineHasBeenProcessed();
2062 return result.simplisticCastAs<
long>();
2064 gROOT->SetLineHasBeenProcessed();
2085 if (path[0] ==
'-' && path[1] ==
'I')
2109 static const TClassRef clRefString(
"std::string");
2110 if (clRefString == cl) {
2115 const char* cobj = (
const char*) obj;
2122 auto inspInspect = [&] (ptrdiff_t offset){
2123 insp.
Inspect(const_cast<TClass*>(cl), insp.
GetParent(),
"_real", cobj, isTransient);
2124 insp.
Inspect(const_cast<TClass*>(cl), insp.
GetParent(),
"_imag", cobj + offset, isTransient);
2128 switch(complexType) {
2135 inspInspect(
sizeof(
float));
2140 inspInspect(
sizeof(
double));
2145 inspInspect(
sizeof(
int));
2150 inspInspect(
sizeof(
long));
2155 static clang::PrintingPolicy
2157 if (printPol.Indentation) {
2159 printPol.Indentation = 0;
2160 printPol.SuppressInitializers =
true;
2163 const char* clname = cl->
GetName();
2166 const clang::ASTContext& astContext =
fInterpreter->getCI()->getASTContext();
2167 const clang::Decl *scopeDecl = 0;
2172 scopeDecl = clingCI->
GetDecl();
2173 recordType = clingCI->
GetType();
2175 const cling::LookupHelper& lh =
fInterpreter->getLookupHelper();
2177 scopeDecl = lh.findScope(clname, cling::LookupHelper::NoDiagnostics,
2181 Error(
"InspectMembers",
"Cannot find Decl for class %s", clname);
2184 const clang::CXXRecordDecl* recordDecl
2185 = llvm::dyn_cast<
const clang::CXXRecordDecl>(scopeDecl);
2187 Error(
"InspectMembers",
"Cannot find Decl for class %s is not a CXXRecordDecl.", clname);
2194 cling::Interpreter::PushTransactionRAII deserRAII(
fInterpreter);
2196 astContext.getASTRecordLayout(recordDecl);
2198 for (clang::RecordDecl::field_iterator iField = recordDecl->field_begin(),
2199 eField = recordDecl->field_end(); iField != eField; ++iField) {}
2202 const clang::ASTRecordLayout& recLayout
2203 = astContext.getASTRecordLayout(recordDecl);
2210 if (cl->
Size() != recLayout.getSize().getQuantity()) {
2211 Error(
"InspectMembers",
"TClass and cling disagree on the size of the class %s, respectively %d %lld\n",
2215 unsigned iNField = 0;
2218 for (clang::RecordDecl::field_iterator iField = recordDecl->field_begin(),
2219 eField = recordDecl->field_end(); iField != eField;
2220 ++iField, ++iNField) {
2223 clang::QualType memberQT = iField->getType();
2228 memberQT = cling::utils::Transform::GetPartiallyDesugaredType(astContext, memberQT,
fNormalizedCtxt->
GetConfig(),
false );
2229 if (memberQT.isNull()) {
2230 std::string memberName;
2231 llvm::raw_string_ostream stream(memberName);
2233 printPol.AnonymousTagLocations =
false;
2234 iField->getNameForDiagnostic(stream, printPol,
true );
2236 Error(
"InspectMembers",
2237 "Cannot retrieve QualType for member %s while inspecting class %s",
2238 memberName.c_str(), clname);
2241 const clang::Type* memType = memberQT.getTypePtr();
2243 std::string memberName;
2244 llvm::raw_string_ostream stream(memberName);
2246 printPol.AnonymousTagLocations =
false;
2247 iField->getNameForDiagnostic(stream, printPol,
true );
2249 Error(
"InspectMembers",
2250 "Cannot retrieve Type for member %s while inspecting class %s",
2251 memberName.c_str(), clname);
2256 Bool_t ispointer =
false;
2257 if (memNonPtrType->isPointerType()) {
2259 clang::QualType ptrQT
2260 = memNonPtrType->getAs<clang::PointerType>()->getPointeeType();
2265 ptrQT = cling::utils::Transform::GetPartiallyDesugaredType(astContext, ptrQT,
fNormalizedCtxt->
GetConfig(),
false );
2266 if (ptrQT.isNull()) {
2267 std::string memberName;
2268 llvm::raw_string_ostream stream(memberName);
2270 printPol.AnonymousTagLocations =
false;
2271 iField->getNameForDiagnostic(stream, printPol,
true );
2273 Error(
"InspectMembers",
2274 "Cannot retrieve pointee Type for member %s while inspecting class %s",
2275 memberName.c_str(), clname);
2278 memNonPtrType = ptrQT.getTypePtr();
2282 llvm::SmallString<8> arraySize;
2283 const clang::ArrayType* arrType = memNonPtrType->getAsArrayTypeUnsafe();
2284 unsigned arrLevel = 0;
2285 bool haveErrorDueToArray =
false;
2289 const clang::ConstantArrayType* constArrType =
2290 clang::dyn_cast<clang::ConstantArrayType>(arrType);
2292 constArrType->getSize().toStringUnsigned(arraySize);
2295 clang::QualType subArrQT = arrType->getElementType();
2296 if (subArrQT.isNull()) {
2297 std::string memberName;
2298 llvm::raw_string_ostream stream(memberName);
2300 printPol.AnonymousTagLocations =
false;
2301 iField->getNameForDiagnostic(stream, printPol,
true );
2303 Error(
"InspectMembers",
2304 "Cannot retrieve QualType for array level %d (i.e. element type of %s) for member %s while inspecting class %s",
2305 arrLevel, subArrQT.getAsString(printPol).c_str(),
2306 memberName.c_str(), clname);
2307 haveErrorDueToArray =
true;
2310 arrType = subArrQT.getTypePtr()->getAsArrayTypeUnsafe();
2312 if (haveErrorDueToArray) {
2317 std::string fieldName;
2318 if (memType->isPointerType()) {
2323 std::string
ioname(iField->getName());
2326 fieldName += arraySize;
2331 clang::CharUnits offset(astContext.toCharUnitsFromBits(recLayout.getFieldOffset(iNField)));
2332 ptrdiff_t fieldOffset = offset.getQuantity();
2342 auto iFiledQtype = iField->getType();
2343 if (
auto tagDecl = iFiledQtype->getAsTagDecl()){
2344 auto declAccess = tagDecl->getAccess();
2345 if (declAccess == AS_private || declAccess == AS_protected) {
2351 insp.
Inspect(const_cast<TClass*>(cl), insp.
GetParent(), fieldName.c_str(), cobj + fieldOffset, isTransient);
2354 const clang::CXXRecordDecl* fieldRecDecl = memNonPtrType->getAsCXXRecordDecl();
2358 std::string sFieldRecName;
2359 if (!ROOT::TMetaUtils::ExtractAttrPropertyFromName(*fieldRecDecl,
"iotype",sFieldRecName)){
2361 clang::QualType(memNonPtrType,0),
2371 insp.
InspectMember(sFieldRecName.c_str(), cobj + fieldOffset,
2372 (fieldName +
'.').c_str(),
transient);
2380 unsigned iNBase = 0;
2381 for (clang::CXXRecordDecl::base_class_const_iterator iBase
2382 = recordDecl->bases_begin(), eBase = recordDecl->bases_end();
2383 iBase != eBase; ++iBase, ++iNBase) {
2384 clang::QualType baseQT = iBase->getType();
2385 if (baseQT.isNull()) {
2386 Error(
"InspectMembers",
2387 "Cannot find QualType for base number %d while inspecting class %s",
2391 const clang::CXXRecordDecl* baseDecl
2392 = baseQT->getAsCXXRecordDecl();
2394 Error(
"InspectMembers",
2395 "Cannot find CXXRecordDecl for base number %d while inspecting class %s",
2400 std::string sBaseName;
2402 std::vector<TClass*> foundClasses;
2404 if (foundClasses.size()==1){
2405 baseCl=foundClasses[0];
2418 std::string qualNameForDiag;
2420 Error(
"InspectMembers",
2421 "Cannot find TClass for base class %s", qualNameForDiag.c_str() );
2426 if (iBase->isVirtual()) {
2429 Error(
"InspectMembers",
2430 "Base %s of class %s is virtual but no object provided",
2431 sBaseName.c_str(), clname);
2439 baseOffset = ci->
GetBaseOffset(baseCi, const_cast<void*>(obj),
2441 if (baseOffset == -1) {
2442 Error(
"InspectMembers",
2443 "Error calculating offset of virtual base %s of class %s",
2444 sBaseName.c_str(), clname);
2447 Error(
"InspectMembers",
2448 "Cannot calculate offset of virtual base %s of class %s",
2449 sBaseName.c_str(), clname);
2454 baseOffset = recLayout.getBaseClassOffset(baseDecl).getQuantity();
2501 bool oldDynLookup =
fInterpreter->isDynamicLookupEnabled();
2552 std::string file_name = filename;
2553 size_t at = std::string::npos;
2554 while ((at = file_name.find(
"/./")) != std::string::npos)
2555 file_name.replace(at, 3,
"/");
2557 std::string filesStr =
"";
2558 llvm::raw_string_ostream filesOS(filesStr);
2559 clang::SourceManager &SM =
fInterpreter->getCI()->getSourceManager();
2560 cling::ClangInternalState::printIncludedFiles(filesOS, SM);
2563 llvm::SmallVector<llvm::StringRef, 100> files;
2564 llvm::StringRef(filesStr).split(files,
"\n");
2566 std::set<std::string> fileMap;
2568 for (llvm::SmallVector<llvm::StringRef, 100>::const_iterator
2569 iF = files.begin(), iE = files.end(); iF != iE; ++iF) {
2570 if ((*iF) == file_name.c_str())
return kTRUE;
2571 fileMap.insert(*iF);
2574 if (fileMap.empty())
return kFALSE;
2577 TString sFilename(file_name.c_str());
2579 && fileMap.count(sFilename.Data())) {
2587 while (incPath.
Index(
" :") != -1) {
2591 sFilename = file_name.c_str();
2593 && fileMap.count(sFilename.Data())) {
2598 sFilename = file_name.c_str();
2600 cling::DynamicLibraryManager* dyLibManager
2603 if (dyLibManager->isLibraryLoaded(found)) {
2608 const clang::DirectoryLookup *CurDir = 0;
2609 clang::Preprocessor &PP =
fInterpreter->getCI()->getPreprocessor();
2610 clang::HeaderSearch &HS = PP.getHeaderSearchInfo();
2611 const clang::FileEntry *FE = HS.LookupFile(file_name.c_str(),
2612 clang::SourceLocation(),
2615 clang::ArrayRef<std::pair<
const clang::FileEntry *,
2616 const clang::DirectoryEntry *>>(),
2625 if (FE && FE->isValid()) {
2627 clang::SourceManager &SM =
fInterpreter->getCI()->getSourceManager();
2629 clang::FileID FID = SM.translateFile(FE);
2630 if (!FID.isInvalid() && FID.getHashValue() == 0)
2633 clang::SrcMgr::SLocEntry SLocE = SM.getSLocEntry(FID);
2634 if (SLocE.isFile() && SLocE.getFile().getContentCache()->getRawBuffer() == 0)
2636 if (!FID.isInvalid())
2640 sFilename = FE->getName();
2642 && fileMap.count(sFilename.Data())) {
2653 #if defined(R__WIN32) || defined(__CYGWIN__) 2654 HMODULE hModules[1024];
2656 unsigned long cbModules;
2658 hProcess = (
void *)::GetCurrentProcess();
2659 ::EnumProcessModules(hProcess, hModules,
sizeof(hModules), &cbModules);
2661 for (i = 1; i < (cbModules /
sizeof(
void *)); i++) {
2662 static const int bufsize = 260;
2663 wchar_t winname[bufsize];
2664 char posixname[bufsize];
2665 ::GetModuleFileNameExW(hProcess, hModules[i], winname, bufsize);
2666 #if defined(__CYGWIN__) 2667 cygwin_conv_path(CCP_WIN_W_TO_POSIX, winname, posixname, bufsize);
2669 std::wstring wpath = winname;
2670 std::replace(wpath.begin(), wpath.end(),
'\\',
'/');
2671 string path(wpath.begin(), wpath.end());
2672 strncpy(posixname, path.c_str(), bufsize);
2678 #elif defined(R__MACOSX) 2681 const char* imageName = 0;
2682 while ((imageName = _dyld_get_image_name(imageIndex))) {
2689 #elif defined(R__LINUX) 2690 struct PointerNo4_t {
2702 PointerNo4_t* procLinkMap = (PointerNo4_t*)dlopen(0, RTLD_LAZY | RTLD_GLOBAL);
2705 LinkMap_t* linkMap = (LinkMap_t*) ((PointerNo4_t*)procLinkMap->fPtr)->fPtr;
2709 dlclose(procLinkMap);
2713 while (iDyLib->fNext) {
2714 iDyLib = iDyLib->fNext;
2719 Error(
"TCling::UpdateListOfLoadedSharedLibraries",
2720 "Platform not supported!");
2731 if (!filename)
return;
2735 cling::DynamicLibraryManager* DLM =
fInterpreter->getDynamicLibraryManager();
2736 if (!DLM->isLibraryLoaded(filename)) {
2737 DLM->loadLibrary(filename,
true );
2740 #if defined(R__MACOSX) 2742 if (!strncmp(filename,
"/usr/lib/system/", 16)
2743 || !strncmp(filename,
"/usr/lib/libc++", 15)
2744 || !strncmp(filename,
"/System/Library/Frameworks/", 27)
2745 || !strncmp(filename,
"/System/Library/PrivateFrameworks/", 34)
2746 || !strncmp(filename,
"/System/Library/CoreServices/", 29)
2747 || !strcmp(filename,
"cl_kernels")
2748 || strstr(filename,
"/usr/lib/libSystem")
2749 || strstr(filename,
"/usr/lib/libstdc++")
2750 || strstr(filename,
"/usr/lib/libicucore")
2751 || strstr(filename,
"/usr/lib/libbsm")
2752 || strstr(filename,
"/usr/lib/libobjc")
2753 || strstr(filename,
"/usr/lib/libresolv")
2754 || strstr(filename,
"/usr/lib/libauto")
2755 || strstr(filename,
"/usr/lib/libcups")
2756 || strstr(filename,
"/usr/lib/libDiagnosticMessagesClient")
2757 || strstr(filename,
"/usr/lib/liblangid")
2758 || strstr(filename,
"/usr/lib/libCRFSuite")
2759 || strstr(filename,
"/usr/lib/libpam")
2760 || strstr(filename,
"/usr/lib/libOpenScriptingUtil")
2761 || strstr(filename,
"/usr/lib/libextension"))
2763 #elif defined(__CYGWIN__) 2765 static const int bufsize = 260;
2766 char posixwindir[bufsize];
2767 char *windir = getenv(
"WINDIR");
2769 cygwin_conv_path(CCP_WIN_A_TO_POSIX, windir, posixwindir, bufsize);
2771 snprintf(posixwindir,
sizeof(posixwindir),
"/Windows/");
2772 if (strstr(filename, posixwindir) ||
2773 strstr(filename,
"/usr/bin/cyg"))
2775 #elif defined(R__WIN32) 2776 if (strstr(filename,
"/Windows/"))
2778 #elif defined (R__LINUX) 2779 if (strstr(filename,
"/ld-linux")
2780 || strstr(filename,
"linux-gnu/")
2781 || strstr(filename,
"/libstdc++.")
2782 || strstr(filename,
"/libgcc")
2783 || strstr(filename,
"/libc.")
2784 || strstr(filename,
"/libdl.")
2785 || strstr(filename,
"/libm."))
2803 Error(
"Load",
"Trying to load library (%s) from rootcling.",filename);
2809 cling::DynamicLibraryManager* DLM =
fInterpreter->getDynamicLibraryManager();
2810 std::string canonLib = DLM->lookupLibrary(filename);
2811 cling::DynamicLibraryManager::LoadLibResult res
2812 = cling::DynamicLibraryManager::kLoadLibNotFound;
2813 if (!canonLib.empty()) {
2815 res = DLM->loadLibrary(filename, system);
2819 cling::Interpreter::CompilationResult compRes;
2820 cling::MetaProcessor::MaybeRedirectOutputRAII RAII(
fMetaProcessor);
2822 if (compRes == cling::Interpreter::kSuccess)
2823 res = cling::DynamicLibraryManager::kLoadLibSuccess;
2827 if (res == cling::DynamicLibraryManager::kLoadLibSuccess) {
2831 case cling::DynamicLibraryManager::kLoadLibSuccess:
return 0;
2832 case cling::DynamicLibraryManager::kLoadLibAlreadyLoaded:
return 1;
2882 Warning(
"Calc",
"waiting for cling thread to free");
2885 gROOT->SetLineIsProcessing();
2893 cling::Interpreter::CompilationResult cr =
fInterpreter->evaluate(line, valRef);
2894 if (cr != cling::Interpreter::kSuccess) {
2902 if (!valRef.isValid()) {
2911 if (valRef.isVoid()) {
2918 gROOT->SetLineHasBeenProcessed();
2921 return valRef.simplisticCastAs<
long>();
2928 void (*histaddFunc)(
const char*
line))
2933 #if defined(R__MUST_REVISIT) 2934 #if R__MUST_REVISIT(6,2) 2935 Warning(
"SetGetline",
"Cling should support the equivalent of SetGetlineFunc(getlineFunc, histaddFunc)");
2948 if ((std::distance(T.decls_begin(), T.decls_end()) != 1)
2949 || T.deserialized_decls_begin() != T.deserialized_decls_end()
2950 || T.macros_begin() != T.macros_end()
2951 || ((!T.getFirstDecl().isNull()) && ((*T.getFirstDecl().begin()) != T.getWrapperFD()))) {
2968 std::set<TObject*>::iterator iSpecial = ((std::set<TObject*>*)
fgSetOfSpecials)->find(obj);
2985 #if defined(R__MUST_REVISIT) 2986 #if R__MUST_REVISIT(6,2) 2988 Warning(
"Reset",
"Cling should support the equivalent of scratch_upto(&fDictPos)");
2998 #if defined(R__MUST_REVISIT) 2999 #if R__MUST_REVISIT(6,2) 3001 Warning(
"ResetAll",
"Cling should support the equivalent of complete reset (unload everything but the startup decls.");
3028 #if defined(R__MUST_REVISIT) 3029 #if R__MUST_REVISIT(6,2) 3031 Warning(
"ResetGlobalVar",
"Cling should support the equivalent of resetglobalvar(obj)");
3043 #if defined(R__MUST_REVISIT) 3044 #if R__MUST_REVISIT(6,2) 3046 Warning(
"RewindDictionary",
"Cling should provide a way to revert transaction similar to rewinddictionary()");
3057 #if defined(R__MUST_REVISIT) 3058 #if R__MUST_REVISIT(6,2) 3060 Warning(
"DeleteGlobal",
"Cling should provide the equivalent of deleteglobal(obj), see also DeleteVariable.");
3072 #if defined(R__MUST_REVISIT) 3073 #if R__MUST_REVISIT(6,2) 3074 Warning(
"DeleteVariable",
"should do more that just reseting the value to zero");
3079 llvm::StringRef srName(name);
3080 const char* unscopedName =
name;
3081 llvm::StringRef::size_type posScope = srName.rfind(
"::");
3082 const clang::DeclContext* declCtx = 0;
3083 if (posScope != llvm::StringRef::npos) {
3084 const cling::LookupHelper& lh =
fInterpreter->getLookupHelper();
3085 const clang::Decl* scopeDecl
3086 = lh.findScope(srName.substr(0, posScope),
3087 cling::LookupHelper::WithDiagnostics);
3089 Error(
"DeleteVariable",
"Cannot find enclosing scope for variable %s",
3093 declCtx = llvm::dyn_cast<clang::DeclContext>(scopeDecl);
3095 Error(
"DeleteVariable",
3096 "Enclosing scope for variable %s is not a declaration context",
3100 unscopedName += posScope + 2;
3102 clang::NamedDecl* nVarDecl
3103 = cling::utils::Lookup::Named(&
fInterpreter->getSema(), unscopedName, declCtx);
3105 Error(
"DeleteVariable",
"Unknown variable %s", name);
3108 clang::VarDecl* varDecl = llvm::dyn_cast<clang::VarDecl>(nVarDecl);
3110 Error(
"DeleteVariable",
"Entity %s is not a variable", name);
3114 clang::QualType qType = varDecl->getType();
3118 if (type->isPointerType()) {
3119 int** ppInt = (
int**)
fInterpreter->getAddressOfGlobal(GlobalDecl(varDecl));
3121 if (ppInt) *ppInt = 0;
3131 #if defined(R__MUST_REVISIT) 3132 #if R__MUST_REVISIT(6,2) 3134 Warning(
"SaveContext",
"Cling should provide a way to record a state watermark similar to store_dictposition(&fDictPos)");
3144 #if defined(R__MUST_REVISIT) 3145 #if R__MUST_REVISIT(6,2) 3147 Warning(
"SaveGlobalsContext",
"Cling should provide a way to record a watermark for the list of global variable similar to store_dictposition(&fDictPosGlobals)");
3181 struct AlternateTupleIntDoubleAsc
3187 struct AlternateTupleIntDoubleDes
3195 std::tuple<int,double> value;
3196 AlternateTupleIntDoubleAsc asc;
3197 AlternateTupleIntDoubleDes des;
3199 size_t offset0 = ((
char*)&(std::get<0>(value))) - ((
char*)&value);
3200 size_t offset1 = ((
char*)&(std::get<1>(value))) - ((
char*)&value);
3202 size_t ascOffset0 = ((
char*)&(asc._0)) - ((
char*)&asc);
3203 size_t ascOffset1 = ((
char*)&(asc._1)) - ((
char*)&asc);
3205 size_t desOffset0 = ((
char*)&(des._0)) - ((
char*)&des);
3206 size_t desOffset1 = ((
char*)&(des._1)) - ((
char*)&des);
3208 if (offset0 == ascOffset0 && offset1 == ascOffset1) {
3210 }
else if (offset0 == desOffset0 && offset1 == desOffset1) {
3220 std::string alternateName =
"TEmulatedTuple";
3221 alternateName.append( classname + 5 );
3223 std::string guard_name;
3225 std::ostringstream guard;
3226 guard <<
"ROOT_INTERNAL_TEmulated_";
3227 guard << guard_name;
3229 std::ostringstream alternateTuple;
3230 alternateTuple <<
"#ifndef " << guard.str() <<
"\n";
3231 alternateTuple <<
"#define " << guard.str() <<
"\n";
3232 alternateTuple <<
"namespace ROOT { namespace Internal {\n";
3233 alternateTuple <<
"template <class... Types> struct TEmulatedTuple;\n";
3234 alternateTuple <<
"template <> struct " << alternateName <<
" {\n";
3239 unsigned int nMember = 0;
3240 auto iter = tupleContent.
fElements.begin() + 1;
3241 auto theEnd = tupleContent.
fElements.end() - 1;
3242 while (iter != theEnd) {
3243 alternateTuple <<
" " << *iter <<
" _" << nMember <<
";\n";
3250 unsigned int nMember = tupleContent.
fElements.size() - 3;
3251 auto iter = tupleContent.
fElements.rbegin() + 1;
3252 auto theEnd = tupleContent.
fElements.rend() - 1;
3253 while (iter != theEnd) {
3254 alternateTuple <<
" " << *iter <<
" _" << nMember <<
";\n";
3261 Fatal(
"TCling::SetClassInfo::AtlernateTuple",
3262 "Layout of std::tuple on this platform is unexpected.");
3267 alternateTuple <<
"};\n";
3268 alternateTuple <<
"}}\n";
3269 alternateTuple <<
"#endif\n";
3271 Error(
"Load",
"Could not declare %s",alternateName.c_str());
3274 alternateName =
"ROOT::Internal::" + alternateName;
3275 return alternateName;
3301 if (strncmp(cl->
GetName(),
"tuple<",strlen(
"tuple<"))==0) {
3308 if (!info->IsValid()) {
3332 zombieCandidate =
kTRUE;
3334 if (!info->IsLoaded()) {
3339 zombieCandidate =
kTRUE;
3389 static const char *anonEnum =
"anonymous enum ";
3390 static const int cmplen = strlen(anonEnum);
3392 if (0 == strncmp(name,anonEnum,cmplen)) {
3411 if (isClassOrNamespaceOnly &&
3414 const char *classname =
name;
3425 const cling::LookupHelper& lh =
fInterpreter->getLookupHelper();
3427 const clang::Decl *decl
3428 = lh.findScope(classname,
3429 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
3430 : cling::LookupHelper::NoDiagnostics,
3434 decl = lh.findScope(buf,
3435 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
3436 : cling::LookupHelper::NoDiagnostics,
3453 clang::ClassTemplateSpecializationDecl *tmpltDecl =
3454 llvm::dyn_cast_or_null<clang::ClassTemplateSpecializationDecl>
3455 (type->getAsCXXRecordDecl());
3456 if (tmpltDecl && !tmpltDecl->getPointOfInstantiation().isValid()) {
3475 if (tci.
Property() & propertiesMask) {
3511 const cling::LookupHelper& lh =
fInterpreter->getLookupHelper();
3512 const clang::Decl *decl
3513 = lh.findClassTemplate(name,
3514 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
3515 : cling::LookupHelper::NoDiagnostics);
3517 std::string strname =
"std::";
3519 decl = lh.findClassTemplate(strname,
3520 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
3521 : cling::LookupHelper::NoDiagnostics);
3547 cl->
fBase = listOfBase;
3563 D =
fInterpreter->getCI()->getASTContext().getTranslationUnitDecl();
3566 if (
const clang::DeclContext* DC = dyn_cast<clang::DeclContext>(D)) {
3567 cling::Interpreter::PushTransactionRAII deserRAII(
fInterpreter);
3569 llvm::SmallVector< DeclContext *, 4> allDeclContexts;
3570 const_cast< clang::DeclContext *
>(DC)->collectAllContexts(allDeclContexts);
3571 for (llvm::SmallVector<DeclContext*, 4>::iterator declIter = allDeclContexts.begin(), declEnd = allDeclContexts.end();
3572 declIter != declEnd; ++declIter) {
3574 for (clang::DeclContext::decl_iterator DI = (*declIter)->decls_begin(),
3575 DE = (*declIter)->decls_end(); DI != DE; ++DI) {
3576 if (
const clang::EnumDecl* ED = dyn_cast<clang::EnumDecl>(*DI)) {
3579 PrintingPolicy Policy(ED->getASTContext().getPrintingPolicy());
3580 llvm::raw_string_ostream stream(buf);
3582 Policy.AnonymousTagLocations =
false;
3583 ED->getNameForDiagnostic(stream, Policy,
false);
3587 const char*
name = buf.c_str();
3589 enumList.
Get(ED, name);
3611 D =
fInterpreter->getCI()->getASTContext().getTranslationUnitDecl();
3615 if (
const clang::DeclContext* DC = dyn_cast<clang::DeclContext>(D)) {
3616 cling::Interpreter::PushTransactionRAII deserRAII(
fInterpreter);
3618 llvm::SmallVector< DeclContext *, 4> allDeclContexts;
3619 const_cast< clang::DeclContext *
>(DC)->collectAllContexts(allDeclContexts);
3620 for (llvm::SmallVector<DeclContext*, 4>::iterator declIter = allDeclContexts.begin(),
3621 declEnd = allDeclContexts.end(); declIter != declEnd; ++declIter) {
3623 for (clang::DeclContext::decl_iterator DI = (*declIter)->decls_begin(),
3624 DE = (*declIter)->decls_end(); DI != DE; ++DI) {
3625 if (
const clang::FunctionTemplateDecl* FTD = dyn_cast<clang::FunctionTemplateDecl>(*DI)) {
3626 funcTempList->
Get(FTD);
3724 if (llvm::isa<clang::NamespaceDecl>(cli->
GetDecl())) {
3733 Error(
"GenerateTClass",
3734 "Cannot find %s::Class_Version()! Class version might be wrong.",
3741 if (newvers == -1) {
3749 newvers = callfunc.
ExecInt(0);
3751 Error(
"GenerateTClass",
3752 "Cannot invoke %s::Class_Version()! Class version might be wrong.",
3756 if (newvers != oldvers) {
3773 static void GenerateTClass_GatherInnerIncludes(cling::Interpreter *interp,
TString &includes,
TClingClassInfo *info)
3777 const clang::ClassTemplateSpecializationDecl *templateCl
3778 = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(info->
GetDecl());
3780 for(
unsigned int i=0; i < templateCl->getTemplateArgs().size(); ++i) {
3781 const clang::TemplateArgument &arg( templateCl->getTemplateArgs().get(i) );
3785 if (!uType->isFundamentalType() && !uType->isEnumeralType()) {
3787 const clang::CXXRecordDecl *argdecl = uType->getAsCXXRecordDecl();
3790 TClingClassInfo subinfo(interp,*(argdecl->getASTContext().getRecordType(argdecl).getTypePtr()));
3791 GenerateTClass_GatherInnerIncludes(interp, includes, &subinfo);
3794 llvm::raw_string_ostream OS(Result);
3795 arg.print(argdecl->getASTContext().getPrintingPolicy(),OS);
3796 Warning(
"TCling::GenerateTClass",
"Missing header file for %s",OS.str().c_str());
3811 if (!info || !info->
IsValid()) {
3812 Fatal(
"GenerateTClass",
"Requires a valid ClassInfo object");
3817 std::string classname;
3821 Info(
"GenerateTClass",
"Will (try to) generate the compiled TClass for %s.",classname.c_str());
3825 GenerateTClass_GatherInnerIncludes(
fInterpreter,includes,info);
3831 Error(
"GenerateTClass",
"Even though the dictionary generation for %s seemed successful we can't find the TClass bootstrap!",classname.c_str());
3837 cl =
new TClass(classinfo, version, 0, 0, -1, -1, silent);
3843 cl =
new TClass(classinfo, 1, 0, 0, -1, -1, silent);
3868 if (classes == 0 || classes[0] == 0) {
3872 std::vector<std::string> listClasses;
3874 const char* current = classes, *prev = classes;
3878 if (*current ==
';') {
3879 listClasses.push_back(std::string(prev, current - prev));
3882 else if (*(current + 1) == 0) {
3883 listClasses.push_back(std::string(prev, current + 1 - prev));
3887 std::vector<std::string> listIncludes;
3889 const char* current = includes, *prev = includes;
3893 if (*current ==
';') {
3894 listIncludes.push_back(std::string(prev, current - prev));
3897 else if (*(current + 1) == 0) {
3898 listIncludes.push_back(std::string(prev, current + 1 - prev));
3904 std::vector<std::string>(), std::vector<std::string>());
3925 if (
const ValueDecl* decl = (
const ValueDecl*) d){
3928 if (hasIoName && ioName != name)
return 0;
3946 const clang::Decl* possibleEnum = 0;
3951 const clang::DeclContext* dc = 0;
3952 if (
const clang::Decl* D = cci->
GetDecl()) {
3953 if (!(dc = dyn_cast<clang::NamespaceDecl>(D))) {
3954 dc = dyn_cast<clang::RecordDecl>(D);
3959 possibleEnum = cling::utils::Lookup::Named(&
fInterpreter->getSema(),
name, dc);
3961 Error(
"TCling::GetEnum",
"DeclContext not found for %s .\n", name);
3966 possibleEnum = cling::utils::Lookup::Named(&
fInterpreter->getSema(),
name);
3968 if (possibleEnum && (possibleEnum != (clang::Decl*)-1)
3969 && isa<clang::EnumDecl>(possibleEnum)) {
3970 return possibleEnum;
3982 llvm::StringRef mangled_name = gv->getName();
3997 std::string scopename(demangled_name_c);
3998 free(demangled_name_c);
4004 std::string dataname;
4006 if (!strncmp(scopename.c_str(),
"typeinfo for ",
sizeof(
"typeinfo for ")-1)) {
4007 scopename.erase(0,
sizeof(
"typeinfo for ")-1);
4008 }
else if (!strncmp(scopename.c_str(),
"vtable for ",
sizeof(
"vtable for ")-1)) {
4009 scopename.erase(0,
sizeof(
"vtable for ")-1);
4012 std::string::size_type pos = scopename.rfind(
'(');
4013 if (pos != std::string::npos) {
4017 pos = scopename.rfind(
':');
4018 if (pos != std::string::npos) {
4019 if ((pos != 0) && (scopename[pos-1] ==
':')) {
4020 dataname = scopename.substr(pos+1);
4021 scopename.erase(pos-1);
4025 dataname = scopename;
4033 if (scopename.size()) {
4049 Error(
"GetDataMemberWithValue()",
"not implemented");
4059 Error(
"GetDataMemberAtAddr()",
"not implemented");
4069 const char* params,
Bool_t objectIsConst )
4081 func.
SetFunc(&gcl, method, params, &offset);
4087 return mangled_name;
4102 GetMethod(method, proto, objectIsConst, 0 , mode).GetMangledName();
4114 const char* params,
Bool_t objectIsConst )
4126 func.
SetFunc(&gcl, method, params, &offset);
4155 std::vector<DeclId_t>& res)
const 4158 const clang::Decl* CtxDecl
4160 S.Context.getTranslationUnitDecl();
4161 const clang::DeclContext*
4162 DeclCtx = llvm::dyn_cast<
const clang::RecordDecl>(CtxDecl);
4164 DeclCtx = dyn_cast<clang::NamespaceDecl>(CtxDecl);
4165 if (!DeclCtx)
return;
4166 clang::DeclarationName DName
4167 = &S.Context.Idents.get(funcname);
4168 clang::LookupResult
R(S, DName, clang::SourceLocation(),
4169 Sema::LookupOrdinaryName, clang::Sema::ForRedeclaration);
4170 S.LookupQualifiedName(R, const_cast<DeclContext*>(DeclCtx));
4171 if (R.empty())
return;
4173 res.reserve(res.size() + (R.end() - R.begin()));
4174 for (clang::LookupResult::iterator IR = R.begin(), ER = R.end();
4176 if (
const clang::FunctionDecl* FD
4177 = llvm::dyn_cast<const clang::FunctionDecl>(*IR)) {
4178 if (!FD->getDescribedFunctionTemplate()) {
4322 func.
SetFunc(&cl,
function, params, &offset);
4338 const char* params,
Bool_t objectIsConst,
int* error)
4351 void* address = (
void*)((
Long_t)addr + offset);
4358 const char* params,
int* error)
4360 Execute(obj,cl,method,params,
false,error);
4375 Error(
"Execute",
"No method was defined");
4384 if (argc > nparms) {
4385 Error(
"Execute",
"Too many parameters to call %s, got %d but expected at most %d.",method->
GetName(),argc,nparms);
4388 if (nparms != argc) {
4398 Int_t firstDefault = -1;
4399 for (
Int_t i = 0; i < nparms; i ++) {
4406 if (firstDefault >= 0) {
4407 Error(
"Execute",
"Too few arguments to call %s, got only %d but expected at least %d and at most %d.",method->
GetName(),argc,firstDefault,nparms);
4409 Error(
"Execute",
"Too few arguments to call %s, got only %d but expected %d.",method->
GetName(),argc,nparms);
4415 const char* listpar =
"";
4420 for (
Int_t i = 0; i < argc; i ++) {
4429 chpar += (nxtpar->String()).
ReplaceAll(
"\"",
"\\\"");
4436 complete += nxtpar->String();
4439 listpar = complete.
Data();
4457 const CXXMethodDecl * mdecl = dyn_cast<CXXMethodDecl>(minfo->
GetMethodDecl());
4459 void* address = (
void*)((
Long_t)addr + offset);
4466 const void* args[] ,
4471 Error(
"ExecuteWithArgsAndReturn",
"No method was defined");
4477 func.ExecWithArgsAndReturn(address, args, nargs, ret);
4498 Warning(
"GetTopLevelMacroName",
"Must change return type!");
4545 #if defined(R__MUST_REVISIT) 4546 #if R__MUST_REVISIT(6,0) 4547 Warning(
"GetCurrentMacroName",
"Must change return type!");
4560 TTHREAD_TLS(
char*) t = 0;
4561 TTHREAD_TLS(
unsigned int) tlen = 0;
4563 unsigned int dlen = strlen(typeDesc);
4566 t =
new char[dlen + 1];
4569 const char* s, *template_start;
4570 if (!strstr(typeDesc,
"(*)(")) {
4571 s = strchr(typeDesc,
' ');
4572 template_start = strchr(typeDesc,
'<');
4573 if (!strcmp(typeDesc,
"long long")) {
4574 strlcpy(t, typeDesc, dlen + 1);
4576 else if (!strncmp(typeDesc,
"unsigned ", s + 1 - typeDesc)) {
4577 strlcpy(t, typeDesc, dlen + 1);
4583 else if (s && (template_start == 0 || (s < template_start))) {
4584 strlcpy(t, s + 1, dlen + 1);
4587 strlcpy(t, typeDesc, dlen + 1);
4591 strlcpy(t, typeDesc, dlen + 1);
4594 while (l > 0 && (t[l - 1] ==
'*' || t[l - 1] ==
'&')) {
4608 const std::map<char, unsigned int> keyLenMap = {{
'c',6},{
'n',10},{
't',8},{
'h',7},{
'e',5},{
'v',4}};
4610 if (rootmapfile && *rootmapfile) {
4614 std::ifstream
file(rootmapfile);
4615 std::string
line; line.reserve(200);
4616 std::string lib_name; line.reserve(100);
4617 bool newFormat=
false;
4618 while (getline(file, line,
'\n')) {
4620 (strstr(line.c_str(),
"Library.")!=
nullptr || strstr(line.c_str(),
"Declare.")!=
nullptr)) {
4626 if (line.compare(0, 9,
"{ decls }") == 0) {
4629 while (getline(file, line,
'\n')) {
4630 if (line[0] ==
'[')
break;
4631 uniqueString->
Append(line);
4634 const char firstChar=line[0];
4635 if (firstChar ==
'[') {
4637 auto brpos = line.find(
']');
4638 if (brpos == string::npos)
continue;
4639 lib_name = line.substr(1, brpos-1);
4641 while( lib_name[nspaces] ==
' ' ) ++nspaces;
4642 if (nspaces) lib_name.replace(0, nspaces,
"");
4644 TString lib_nameTstr(lib_name.c_str());
4645 TObjArray* tokens = lib_nameTstr.Tokenize(
" ");
4649 Info(
"ReadRootmapFile",
"new section for %s", lib_nameTstr.Data());
4652 Info(
"ReadRootmapFile",
"section for %s (library does not exist)", lib_nameTstr.Data());
4659 auto keyLenIt = keyLenMap.find(firstChar);
4660 if (keyLenIt == keyLenMap.end())
continue;
4661 unsigned int keyLen = keyLenIt->second;
4663 const char *keyname = line.c_str()+keyLen;
4665 Info(
"ReadRootmapFile",
"class %s in %s", keyname, lib_name.c_str());
4668 if(lib_name != isThere->GetValue()){
4669 if (firstChar ==
'n') {
4671 Info(
"ReadRootmapFile",
"namespace %s found in %s is already in %s",
4672 keyname, lib_name.c_str(), isThere->GetValue());
4673 }
else if (firstChar ==
'h'){
4675 lib_name+=isThere->GetValue();
4679 Warning(
"ReadRootmapFile",
"%s %s found in %s is already in %s", line.substr(0, keyLen).c_str(),
4680 keyname, lib_name.c_str(), isThere->GetValue());
4684 Info(
"ReadRootmapFile",
"Key %s was already defined for %s", keyname, lib_name.c_str());
4725 #if defined(R__MACOSX) && (TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR) 4757 using namespace clang;
4759 class ExtVisibleStorageAdder:
public RecursiveASTVisitor<ExtVisibleStorageAdder>{
4765 ExtVisibleStorageAdder(std::unordered_set<const NamespaceDecl*>& nsSet): fNSSet(nsSet) {};
4766 bool VisitNamespaceDecl(NamespaceDecl* nsDecl) {
4770 nsDecl->setHasExternalVisibleStorage();
4771 fNSSet.insert(nsDecl);
4775 std::unordered_set<const NamespaceDecl*>& fNSSet;
4821 for (
Int_t j = 0; j < i; j++) {
4832 Info(
"LoadLibraryMap",
"%s", d.
Data());
4843 Info(
"LoadLibraryMap",
" rootmap file: %s", p.
Data());
4865 Warning(
"LoadLibraryMap",
"please rename %s to end with \".rootmap\"", p.
Data());
4878 if (rootmapfile && *rootmapfile) {
4885 else if (res == -3) {
4895 while ((rec = (
TEnvRec*) next())) {
4897 if (!strncmp(cls.
Data(),
"Library.", 8) && cls.
Length() > 8) {
4916 Info(
"LoadLibraryMap",
"class %s in %s", cls.
Data(), wlib);
4919 Info(
"LoadLibraryMap",
"class %s in %s (library does not exist)", cls.
Data(), lib);
4934 else if (!strncmp(cls.
Data(),
"Declare.", 8) && cls.
Length() > 8) {
4944 cling::Transaction* T =
nullptr;
4946 assert(cling::Interpreter::kSuccess == compRes &&
"A declaration in a rootmap could not be compiled");
4948 if (compRes!=cling::Interpreter::kSuccess){
4950 "Problems in %s declaring '%s' were encountered.", rootmapfile, uniqueString.
Data()) ;
4955 for (
auto declIt = T->decls_begin(); declIt < T->decls_end(); ++declIt) {
4956 if (declIt->m_DGR.isSingleDecl()) {
4957 if (Decl* D = declIt->m_DGR.getSingleDecl()) {
4958 if (NamespaceDecl* NSD = dyn_cast<NamespaceDecl>(D)) {
4959 evsAdder.TraverseDecl(NSD);
4994 for (
Int_t ilib = 0; ilib < nrSharedLibs; ilib++) {
5001 TString rootMapBaseStr = sharedLibBaseStr;
5002 if (sharedLibBaseStr.
EndsWith(
".dll")) {
5005 else if (sharedLibBaseStr.
EndsWith(
".DLL")) {
5008 else if (sharedLibBaseStr.
EndsWith(
".so")) {
5011 else if (sharedLibBaseStr.
EndsWith(
".sl")) {
5014 else if (sharedLibBaseStr.
EndsWith(
".dl")) {
5017 else if (sharedLibBaseStr.
EndsWith(
".a")) {
5021 Error(
"ReloadAllSharedLibraryMaps",
"Unknown library type %s", sharedLibBaseStr.
Data());
5025 rootMapBaseStr +=
".rootmap";
5028 Error(
"ReloadAllSharedLibraryMaps",
"Could not find rootmap %s in path", rootMap);
5035 Error(
"ReloadAllSharedLibraryMaps",
"Error loading map %s", rootMap);
5070 if (!
fMapfile || !library || !*library) {
5078 size_t len = libname.
Length();
5083 while ((rec = (
TEnvRec *) next())) {
5094 if (!strncmp(cls.
Data(),
"Library.", 8) && cls.
Length() > 8) {
5103 if (!strncmp(lib, libname.
Data(), len)) {
5105 Error(
"UnloadLibraryMap",
"entry for <%s, %s> not found in library map table", cls.
Data(), lib);
5113 TString library_rootmap(library);
5114 if (!library_rootmap.
EndsWith(
".rootmap"))
5115 library_rootmap.
Append(
".rootmap");
5170 free(demangled_name);
5186 std::string demangled_name(demangled_name_c);
5187 free(demangled_name_c);
5200 result =
AutoLoad(demangled_name.c_str(), knowDictNotLoaded);
5225 Info(
"TCling::AutoLoad",
5226 "Trying to autoload for %s", cls);
5232 Info(
"TCling::AutoLoad",
5233 "Disabled due to gROOT or gInterpreter being invalid/not ready (the class name is %s)", cls);
5240 Info(
"TCling::AutoLoad",
5241 "Explicitly disabled (the class name is %s)", cls);
5262 if (
gROOT->LoadClass(cls, deplib) == 0) {
5264 Info(
"TCling::AutoLoad",
5265 "loaded dependent library %s for %s", deplib, cls);
5269 Error(
"TCling::AutoLoad",
5270 "failure loading dependent library %s for %s",
5275 if (lib && lib[0]) {
5276 if (
gROOT->LoadClass(cls, lib) == 0) {
5278 Info(
"TCling::AutoLoad",
5279 "loaded library %s for %s", lib, cls);
5284 Error(
"TCling::AutoLoad",
5285 "failure loading library %s for %s", lib, cls);
5300 cling::Interpreter *interpreter)
5303 Sema &SemaR = interpreter->getSema();
5304 ASTContext&
C = SemaR.getASTContext();
5305 Preprocessor &PP = SemaR.getPreprocessor();
5306 Parser&
P =
const_cast<Parser&
>(interpreter->getParser());
5307 Preprocessor::CleanupAndRestoreCacheRAII cleanupRAII(PP);
5308 Parser::ParserCurTokRestoreRAII savedCurToken(P);
5311 Token& Tok =
const_cast<Token&
>(P.getCurToken());
5312 Tok.setKind(tok::semi);
5318 Sema::ContextAndScopeRAII pushedDCAndS(SemaR, C.getTranslationUnitDecl(),
5320 std::string code = gNonInterpreterClassDef ;
5327 code += (
"#include \"");
5331 code += (
"#ifdef __ROOTCLING__\n" 5332 "#undef __ROOTCLING__\n" 5333 + gInterpreterClassDef +
5336 cling::Interpreter::CompilationResult cr;
5342 clangDiagSuppr diagSuppr(SemaR.getDiagnostics());
5344 #if defined(R__MUST_REVISIT) 5345 #if R__MUST_REVISIT(6,2) 5346 Warning(
"TCling::RegisterModule",
"Diagnostics suppression should be gone by now.");
5350 cr = interpreter->parseForModule(code);
5368 Int_t nHheadersParsed = 0;
5371 bool skipFirstEntry =
false;
5372 std::vector<std::string> autoparseKeys;
5373 if (strchr(cls,
'<')) {
5379 if (!autoparseKeys.empty()){
5380 TString templateName(autoparseKeys[0]);
5381 auto tokens = templateName.
Tokenize(
"::");
5382 clang::NamedDecl* previousScopeAsNamedDecl =
nullptr;
5383 clang::DeclContext* previousScopeAsContext =
fInterpreter->getCI()->getASTContext().getTranslationUnitDecl();
5385 previousScopeAsContext =
fInterpreter->getSema().getStdNamespace();
5386 for (
auto const scopeObj : *tokens){
5387 auto scopeName = ((
TObjString*) scopeObj)->String().Data();
5388 previousScopeAsNamedDecl = cling::utils::Lookup::Named(&
fInterpreter->getSema(), scopeName, previousScopeAsContext);
5390 if ((clang::NamedDecl*)-1 == previousScopeAsNamedDecl)
break;
5391 previousScopeAsContext = llvm::dyn_cast_or_null<clang::DeclContext>(previousScopeAsNamedDecl);
5392 if (!previousScopeAsContext)
break;
5396 if ((clang::NamedDecl*)-1 != previousScopeAsNamedDecl) {
5397 if (
auto templateDecl = llvm::dyn_cast_or_null<clang::ClassTemplateDecl>(previousScopeAsNamedDecl)) {
5398 if (
auto templatedDecl = templateDecl->getTemplatedDecl()) {
5399 skipFirstEntry =
nullptr != templatedDecl->getDefinition();
5406 if (topLevel) autoparseKeys.emplace_back(cls);
5408 for (
const auto & apKeyStr : autoparseKeys) {
5409 if (skipFirstEntry) {
5410 skipFirstEntry=
false;
5413 if (apKeyStr.empty())
continue;
5414 const char *apKey = apKeyStr.c_str();
5418 Info(
"TCling::AutoParse",
5419 "Starting autoparse for %s\n", apKey);
5424 const cling::Transaction *T =
fInterpreter->getCurrentTransaction();
5426 auto const &hNamesPtrs = iter->second;
5428 Info(
"TCling::AutoParse",
5429 "We can proceed for %s. We have %s headers.", apKey, std::to_string(hNamesPtrs.size()).c_str());
5431 for (
auto & hName : hNamesPtrs) {
5433 if (0 !=
fPayloads.count(normNameHash)) {
5434 float initRSSval=0.f, initVSIZEval=0.f;
5436 (
void) initVSIZEval;
5439 "Parsing full payload for %s", apKey);
5446 if (cRes != cling::Interpreter::kSuccess) {
5447 if (hName[0] ==
'\n')
5448 Error(
"AutoParse",
"Error parsing payload code for class %s with content:\n%s", apKey, hName);
5457 Info(
"Autoparse",
">>> RSS key %s - before %.3f MB - after %.3f MB - delta %.3f MB", apKey, initRSSval, endRSSval, endRSSval-initRSSval);
5458 Info(
"Autoparse",
">>> VSIZE key %s - before %.3f MB - after %.3f MB - delta %.3f MB", apKey, initVSIZEval, endVSIZEval, endVSIZEval-initVSIZEval);
5464 "Parsing single header %s", hName);
5467 if (cRes != cling::Interpreter::kSuccess) {
5468 Error(
"AutoParse",
"Error parsing headerfile %s for class %s.", hName, apKey);
5480 if (strchr(apKey,
'<')) {
5487 return nHheadersParsed;
5508 Info(
"TCling::AutoParse",
5509 "Trying to autoparse for %s", cls);
5525 if (nHheadersParsed != 0) {
5544 return nHheadersParsed > 0 ? 1 : 0;
5557 mangled_name.c_str())) {
5568 std::string
name(demangled_name_c);
5569 free(demangled_name_c);
5577 if (!strncmp(name.c_str(),
"typeinfo for ",
sizeof(
"typeinfo for ")-1)) {
5578 name.erase(0,
sizeof(
"typeinfo for ")-1);
5579 }
else if (!strncmp(name.c_str(),
"vtable for ",
sizeof(
"vtable for ")-1)) {
5580 name.erase(0,
sizeof(
"vtable for ")-1);
5581 }
else if (!strncmp(name.c_str(),
"operator",
sizeof(
"operator")-1)
5582 && !isalnum(name[
sizeof(
"operator")])) {
5584 name.erase(0,
sizeof(
"operator")-1);
5585 std::string::size_type pos = name.rfind(
'(');
5586 if (pos != std::string::npos) {
5587 name.erase(0, pos + 1);
5588 pos = name.find(
",");
5589 if (pos != std::string::npos) {
5593 pos = name.rfind(
" const");
5594 if (pos != std::string::npos) {
5595 name.erase(pos, strlen(
" const"));
5597 while (!name.empty() && strchr(
"&*", name.back()))
5598 name.erase(name.length() - 1);
5602 std::string::size_type pos = name.rfind(
'(');
5603 if (pos != std::string::npos) {
5607 pos = name.rfind(
':');
5608 if (pos != std::string::npos) {
5609 if ((pos != 0) && (name[pos-1] ==
':')) {
5626 while (libs.
Tokenize(lib, posLib)) {
5636 void* addr = llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(mangled_name.c_str());
5663 const NamedDecl* ND =
static_cast<const NamedDecl*
>(vTD);
5664 const TagDecl* td = dyn_cast<TagDecl>(ND);
5668 tdDef = td->getDefinition();
5674 if (llvm::isa<clang::FunctionDecl>(td->getDeclContext())) {
5678 clang::QualType
type( td->getTypeForDecl(), 0 );
5680 auto declName=ND->getNameAsString();
5688 name = ND->getNameAsString();
5703 const TagDecl* tdOld = llvm::dyn_cast_or_null<TagDecl>(cci->
GetDecl());
5704 if (!tdOld || (tdDef && tdDef != tdOld)) {
5761 std::set<TClass*> modifiedTClasses;
5766 bool isTUTransaction =
false;
5767 if (!T.empty() && T.decls_begin() + 1 == T.decls_end() && !T.hasNestedTransactions()) {
5768 clang::Decl* FirstDecl = *(T.decls_begin()->m_DGR.begin());
5769 if (llvm::isa<clang::TranslationUnitDecl>(FirstDecl)) {
5772 isTUTransaction =
true;
5776 std::set<const void*> TransactionDeclSet;
5777 if (!isTUTransaction && T.decls_end() - T.decls_begin()) {
5778 const clang::Decl* WrapperFD = T.getWrapperFD();
5779 for (cling::Transaction::const_iterator
I = T.decls_begin(),
E = T.decls_end();
5781 if (
I->m_Call != cling::Transaction::kCCIHandleTopLevelDecl
5782 &&
I->m_Call != cling::Transaction::kCCIHandleTagDeclDefinition)
5785 for (DeclGroupRef::const_iterator DI =
I->m_DGR.begin(),
5786 DE =
I->m_DGR.end(); DI != DE; ++DI) {
5787 if (*DI == WrapperFD)
5789 TransactionDeclSet.insert(*DI);
5790 ((
TCling*)
gCling)->HandleNewDecl(*DI,
false, modifiedTClasses);
5797 for (cling::Transaction::const_iterator
I = T.deserialized_decls_begin(),
5798 E = T.deserialized_decls_end();
I !=
E; ++
I) {
5799 for (DeclGroupRef::const_iterator DI =
I->m_DGR.begin(),
5800 DE =
I->m_DGR.end(); DI != DE; ++DI)
5801 if (TransactionDeclSet.find(*DI) == TransactionDeclSet.end()) {
5817 std::vector<TClass*> modifiedTClassesDiff(modifiedTClasses.size());
5818 std::vector<TClass*>::iterator it;
5819 it = set_difference(modifiedTClasses.begin(), modifiedTClasses.end(),
5822 modifiedTClassesDiff.begin());
5823 modifiedTClassesDiff.resize(it - modifiedTClassesDiff.begin());
5826 ((
TCling*)
gCling)->GetModTClasses().insert(modifiedTClassesDiff.begin(),
5827 modifiedTClassesDiff.end());
5828 for (std::vector<TClass*>::const_iterator
I = modifiedTClassesDiff.begin(),
5829 E = modifiedTClassesDiff.end();
I !=
E; ++
I) {
5831 if (!
gROOT->GetListOfClasses()->FindObject(*
I)) {
5835 cling::Interpreter::PushTransactionRAII RAII(
fInterpreter);
5855 for (DeclContext::decl_iterator RI = DC->decls_begin(), RE = DC->decls_end(); RI != RE; ++RI) {
5856 if (isa<VarDecl>(*RI) || isa<FieldDecl>(*RI)) {
5857 const clang::ValueDecl* VD = dyn_cast<ValueDecl>(*RI);
5861 datamembers->
Unload(var);
5864 }
else if (
const FunctionDecl* FD = dyn_cast<FunctionDecl>(*RI)) {
5867 functions->
Unload(
function);
5868 function->Update(0);
5870 }
else if (
const EnumDecl* ED = dyn_cast<EnumDecl>(*RI)) {
5878 if (enumConst && enumConst->IsValid()) {
5879 datamembers->
Unload(enumConst);
5880 enumConst->Update(0);
5886 }
else if (
const FunctionTemplateDecl* FTD = dyn_cast<FunctionTemplateDecl>(*RI)) {
5888 if (functiontemplate) {
5889 functiontemplates->
Unload(functiontemplate);
5890 functiontemplate->
Update(0);
5907 cling::Transaction::const_nested_iterator iNested = T.nested_begin();
5908 for(cling::Transaction::const_iterator
I = T.decls_begin(),
E = T.decls_end();
5910 if (
I->m_Call == cling::Transaction::kCCIHandleVTable)
5913 if (
I->m_Call == cling::Transaction::kCCINone) {
5919 for (DeclGroupRef::const_iterator DI =
I->m_DGR.begin(),
5920 DE =
I->m_DGR.end(); DI != DE; ++DI) {
5924 if ( (*DI)->isFromASTFile() )
5928 if (isa<VarDecl>(*DI) || isa<EnumConstantDecl>(*DI)) {
5946 }
else if (
const FunctionDecl* FD = dyn_cast<FunctionDecl>(*DI)) {
5948 if (
function && function->IsValid()) {
5949 functions->
Unload(
function);
5950 function->Update(0);
5953 }
else if (
const FunctionTemplateDecl* FTD = dyn_cast<FunctionTemplateDecl>(*DI)) {
5955 if (functiontemplate) {
5956 functiontemplates->
Unload(functiontemplate);
5957 functiontemplate->
Update(0);
5960 }
else if (
const EnumDecl* ED = dyn_cast<EnumDecl>(*DI)) {
5963 TIter iEnumConst(
e->GetConstants());
5969 globals->
Unload(enumConst);
5970 enumConst->Update(0);
5978 }
else if (
const clang::RecordDecl* RD = dyn_cast<RecordDecl>(*DI)) {
5979 std::vector<TClass*> vectTClass;
5981 if (RD->isCompleteDefinition()) {
5983 for (std::vector<TClass*>::iterator CI = vectTClass.begin(), CE = vectTClass.end();
5986 (*CI)->ResetClassInfo();
5991 }
else if (
const clang::NamespaceDecl* ND = dyn_cast<NamespaceDecl>(*DI)) {
5992 std::vector<TClass*> vectTClass;
5994 for (std::vector<TClass*>::iterator CI = vectTClass.begin(), CE = vectTClass.end();
5997 if (ND->isOriginalNamespace()) {
5998 (*CI)->ResetClassInfo();
6014 std::size_t normNameHash = triter->second;
6020 auto const &hNamesPtrs = iter->second;
6021 for (
auto &hName : hNamesPtrs) {
6023 Info(
"TransactionRollback",
6024 "Restoring ability to autoaparse: %s", hName);
6063 if (!cls || !*cls) {
6071 const char* libs = libs_record->
GetValue();
6072 return (*libs) ? libs : 0;
6089 const char* libs = libs_record->
GetValue();
6090 return (*libs) ? libs : 0;
6105 if (!
fMapfile || !lib || !lib[0]) {
6115 size_t len = libname.
Length();
6116 while ((rec = (
TEnvRec*) next())) {
6117 const char* libs = rec->
GetValue();
6118 if (!strncmp(libs, libname.
Data(), len) && strlen(libs) >= len
6119 && (!libs[len] || libs[len] ==
' ' || libs[len] ==
'.')) {
6132 #if defined(R__MUST_REVISIT) 6133 #if R__MUST_REVISIT(6,2) 6134 Warning(
"IsErrorMessagesEnabled",
"Interface not available yet.");
6146 #if defined(R__MUST_REVISIT) 6147 #if R__MUST_REVISIT(6,2) 6148 Warning(
"SetErrorMessages",
"Interface not available yet.");
6164 llvm::SmallVector<std::string, 10> includePaths;
6166 fInterpreter->GetIncludePaths(includePaths,
false,
true);
6167 if (
const size_t nPaths = includePaths.size()) {
6168 assert(!(nPaths & 1) &&
"GetIncludePath, number of paths and options is not equal");
6170 for (
size_t i = 0; i < nPaths; i += 2) {
6175 if (includePaths[i] !=
"-I")
6209 assert(fout != 0 &&
"DisplayIncludePath, 'fout' parameter is null");
6211 llvm::SmallVector<std::string, 10> includePaths;
6213 fInterpreter->GetIncludePaths(includePaths,
false,
true);
6214 if (
const size_t nPaths = includePaths.size()) {
6215 assert(!(nPaths & 1) &&
"DisplayIncludePath, number of paths and options is not equal");
6217 std::string allIncludes(
"include path:");
6218 for (
size_t i = 0; i < nPaths; i += 2) {
6220 allIncludes += includePaths[i];
6222 if (includePaths[i] !=
"-I")
6224 allIncludes += includePaths[i + 1];
6227 fprintf(fout,
"%s\n", allIncludes.c_str());
6246 #if defined(R__MUST_REVISIT) 6247 #if R__MUST_REVISIT(6,2) 6248 Warning(
"GenericError",
"Interface not available yet.");
6278 Error(
"Getgvp",
"This was controlling the behavior of the wrappers for object construction and destruction.\nThis is now a nop and likely change the behavior of the calling routines.");
6286 Error(
"Getp2f2funcname",
"Will not be implemented: " 6287 "all function pointers are compiled!");
6296 #if defined(R__MUST_REVISIT) 6297 #if R__MUST_REVISIT(6,2) 6298 Warning(
"GetSecurityError",
"Interface not available yet.");
6309 cling::Interpreter::CompilationResult compRes;
6310 cling::MetaProcessor::MaybeRedirectOutputRAII RAII(
fMetaProcessor);
6312 return compRes == cling::Interpreter::kFailure;
6323 return (
fInterpreter->declare(text) == cling::Interpreter::kSuccess);
6331 TTHREAD_TLS_DECL(std::string,buffer);
6333 return buffer.c_str();
6399 #if defined(R__MUST_REVISIT) 6400 #if R__MUST_REVISIT(6,2) 6401 Warning(
"SetErrmsgcallback",
"Interface not available yet.");
6413 Error(
"Setgvp",
"This was controlling the behavior of the wrappers for object construction and destruction.\nThis is now a nop and likely change the behavior of the calling routines.");
6421 Error(
"SetRTLD_NOW()",
"Will never be implemented! Don't use!");
6428 Error(
"SetRTLD_LAZY()",
"Will never be implemented! Don't use!");
6443 cling::DynamicLibraryManager* DLM =
fInterpreter->getDynamicLibraryManager();
6444 std::string canonical = DLM->lookupLibrary(path);
6445 if (canonical.empty()) {
6449 cling::Interpreter::CompilationResult compRes;
6450 cling::MetaProcessor::MaybeRedirectOutputRAII RAII(
fMetaProcessor);
6452 return compRes == cling::Interpreter::kFailure;
6468 std::vector<std::string>& completions)
6477 using namespace cling;
6491 if (value.isValid() && value.needsManagedAllocation()) {
6504 cling::Interpreter *interpreter = ((
TCling*)
gCling)->GetInterpreter();
6514 auto iSpecObj = iSpecObjMap->second.find(Name);
6515 if (iSpecObj != iSpecObjMap->second.end()) {
6517 return iSpecObj->second;
6523 Sema &SemaR = interpreter->getSema();
6524 ASTContext&
C = SemaR.getASTContext();
6525 Preprocessor &PP = SemaR.getPreprocessor();
6526 Parser&
P =
const_cast<Parser&
>(interpreter->getParser());
6527 Preprocessor::CleanupAndRestoreCacheRAII cleanupRAII(PP);
6528 Parser::ParserCurTokRestoreRAII savedCurToken(P);
6531 Token& Tok =
const_cast<Token&
>(P.getCurToken());
6532 Tok.setKind(tok::semi);
6538 Sema::ContextAndScopeRAII pushedDCAndS(SemaR, C.getTranslationUnitDecl(),
6541 TObject* specObj =
gROOT->FindSpecialObject(Name, LookupCtx);
6544 Error(
"GetObjectAddress",
"Got a special object without LookupCtx!");
6558 clang::CXXRecordDecl* klass)
const 6560 using namespace clang;
6561 ASTContext& Ctx = klass->getASTContext();
6562 FriendDecl::FriendUnion friendUnion(
function);
6565 FriendDecl* friendDecl = FriendDecl::Create(Ctx, klass, sl, friendUnion, sl);
6566 klass->pushFriendDecl(friendDecl);
6580 if (func)
return ((
TClingCallFunc*)func)->GetDecl()->getCanonicalDecl();
6651 f->
Exec(address, &val);
6665 const void* args[] ,
6832 f->
SetFunc(ci, method, params, offset);
6841 f->
SetFunc(ci, method, params, objectIsConst, offset);
6869 f->
SetFuncProto(ci, method, proto, objectIsConst, offset, mode);
6879 llvm::SmallVector<clang::QualType, 4> funcProto;
6880 for (std::vector<TypeInfo_t*>::const_iterator iter = proto.begin(), end = proto.end();
6881 iter != end; ++iter) {
6882 funcProto.push_back( ((
TClingTypeInfo*)(*iter))->GetQualType() );
6894 llvm::SmallVector<clang::QualType, 4> funcProto;
6895 for (std::vector<TypeInfo_t*>::const_iterator iter = proto.begin(), end = proto.end();
6896 iter != end; ++iter) {
6897 funcProto.push_back( ((
TClingTypeInfo*)(*iter))->GetQualType() );
6899 f->
SetFuncProto(ci, method, funcProto, objectIsConst, offset, mode);
6914 if (!declid)
return kFALSE;
6916 const clang::Decl *scope;
6918 else scope =
fInterpreter->getCI()->getASTContext().getTranslationUnitDecl();
6920 const clang::Decl *decl =
reinterpret_cast<const clang::Decl*
>(declid);
6921 const clang::DeclContext *ctxt = clang::Decl::castToDeclContext(scope);
6922 if (!decl || !ctxt)
return kFALSE;
6923 if (decl->getDeclContext()->Equals(ctxt))
6925 else if (decl->getDeclContext()->isTransparentContext() &&
6926 decl->getDeclContext()->getParent()->Equals(ctxt))
6998 return TClinginfo->
GetMethodNArg(method, proto, objectIsConst, mode);
7023 TClinginfo->
Init(name);
7032 TClinginfo->
Init(tagnum);
7040 return TClinginfo->
IsBase(name);
7071 return TClinginfo->
IsValidMethod(method, proto,
false, offset, mode);
7079 return TClinginfo->
IsValidMethod(method, proto, objectIsConst, offset, mode);
7087 return TClinginfo->
Next();
7135 return TClinginfo->
Size();
7143 return TClinginfo->
Tagnum();
7159 TTHREAD_TLS_DECL(std::string,
output);
7169 return TClinginfo->
Name();
7177 return TClinginfo->
Title();
7214 ClassInfo_t* base)
const 7227 return TClinginfo->
Next();
7235 return TClinginfo->
Next(onlyDirect);
7243 return TClinginfo->
Offset(address, isDerivedObject);
7256 return TClinginfo->
GetBaseOffset(TClinginfoBase, address, isDerivedObject);
7272 return (ClassInfo_t *)TClinginfo->
GetBase();
7280 return TClinginfo->
Tagnum();
7288 TTHREAD_TLS_DECL(std::string,
output);
7298 return TClinginfo->
Name();
7343 const clang::Decl* decl =
reinterpret_cast<const clang::Decl*
>(declid);
7344 const clang::ValueDecl* vd = llvm::dyn_cast_or_null<clang::ValueDecl>(decl);
7377 return TClinginfo->
Next();
7385 return TClinginfo->
Offset();
7433 return TClinginfo->
Name();
7441 return TClinginfo->
Title();
7448 TTHREAD_TLS_DECL(std::string,
result);
7459 Decl* decl =
static_cast<Decl*
>(
const_cast<void*
>(declId));
7460 ASTContext &
C = decl->getASTContext();
7461 SourceRange commentRange;
7462 decl->addAttr(
new (C) AnnotateAttr( commentRange, C, attribute, 0 ) );
7473 cling::Interpreter &interp,
7476 const clang::TypeDecl* td = llvm::dyn_cast<clang::TypeDecl>(decl->getDeclContext());
7479 clang::QualType qualType(td->getTypeForDecl(),0);
7481 unsigned int level = 0;
7482 for(
size_t cursor = name.length()-1; cursor != 0; --cursor) {
7483 if (name[cursor] ==
'>') ++level;
7484 else if (name[cursor] ==
'<' && level) --level;
7485 else if (level == 0 && name[cursor] ==
':') {
7486 name.erase(0,cursor+1);
7497 if (llvm::isa<clang::CXXConstructorDecl>(decl))
7501 }
else if (llvm::isa<clang::CXXDestructorDecl>(decl))
7504 output.insert(output.begin(),
'~');
7506 llvm::raw_string_ostream stream(output);
7507 auto printPolicy = decl->getASTContext().getPrintingPolicy();
7509 printPolicy.AnonymousTagLocations =
false;
7510 decl->getNameForDiagnostic(stream, printPolicy,
false);
7540 return (FuncTempInfo_t*)
const_cast<void*
>(declid);
7551 return (FuncTempInfo_t*)ft_info;
7571 if (!ft_info)
return 0;
7572 const clang::FunctionTemplateDecl *ft = (
const clang::FunctionTemplateDecl*)ft_info;
7573 return ft->getTemplateParameters()->size();
7582 if (!ft_info)
return 0;
7583 const clang::FunctionTemplateDecl *ft = (clang::FunctionTemplateDecl*)ft_info;
7584 return ft->getTemplateParameters()->getMinRequiredArguments();
7592 if (!ft_info)
return 0;
7597 const clang::FunctionTemplateDecl *ft = (clang::FunctionTemplateDecl*)ft_info;
7599 switch (ft->getAccess()) {
7600 case clang::AS_public:
7603 case clang::AS_protected:
7606 case clang::AS_private:
7609 case clang::AS_none:
7610 if (ft->getDeclContext()->isNamespace())
7618 const clang::FunctionDecl *fd = ft->getTemplatedDecl();
7619 if (
const clang::CXXMethodDecl *md =
7620 llvm::dyn_cast<clang::CXXMethodDecl>(fd)) {
7621 if (md->getTypeQualifiers() & clang::Qualifiers::Const) {
7624 if (md->isVirtual()) {
7630 if (
const clang::CXXConstructorDecl *cd =
7631 llvm::dyn_cast<clang::CXXConstructorDecl>(md)) {
7632 if (cd->isExplicit()) {
7636 else if (
const clang::CXXConversionDecl *cd =
7637 llvm::dyn_cast<clang::CXXConversionDecl>(md)) {
7638 if (cd->isExplicit()) {
7652 if (!ft_info)
return;
7653 const clang::FunctionTemplateDecl *ft = (clang::FunctionTemplateDecl*)ft_info;
7665 if (!ft_info)
return;
7666 const clang::FunctionTemplateDecl *ft = (
const clang::FunctionTemplateDecl*)ft_info;
7670 if (
const RedeclarableTemplateDecl *AnnotFD
7672 if (AnnotateAttr *
A = AnnotFD->getAttr<AnnotateAttr>()) {
7673 output =
A->getAnnotation().str();
7677 if (!ft->isFromASTFile()) {
7727 const clang::Decl* decl =
reinterpret_cast<const clang::Decl*
>(declid);
7729 const clang::FunctionDecl* fd = llvm::dyn_cast_or_null<clang::FunctionDecl>(decl);
7761 return info->
NArg();
7777 return info->
Next();
7801 return (TypeInfo_t*)info->
Type();
7809 TTHREAD_TLS_DECL(
TString, mangled_name);
7811 return mangled_name;
7854 return info->
Title();
7873 if (info && info->
IsValid()) {
7875 clang::QualType QT( typeinfo->
GetQualType().getCanonicalType() );
7876 if (QT->isEnumeralType()) {
7878 }
else if (QT->isPointerType()) {
7880 QT = llvm::cast<clang::PointerType>(QT)->getPointeeType();
7881 if ( QT->isCharType() ) {
7886 }
else if ( QT->isFloatingType() ) {
7887 int sz = typeinfo->
Size();
7888 if (sz == 4 || sz == 8) {
7894 }
else if ( QT->isIntegerType() ) {
7895 int sz = typeinfo->
Size();
7948 return (MethodArgInfo_t*)
7965 return info->
Next();
7989 return info->
Name();
8049 TClinginfo->
Init(name);
8065 return TClinginfo->
Name();
8089 return TClinginfo->
Size();
8139 const char*
name)
const 8143 TClinginfo->
Init(name);
8159 return TClinginfo->
Next();
8175 return TClinginfo->
Size();
8191 return TClinginfo->
Name();
8199 return TClinginfo->
Title();
int TCling__AutoLoadCallback(const char *className)
virtual TObject * FindObject(const TObject *obj) const
Find object using its hash value (returned by its Hash() member).
virtual MethodArgInfo_t * MethodArgInfo_Factory() const
Describe Streamer information for one class version.
const char * GetIncludePath()
Refresh the list of include paths known to the interpreter and return it with -I prepended.
void ResetCaches()
To clean out all caches.
virtual Long_t MethodInfo_Property(MethodInfo_t *minfo) const
virtual Long_t ClassInfo_ClassProperty(ClassInfo_t *info) const
long TypeProperty() const
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
virtual Int_t GetEntries() const
virtual Bool_t AccessPathName(const char *path, EAccessMode mode=kFileExists)
Returns FALSE if one can access a file using the specified access mode.
virtual void SetTempLevel(int val) const
Create / close a scope for temporaries.
const clang::FunctionTemplateDecl * GetFunctionTemplate(const char *fname) const
Ssiz_t Last(char c) const
Find last occurrence of a character c.
virtual void SetRcName(const char *name)
ETupleOrdering
Check in what order the member of a tuple are layout.
TObject * GetObjectAddress(const char *Name, void *&LookupCtx)
If the interpreter encounters Name, check whether that is an object ROOT could retrieve.
A collection of TDataMember objects designed for fast access given a DeclId_t and for keep track of T...
The TEnum class implements the enum type.
virtual DeclId_t GetDataMemberAtAddr(const void *addr) const
Return pointer to cling DeclId for a data member with a given name.
virtual TString SplitAclicMode(const char *filename, TString &mode, TString &args, TString &io) const
This method split a filename of the form: ~~~ {.cpp} [path/]macro.C[+|++[k|f|g|O|c|s|d|v|-]][(args)]...
int TCling__IsAutoLoadNamespaceCandidate(const clang::NamespaceDecl *nsDecl)
This class defines an abstract interface to a generic command line interpreter.
int TCling__CompileMacro(const char *fileName, const char *options)
const char * Name() const
void * GetInterfaceMethod(TClass *cl, const char *method, const char *params, Bool_t objectIsConst=kFALSE)
Return pointer to cling interface function for a method of a class with parameters params (params is ...
static clang::ClassTemplateDecl * FindTemplateInNamespace(clang::Decl *decl)
Find a template decl within N nested namespaces, 0<=N<inf Assumes 1 and only 1 template present and 1...
virtual void SetRTLD_NOW() const
DeclId_t GetFunctionWithValues(ClassInfo_t *cl, const char *method, const char *params, Bool_t objectIsConst=kFALSE)
Return pointer to cling DeclId for a method of a class with a certain prototype, i.e.
void TransactionRollback(const cling::Transaction &T)
virtual int TypedefInfo_Size(TypedefInfo_t *tinfo) const
virtual TVirtualMutex * Factory(Bool_t=kFALSE)=0
virtual void SetAllocunlockfunc(void(*)()) const
[Place holder for Mutex Unlock] Provide the interpreter with a way to release a lock used to protect ...
virtual bool ClassInfo_HasDefaultConstructor(ClassInfo_t *info) const
ROOT::ESTLType IsSTLCont(std::string_view type)
type : type name: vector<list<classA,allocator>,allocator> result: 0 : not stl container code of cont...
void LibraryLoaded(const void *dyLibHandle, const char *canonicalName)
Bool_t HandleNewTransaction(const cling::Transaction &T)
Helper function to increase the internal Cling count of transactions that change the AST...
virtual CallFuncIFacePtr_t CallFunc_IFacePtr(CallFunc_t *func) const
void TCling__UpdateListsOnCommitted(const cling::Transaction &T, cling::Interpreter *)
virtual void PostLoadCheck()
Do the initialization that can only be done after the CINT dictionary has been fully populated and ca...
virtual void BaseClassInfo_Delete(BaseClassInfo_t *bcinfo) const
virtual DataMemberInfo_t * DataMemberInfo_Factory(ClassInfo_t *clinfo=0) const
virtual bool CallFunc_IsValid(CallFunc_t *func) const
static void ConstructorName(std::string &name, const clang::NamedDecl *decl, cling::Interpreter &interp, const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt)
R__EXTERN Int_t gErrorIgnoreLevel
virtual int ClassInfo_Next(ClassInfo_t *info) const
virtual const char * WorkingDirectory()
Return working directory.
virtual const char * DataMemberInfo_TypeName(DataMemberInfo_t *dminfo) const
virtual void CallFunc_ExecWithReturn(CallFunc_t *func, void *address, void *ret) const
This namespace contains pre-defined functions to be used in conjuction with TExecutor::Map and TExecu...
virtual void StackTrace()
Print a stack trace.
std::map< SpecialObjectLookupCtx_t, SpecialObjectMap_t > fSpecialObjectMaps
virtual TypedefInfo_t * TypedefInfo_FactoryCopy(TypedefInfo_t *tinfo) const
virtual TObject * FindObject(const char *name) const
Find an object in this collection using its name.
static Bool_t Check(const char *cname, std::string &normname)
static const char **& GetExtraInterpreterArgs()
static cling::Interpreter::CompilationResult ExecAutoParse(const char *what, Bool_t header, cling::Interpreter *interpreter)
Parse the payload or header.
void RegisterLoadedSharedLibrary(const char *name)
Register a new shared library name with the interpreter; add it to fSharedLibs.
Collectable string class.
static void AddClassToDeclIdMap(TDictionary::DeclId_t id, TClass *cl)
static: Add a TClass* to the map of classes.
const char * Name() const
virtual DeclId_t GetEnum(TClass *cl, const char *name) const
Return pointer to cling Decl of global/static variable that is located at the address given by addr...
R__EXTERN TClassTable * gClassTable
TClass * GetClass() const
const char * GetPrototype(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
void UpdateListsOnCommitted(const cling::Transaction &T)
TDictionary::DeclId_t DeclId_t
virtual int BaseClassInfo_Next(BaseClassInfo_t *bcinfo) const
RooArgList L(const RooAbsArg &v1)
void * llvmLazyFunctionCreator(const std::string &mangled_name)
Autoload a library provided the mangled name of a missing symbol.
TEnum * Find(DeclId_t id) const
Return the TEnum corresponding to the Decl 'id' or NULL if it does not exist.
Dictionary for function template This class describes one single function template.
double ExecDouble(void *address)
void Init(const char *name)
virtual TypeInfo_t * TypeInfo_FactoryCopy(TypeInfo_t *) const
All ROOT classes may have RTTI (run time type identification) support added.
int GetSplit(const char *type, std::vector< std::string > &output, int &nestedLoc, EModType mode=TClassEdit::kNone)
Stores in output (after emptying it) the split type.
virtual void MethodInfo_CreateSignature(MethodInfo_t *minfo, TString &signature) const
static TProtoClass * GetProtoNorm(const char *cname)
Given the class normalized name returns the TClassProto object for the class.
TObject * FindObject(const char *name) const
Find object using its name.
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
int GetMethodNArg(const char *method, const char *proto, Bool_t objectIsConst, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch) const
R__EXTERN TVirtualMutex * gInterpreterMutex
bool TClingLookupHelper__ExistingTypeCheck(const std::string &tname, std::string &result)
Try hard to avoid looking up in the Cling database as this could enduce an unwanted autoparsing...
TList * GetListOfEnums(Bool_t load=kTRUE)
Return a list containing the TEnums of a class.
TString & ReplaceAll(const TString &s1, const TString &s2)
const char * Name() const
bool HasMethod(const char *name) const
void Init(const char *name)
Lookup named typedef and reset the iterator to point to it.
std::atomic< TListOfEnums * > fEnums
virtual CallFunc_t * CallFunc_FactoryCopy(CallFunc_t *func) const
int GetPathInfo(const char *path, Long_t *id, Long_t *size, Long_t *flags, Long_t *modtime)
Get info about a file: id, size, flags, modification time.
void SetFunc(const TClingClassInfo *info, const char *method, const char *arglist, long *poffset)
void Destruct(void *arena, const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
virtual const char * MethodInfo_Title(MethodInfo_t *minfo) const
void SetArgArray(long *argArr, int narg)
virtual TList * GetListOfKeys() const
cling::MetaProcessor * fMetaProcessor
virtual int DataMemberInfo_TypeSize(DataMemberInfo_t *dminfo) const
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
const char * GetFullTypeName() const
Get full type description of typedef, e,g.: "class TDirectory*".
Persistent version of a TClass.
virtual void SetRTLD_LAZY() const
Emulation of the CINT DataMemberInfo class.
TEnum * Get(DeclId_t id, const char *name)
Return (after creating it if necessary) the TEnum describing the enum corresponding to the Decl 'id'...
std::atomic< Bool_t > fHasRootPcmInfo
C++ Property of the class (is abstract, has virtual table, etc.)
TClass * GenerateTClass(const char *classname, Bool_t emulation, Bool_t silent=kFALSE)
Generate a TClass for the given class.
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
void UpdateListOfGlobals()
No op: see TClingCallbacks (used to update the list of globals)
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format...
void UpdateListOfGlobalFunctions()
No op: see TClingCallbacks (used to update the list of global functions)
Emulation of the CINT MethodInfo class.
ptrdiff_t GetBaseOffset(TClingClassInfo *toBase, void *address, bool isDerivedObject)
virtual std::string MethodArgInfo_TypeNormalizedName(MethodArgInfo_t *marginfo) const
const char * Name() const
void SaveContext()
Save the current Cling state.
virtual MethodInfo_t * CallFunc_FactoryMethod(CallFunc_t *func) const
cling::Interpreter * fInterpreter
virtual ClassInfo_t * ClassInfo_Factory(Bool_t all=kTRUE) const
virtual const char * HomeDirectory(const char *userName=0)
Return the user's home directory.
static void RemoveClassDeclId(TDictionary::DeclId_t id)
Long_t Property() const
Set TObject::fBits and fStreamerType to cache information about the class.
virtual BaseClassInfo_t * BaseClassInfo_Factory(ClassInfo_t *info) const
const char * GetClassSharedLibs(const char *cls)
Get the list of shared libraries containing the code for class cls.
const char * GetValue() const
void TCling__DEBUG__dump(clang::DeclContext *DC)
const TClingTypeInfo * Type() const
virtual TObject * FindObject(const char *name) const
Specialize FindObject to do search for the a function just by name or create it if its not already in...
virtual void MethodInfo_Delete(MethodInfo_t *minfo) const
Interface to cling function.
virtual void CallFunc_SetArgArray(CallFunc_t *func, Long_t *paramArr, Int_t nparam) const
virtual const char * TypedefInfo_TrueName(TypedefInfo_t *tinfo) const
Bool_t IsPersistent() const
void TCling__UpdateListsOnUnloaded(const cling::Transaction &T)
virtual TObject * Remove(TObject *obj)
Remove object from array.
TList * GetListOfDataMembers(Bool_t load=kTRUE)
Return list containing the TDataMembers of a class.
bool LoadPCM(TString pcmFileName, const char **headers, void(*triggerFunc)()) const
Tries to load a PCM; returns true on success.
virtual Bool_t IsTreatingNonAccessibleTypes()
virtual FuncTempInfo_t * FuncTempInfo_FactoryCopy(FuncTempInfo_t *) const
Construct a FuncTempInfo_t.
void FullName(std::string &output, const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
Int_t Load(const char *filenam, Bool_t system=kFALSE)
Load a library file in cling's memory.
virtual int Load(const char *module, const char *entry="", Bool_t system=kFALSE)
Load a shared library.
The TEnv class reads config files, by default named .rootrc.
std::string InsertStd(const char *tname)
clang::DeclContext * TCling__DEBUG__getDeclContext(clang::Decl *D)
TClass * GetClass(const std::type_info &typeinfo, Bool_t load) const
Demangle the name (from the typeinfo) and then request the class via the usual name based interface (...
ROOT::TMetaUtils::TNormalizedCtxt * fNormalizedCtxt
TString GetMangledName(TClass *cl, const char *method, const char *params, Bool_t objectIsConst=kFALSE)
Return the cling mangled name for a method of a class with parameters params (params is a string of a...
static int HandleInterpreterException(cling::MetaProcessor *metaProcessor, const char *input_line, cling::Interpreter::CompilationResult &compRes, cling::Value *result)
Let cling process a command line.
static Bool_t HasNoInfoOrEmuOrFwdDeclaredDecl(const char *)
bool HasDefaultConstructor() const
virtual TApplicationImp * GetApplicationImp()
TClingMethodInfo GetMethod(const char *fname) const
TClingTypeInfo * Type() const
virtual const char * DirName(const char *pathname)
Return the directory name in pathname.
virtual const char * MethodInfo_GetMangledName(MethodInfo_t *minfo) const
virtual UInt_t FuncTempInfo_TemplateNargs(FuncTempInfo_t *) const
Return the maximum number of template arguments of the function template described by ft_info...
virtual int DisplayIncludePath(FILE *fout) const
Interface to cling function.
std::vector< std::pair< std::string, int > > FwdDeclArgsToKeepCollection_t
void * fPrevLoadedDynLibInfo
virtual char * Which(const char *search, const char *file, EAccessMode mode=kFileExists)
Find location of file in a search path.
Each ROOT method (see TMethod) has a linked list of its arguments.
virtual const char * BaseClassInfo_Name(BaseClassInfo_t *bcinfo) const
virtual void TypeInfo_Delete(TypeInfo_t *tinfo) const
virtual Long_t CallFunc_ExecInt(CallFunc_t *func, void *address) const
Int_t DeleteVariable(const char *name)
Undeclare obj called name.
virtual int SetClassAutoparsing(int)
Enable/Disable the Autoparsing of headers.
Int_t GetEntriesFast() const
llvm::StringRef ValidArrayIndex() const
virtual int LoadFile(const char *path) const
Load a source file or library called path into the interpreter.
const char * TrueName(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
Get the name of the underlying type of the current typedef.
TString & Prepend(const char *cs)
void SetAutoParsingSuspended(bool val=true)
R__EXTERN TApplication * gApplication
Abstract base class for accessing the data-members of a class.
virtual void TypeInfo_Init(TypeInfo_t *tinfo, const char *funcname) const
TString GetMangledNameWithPrototype(TClass *cl, const char *method, const char *proto, Bool_t objectIsConst=kFALSE, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch)
Return the cling mangled name for a method of a class with a certain prototype, i.e.
std::vector< cling::Value > * fTemporaries
virtual ~TCling()
Destroy the interpreter interface.
virtual const char * DataMemberInfo_Title(DataMemberInfo_t *dminfo) const
virtual void LoadFunctionTemplates(TClass *cl) const
Create list of pointers to function templates for TClass cl.
virtual bool MethodArgInfo_IsValid(MethodArgInfo_t *marginfo) const
virtual bool Update(FuncTempInfo_t *info)
Update the TFunctionTemplate to reflect the new info.
virtual Long_t DataMemberInfo_Property(DataMemberInfo_t *dminfo) const
virtual Long_t TypedefInfo_Property(TypedefInfo_t *tinfo) const
virtual void * ClassInfo_New(ClassInfo_t *info) const
const clang::Type * GetType() const
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
Emulation of the CINT CallFunc class.
virtual int DisplayClass(FILE *fout, const char *name, int base, int start) const
virtual const char * GetTopLevelMacroName() const
Return the file name of the current un-included interpreted file.
virtual TObject * At(Int_t idx) const
Returns the object at position idx. Returns 0 if idx is out of range.
virtual int GetProcInfo(ProcInfo_t *info) const
Returns cpu and memory used by this process into the ProcInfo_t structure.
Bool_t R_ISREG(Int_t mode)
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
virtual void SetDeclAttr(DeclId_t, const char *)
virtual bool ClassInfo_IsValidMethod(ClassInfo_t *info, const char *method, const char *proto, Long_t *offset, ROOT::EFunctionMatchMode=ROOT::kConversionMatch) const
virtual int DataMemberInfo_MaxIndex(DataMemberInfo_t *dminfo, Int_t dim) const
V GetOffset(E val1, E val2, V iso)
void Execute(const char *function, const char *params, int *error=0)
Execute a global function with arguments params.
virtual const char * FindFile(const char *search, TString &file, EAccessMode mode=kFileExists)
Find location of file in a search path.
const char * GetSharedLibDeps(const char *lib)
Get the list a libraries on which the specified lib depends.
virtual bool DiagnoseIfInterpreterException(const std::exception &e) const
static const char * GetMacroPath()
Get macro search path. Static utility function.
virtual void SetValue(const char *name, const char *value, EEnvLevel level=kEnvChange, const char *type=0)
Set the value of a resource or create a new resource.
std::set< size_t > fPayloads
TDictionary * Find(DeclId_t id) const
Return (after creating it if necessary) the TDataMember describing the data member corresponding to t...
const TSeqCollection * GetConstants() const
virtual Long_t GetExecByteCode() const
This routines used to return the address of the internal wrapper function (of the interpreter) that w...
static void Add(const char *cname, Version_t id, const std::type_info &info, DictFuncPtr_t dict, Int_t pragmabits)
Add a class to the class table (this is a static function).
virtual void MethodArgInfo_Delete(MethodArgInfo_t *marginfo) const
std::vector< const char * > fCurExecutingMacros
Bool_t IsValid()
Return true if this data member object is pointing to a currently loaded data member.
virtual int TypeInfo_RefType(TypeInfo_t *) const
const char * Data() const
void AddFriendToClass(clang::FunctionDecl *, clang::CXXRecordDecl *) const
Inject function as a friend into klass.
virtual Long_t BaseClassInfo_Offset(BaseClassInfo_t *toBaseClassInfo, void *address, bool isDerivedObject) const
virtual TObject * FindObject(const char *name) const
Find an object in this collection using its name.
void TCling__DEBUG__decl_dump(void *D)
Int_t UnloadLibraryMap(const char *library)
Unload library map entries coming from the specified library.
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
virtual TEnum * CreateEnum(void *VD, TClass *cl) const
virtual void GenericError(const char *error) const
Let the interpreter issue a generic error, and set its error state.
void ClearStack()
Delete existing temporary values.
virtual const char * GetDirEntry(void *dirp)
Get a directory entry. Returns 0 if no more entries.
virtual void ClassInfo_Init(ClassInfo_t *info, const char *funcname) const
void ResetAll()
Reset the Cling state to its initial state.
void Exec(void *address, TInterpreterValue *interpVal=0)
int ReadRootmapFile(const char *rootmapfile, TUniqueString *uniqueString=nullptr)
Read and parse a rootmapfile in its new format, and return 0 in case of success, -1 if the file has a...
int Next()
Increment the iterator.
void CreateSignature(TString &signature) const
virtual void CallFunc_Init(CallFunc_t *func) const
TInterpreter::CallFuncIFacePtr_t IFacePtr()
Int_t GenerateDictionary(const char *classes, const char *includes=0, const char *options=0)
Generate the dictionary for the C++ classes listed in the first argument (in a semi-colon separated l...
THashTable implements a hash table to store TObject's.
const char * TCling__GetClassSharedLibs(const char *className)
clang::NamespaceDecl * TCling__DEBUG__DCtoNamespace(clang::DeclContext *DC)
void ExecuteWithArgsAndReturn(TMethod *method, void *address, const void *args[]=0, int nargs=0, void *ret=0) const
virtual DeclId_t GetDataMember(ClassInfo_t *cl, const char *name) const
Return pointer to cling Decl of global/static variable that is located at the address given by addr...
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString...
virtual TypedefInfo_t * TypedefInfo_Factory() const
virtual Long_t BaseClassInfo_Property(BaseClassInfo_t *bcinfo) const
virtual void Sleep(UInt_t milliSec)
Sleep milliSec milli seconds.
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
Bool_t CheckClassInfo(const char *name, Bool_t autoload, Bool_t isClassOrNamespaceOnly=kFALSE)
Checks if an entity with the specified name is defined in Cling.
std::atomic< TList * > fBase
virtual void CallFunc_Exec(CallFunc_t *func, void *address) const
Bool_t Declare(const char *code)
Declare code to the interpreter, without any of the interpreter actions that could trigger a re-inter...
std::map< const cling::Transaction *, size_t > fTransactionHeadersMap
virtual UInt_t FuncTempInfo_TemplateMinReqArgs(FuncTempInfo_t *) const
Return the number of required template arguments of the function template described by ft_info...
void ShortType(std::string &answer, int mode)
Return the absolute type of typeDesc into the string answ.
void GetInterpreterTypeName(const char *name, std::string &output, Bool_t full=kFALSE)
The 'name' is known to the interpreter, this function returns the internal version of this name (usua...
The TNamed class is the base class for all named ROOT classes.
void SetObjectValidity(EObjectPointerState val)
void CreateListOfDataMembers(TClass *cl) const
Create list of pointers to data members for TClass cl.
void SetArgs(const char *args)
char * DemangleName(const char *mangled_name, int &errorCode)
void * GetInterfaceMethodWithPrototype(TClass *cl, const char *method, const char *proto, Bool_t objectIsConst=kFALSE, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch)
Return pointer to cling interface function for a method of a class with a certain prototype...
virtual void ClassInfo_DeleteArray(ClassInfo_t *info, void *arena, bool dtorOnly) const
long ClassProperty() const
DeclId_t GetFunctionWithPrototype(ClassInfo_t *cl, const char *method, const char *proto, Bool_t objectIsConst=kFALSE, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch)
Return pointer to cling interface function for a method of a class with a certain prototype...
void Init(TClassEdit::TInterpreterLookupHelper *helper)
virtual MethodInfo_t * MethodInfo_FactoryCopy(MethodInfo_t *minfo) const
void ClearFileBusy()
Reset the interpreter internal state in case a previous action was not correctly terminated.
static void UpdateClassInfo(char *name, Long_t tagnum)
No op: see TClingCallbacks.
TClass * GetClass() const
void CreateListOfBaseClasses(TClass *cl) const
Create list of pointers to base class(es) for TClass cl.
virtual const char * GetDynamicPath()
Return the dynamic path (used to find shared libraries).
virtual Long_t DataMemberInfo_Offset(DataMemberInfo_t *dminfo) const
void Clear()
Clear string without changing its capacity.
virtual Bool_t Declare(const char *code)=0
bool Append(const std::string &str)
Append string to the storage if not added already.
virtual int CompileMacro(const char *filename, Option_t *opt="", const char *library_name="", const char *build_dir="", UInt_t dirmode=0)
This method compiles and loads a shared library containing the code from the file "filename"...
virtual const char * ClassInfo_FileName(ClassInfo_t *info) const
virtual const char * TypeInfo_Name(TypeInfo_t *) const
virtual const char * Getenv(const char *env)
Get environment variable.
virtual const char * MapCppName(const char *) const
Interface to cling function.
TString & Append(const char *cs)
static bool IsEnum(cling::Interpreter *interp, const char *name)
virtual const char * PrependPathName(const char *dir, TString &name)
Concatenate a directory and a file name.
virtual const char * GetCurrentMacroName() const
Return the file name of the currently interpreted file, included or not.
virtual int SetClassAutoloading(int) const
Enable/Disable the Autoloading of libraries.
ULong64_t fTransactionCount
const char * GetDefault() const
Get default value of method argument.
virtual bool ClassInfo_IsBase(ClassInfo_t *info, const char *name) const
char * DemangleTypeIdName(const std::type_info &ti, int &errorCode)
Demangle in a portable way the type id name.
virtual Long_t ClassInfo_GetBaseOffset(ClassInfo_t *fromDerived, ClassInfo_t *toBase, void *address, bool isDerivedObject) const
DeclId_t GetFunction(ClassInfo_t *cl, const char *funcname)
Return pointer to cling interface function for a method of a class with a certain name...
virtual int MethodInfo_NArg(MethodInfo_t *minfo) const
long Property() const
Return a bit mask of metadata about the current typedef.
virtual void Setgvp(Long_t) const
Interface to the cling global object pointer which was controlling the behavior of the wrapper around...
const char * TypeName() const
Long_t ProcessLine(const char *line, EErrorCode *error=0)
virtual Long_t ClassInfo_Property(ClassInfo_t *info) const
virtual bool Update(DataMemberInfo_t *info)
Update the TFunction to reflect the new info.
Emulation of the CINT TypeInfo class.
virtual int TypedefInfo_Next(TypedefInfo_t *tinfo) const
virtual bool TypeInfo_IsValid(TypeInfo_t *tinfo) const
Book space in a file, create I/O buffers, to fill them, (un)compress them.
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
clang::RecordDecl * TCling__DEBUG__DCtoRecordDecl(clang::DeclContext *DC)
This class defines an interface to the cling C++ interpreter.
Bool_t IgnoreDuplicates(Bool_t ignore)
If set to true, no warnings in case of duplicates are issued.
TClass *(* DictFuncPtr_t)()
TVirtualPad is an abstract base class for the Pad and Canvas classes.
DeclId_t GetDeclId(const llvm::GlobalValue *gv) const
Return pointer to cling DeclId for a global value.
const char * TypeTrueName(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
Int_t UnloadAllSharedLibraryMaps()
Unload the library map entries coming from all the loaded shared libraries.
void InitRootmapFile(const char *name)
Create a resource table and read the (possibly) three resource files, i.e $ROOTSYS/etc/system<name> (...
std::string GetLong64_Name(const char *original)
Replace 'long long' and 'unsigned long long' by 'Long64_t' and 'ULong64_t'.
void InspectMembers(TMemberInspector &, const void *obj, const TClass *cl, Bool_t isTransient)
Visit all members over members, recursing over base classes.
virtual bool ClassInfo_IsEnum(const char *name) const
static void TCling__UpdateClassInfo(const NamedDecl *TD)
Update TClingClassInfo for a class (e.g. upon seeing a definition).
void TCling__DEBUG__printName(clang::Decl *D)
EComplexType GetComplexType(const char *)
long ExtraProperty() const
void GetObject(const char *namecycle, T *&ptr)
virtual Long_t DataMemberInfo_TypeProperty(DataMemberInfo_t *dminfo) const
TCppMethod_t GetMethod(TCppScope_t scope, TCppIndex_t imeth)
virtual Bool_t IsCmdThread()
void PrintIntro()
No-op; see TRint instead.
R__EXTERN TVirtualMutex * gGlobalMutex
virtual Int_t ReadFile(const char *fname, EEnvLevel level)
Read and parse the resource file for a certain level.
const Decl * TCling__GetObjectDecl(TObject *obj)
R__EXTERN TROOT * gROOTLocal
void UpdateListOfTypes()
No op: see TClingCallbacks (used to update the list of types)
virtual const char * TypeInfo_TrueName(TypeInfo_t *tinfo) const
virtual std::string MethodInfo_TypeNormalizedName(MethodInfo_t *minfo) const
const char * Name() const
RooArgSet S(const RooAbsArg &v1)
const char * TmpltName() const
UInt_t AutoParseImplRecurse(const char *cls, bool topLevel)
Helper routine for TCling::AutoParse implementing the actual call to the parser and looping over temp...
virtual TList * GetListOfMethodArgs()
Returns methodarg list and additionally updates fDataMember in TMethod by calling FindDataMember();...
virtual void CallFunc_SetArgs(CallFunc_t *func, const char *param) const
const char * TmpltName() const
void Init(const char *name)
bool TCling__TEST_isInvalidDecl(clang::Decl *D)
TClingClassInfo * GetBase() const
std::vector< void * > fRegisterModuleDyLibs
TFunctionTemplate * Get(DeclId_t id)
Return (after creating it if necessary) the TMethod or TFunction describing the function correspondin...
Int_t AutoParse(const char *cls)
Parse the headers relative to the class Returns 1 in case of success, 0 in case of failure...
virtual bool MethodInfo_IsValid(MethodInfo_t *minfo) const
int MaxIndex(int dim) const
void TCling__SplitAclicMode(const char *fileName, string &mode, string &args, string &io, string &fname)
std::vector< std::string > fElements
const char * GetName() const
Returns name of object.
virtual Long_t TypeInfo_Property(TypeInfo_t *tinfo) const
Bool_t EndsWith(const char *pat, ECaseCompare cmp=kExact) const
Return true if string ends with the specified string.
Emulation of the CINT BaseClassInfo class.
TClingMethodInfo * FactoryMethod() const
R__EXTERN TSystem * gSystem
if object ctor succeeded but object should not be used
void * InterfaceMethod(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
virtual const char * DataMemberInfo_TypeTrueName(DataMemberInfo_t *dminfo) const
ptrdiff_t Offset(void *address=0, bool isDerivedObject=true) const
virtual void GetFunctionName(const clang::FunctionDecl *decl, std::string &name) const
Basic data type descriptor (datatype information is obtained from CINT).
void SetFuncProto(const TClingClassInfo *info, const char *method, const char *proto, long *poffset, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch)
virtual void LoadEnums(TListOfEnums &cl) const
Create list of pointers to enums for TClass cl.
std::set< TClass * > & GetModTClasses()
virtual int TypeInfo_Size(TypeInfo_t *tinfo) const
static void UpdateAllCanvases()
Update all canvases at end the terminal input command.
const clang::FunctionDecl * GetMethodDecl() const
const char * TrueName(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
Return the normalized name of the type (i.e.
ClassInfo_t * GetClassInfo() const
virtual CallFunc_t * CallFunc_Factory() const
const char * DefaultValue() const
static Long_t ExecuteFile(const char *file, Int_t *error=0, Bool_t keep=kFALSE)
Execute a file containing a C++ macro (static method).
virtual TEnvRec * Lookup(const char *n)
Loop over all resource records and return the one with name.
TObject * Remove(TObject *obj)
Remove object from the list.
virtual Int_t AutoParse(const char *cls)=0
Collection abstract base class.
Bool_t SetErrorMessages(Bool_t enable=kTRUE)
If error messages are disabled, the interpreter should suppress its failures and warning messages fro...
int TCling__AutoParseCallback(const char *className)
virtual const char * DataMemberInfo_ValidArrayIndex(DataMemberInfo_t *dminfo) const
void SaveGlobalsContext()
Save the current Cling state of global objects.
void UpdateClassInfoWithDecl(const void *vTD)
Internal function. Inform a TClass about its new TagDecl or NamespaceDecl.
virtual Long_t BaseClassInfo_Tagnum(BaseClassInfo_t *bcinfo) const
Bool_t TestBit(UInt_t f) const
virtual Bool_t IsValid()
Return true if this global object is pointing to a currently loaded global.
virtual const char * ClassInfo_Title(ClassInfo_t *info) const
void UpdateListOfLoadedSharedLibraries()
char * Form(const char *fmt,...)
virtual void CallFunc_SetFunc(CallFunc_t *func, ClassInfo_t *info, const char *method, const char *params, Long_t *Offset) const
virtual TypeInfo_t * MethodInfo_Type(MethodInfo_t *minfo) const
Long_t Calc(const char *line, EErrorCode *error=0)
Directly execute an executable statement (e.g.
Int_t RescanLibraryMap()
Scan again along the dynamic path for library maps.
virtual const char * GetName() const
Returns name of object.
The TEnumConstant class implements the constants of the enum type.
virtual const char * Getp2f2funcname(void *receiver) const
virtual bool TypedefInfo_IsValid(TypedefInfo_t *tinfo) const
virtual Bool_t LoadText(const char *text) const
Load the declarations from text into the interpreter.
The ROOT global object gROOT contains a list of all defined classes.
virtual int MethodInfo_Next(MethodInfo_t *minfo) const
clang::QualType GetQualType() const
virtual int MethodInfo_NDefaultArg(MethodInfo_t *minfo) const
virtual int MethodArgInfo_Next(MethodArgInfo_t *marginfo) const
void TCling__PrintStackTrace()
Print a StackTrace!
Global variables class (global variables are obtained from CINT).
void * LazyFunctionCreatorAutoload(const std::string &mangled_name)
Autoload a library based on a missing symbol.
Version_t GetClassVersion() const
Long_t ExecuteMacro(const char *filename, EErrorCode *error=0)
Execute a cling macro.
virtual void Initialize()
Initialize the interpreter, once TROOT::fInterpreter is set.
Bool_t CheckClassTemplate(const char *name)
Return true if there is a class template by the given name ...
static void indent(ostringstream &buf, int indent_level)
THashList * GetTable() const
virtual void CallFunc_SetFuncProto(CallFunc_t *func, ClassInfo_t *info, const char *method, const char *proto, Long_t *Offset, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch) const
Interface to cling function.
bool IsStdClass(const char *type)
return true if the class belongs to the std namespace
virtual void FreeDirectory(void *dirp)
Free a directory.
virtual const char * MethodInfo_GetPrototype(MethodInfo_t *minfo) const
TDictionary::DeclId_t GetDeclId() const
virtual void CallFunc_ExecWithArgsAndReturn(CallFunc_t *func, void *address, const void *args[]=0, int nargs=0, void *ret=0) const
TObject * TCling__GetObjectAddress(const char *Name, void *&LookupCtx)
virtual Bool_t FuncTempInfo_IsValid(FuncTempInfo_t *) const
Check validity of a FuncTempInfo_t.
TObjArray * Tokenize(const TString &delim) const
This function is used to isolate sequential tokens in a TString.
Each class (see TClass) has a linked list of its base class(es).
const char * Name() const
Get the name of the current typedef.
void EnableAutoLoading()
Enable the automatic loading of shared libraries when a class is used that is stored in a not yet loa...
Type
enumeration specifying the integration types.
R__DLLEXPORT void DestroyInterpreter(TInterpreter *interp)
bool IsAutoloadingEnabled()
const char * TypeName() const
TDictionary::DeclId_t DeclId_t
#define R__LOCKGUARD2(mutex)
virtual void CallFunc_Delete(CallFunc_t *func) const
Bool_t CallShowMembers(const void *obj, TMemberInspector &insp, Bool_t isTransient=kFALSE) const
Call ShowMembers() on the obj of this class type, passing insp and parent.
std::unordered_set< const clang::NamespaceDecl * > fNSFromRootmaps
virtual const char * BaseClassInfo_FullName(BaseClassInfo_t *bcinfo) const
virtual MethodInfo_t * MethodInfo_Factory() const
void TCling__GetNormalizedContext(const ROOT::TMetaUtils::TNormalizedCtxt *&normCtxt)
int Size() const
Return the size in bytes of the underlying type of the current typedef.
virtual const void * GetValAddr() const =0
virtual const char * FindDynamicLibrary(TString &lib, Bool_t quiet=kFALSE)
Find a dynamic library using the system search paths.
void EndOfLineAction()
It calls a "fantom" method to synchronize user keyboard input and ROOT prompt line.
std::string GetMangledName() const
TString & Remove(Ssiz_t pos)
const char * Name(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
Bool_t IsLoaded() const
Return true if the shared library of this class is currently in the a process's memory.
void SetClassInfo(TClass *cl, Bool_t reload=kFALSE)
Set pointer to the TClingClassInfo in TClass.
Emulation of the CINT TypedefInfo class.
const clang::Decl * GetDecl() const
const char * TypeName() const
A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum t...
int(* AutoLoadCallBack_t)(const char *)
virtual const char * MethodArgInfo_DefaultValue(MethodArgInfo_t *marginfo) const
virtual const char * ClassInfo_Name(ClassInfo_t *info) const
virtual const char * GetIncludePath()
Get the list of include path.
virtual bool DataMemberInfo_IsValid(DataMemberInfo_t *dminfo) const
int TCling_GenerateDictionary(const std::vector< std::string > &classes, const std::vector< std::string > &headers, const std::vector< std::string > &fwdDecls, const std::vector< std::string > &unknown)
TInterpreterValue * CreateTemporary()
The created temporary must be deleted by the caller.
void GetFunctionOverloads(ClassInfo_t *cl, const char *funcname, std::vector< DeclId_t > &res) const
Insert overloads of name in cl to res.
void UpdateListsOnUnloaded(const cling::Transaction &T)
virtual FuncTempInfo_t * FuncTempInfo_Factory(DeclId_t declid) const
Construct a FuncTempInfo_t.
TObjArray * fStreamerInfo
virtual void FuncTempInfo_Title(FuncTempInfo_t *, TString &name) const
Return the comments associates with this function template.
std::set< size_t > fLookedUpClasses
void UpdateListOfDataMembers(TClass *cl) const
Update the list of pointers to data members for TClass cl This is now a nop.
const char * GetParent() const
void UnloadClassMembers(TClass *cl, const clang::DeclContext *DC)
Helper function to go through the members of a class or namespace and unload them.
EState fState
cached of the streaming method to use
void TCling__LibraryLoadedRTTI(const void *dyLibHandle, const char *canonicalName)
Emulation of the CINT MethodInfo class.
char * DynamicPathName(const char *lib, Bool_t quiet=kFALSE)
Find a dynamic library called lib using the system search paths.
static DictFuncPtr_t GetDict(const char *cname)
Given the class name returns the Dictionary() function of a class (uses hash of name).
virtual Bool_t ClassInfo_Contains(ClassInfo_t *info, DeclId_t declid) const
Return true if the entity pointed to by 'declid' is declared in the context described by 'info'...
TFunction * Find(DeclId_t id) const
Return the TMethod or TFunction describing the function corresponding to the Decl 'id'...
virtual const char * DataMemberInfo_Name(DataMemberInfo_t *dminfo) const
void Unload()
Mark 'all func' as being unloaded.
virtual int DataMemberInfo_ArrayDim(DataMemberInfo_t *dminfo) const
void RegisterTClassUpdate(TClass *oldcl, DictFuncPtr_t dict)
Register classes that already existed prior to their dictionary loading and that already had a ClassI...
Bool_t IsAutoLoadNamespaceCandidate(const char *name)
virtual void CallFunc_ResetArg(CallFunc_t *func) const
virtual void FuncTempInfo_Delete(FuncTempInfo_t *) const
Delete the FuncTempInfo_t.
TDictionary::DeclId_t DeclId_t
void DeleteArray(void *arena, bool dtorOnly, const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
void ResetGlobalVar(void *obj)
Reset the Cling 'user' global objects/variables state to the state saved by the last call to TCling::...
unsigned long long ULong64_t
Print a TSeq at the prompt:
DeclId_t GetFunctionTemplate(ClassInfo_t *cl, const char *funcname)
Return pointer to cling interface function for a method of a class with a certain name...
virtual Long64_t CallFunc_ExecInt64(CallFunc_t *func, void *address) const
void Reset()
Pressing Ctrl+C should forward here.
Int_t LoadLibraryMap(const char *rootmapfile=0)
Load map between class and library.
void CreateListOfMethodArgs(TFunction *m) const
Create list of pointers to method arguments for TMethod m.
TObjArray * fRootmapFiles
double func(double *x, double *p)
virtual void Expand(Int_t newSize)
Expand or shrink the array to newSize elements.
std::set< const char * > fParsedPayloadsAddresses
ROOT::TMetaUtils::TClingLookupHelper * fLookupHelper
void FullName(std::string &output, const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
TClingCallbacks * fClingCallbacks
Int_t AutoLoad(const char *classname, Bool_t knowDictNotLoaded=kFALSE)
Load library containing the specified class.
Emulation of the CINT ClassInfo class.
EObjectPointerState GetObjectValidity() const
virtual ~TROOT()
Clean up and free resources used by ROOT (files, network sockets, shared memory segments, etc.).
you should not use this method at all Int_t Int_t Double_t Double_t Double_t e
virtual int GetSecurityError() const
Interface to cling function.
#define R__LOCKGUARD(mutex)
void InspectMember(const T &obj, const char *name, Bool_t isTransient)
Int_t GetEntries() const
Return the number of objects in array (i.e.
virtual void Add(TObject *obj)=0
virtual void * MethodInfo_InterfaceMethod(MethodInfo_t *minfo) const
void SetGetline(const char *(*getlineFunc)(const char *prompt), void(*histaddFunc)(const char *line))
Set a getline function to call when input is needed.
const clang::ValueDecl * GetDataMember(const char *name) const
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.
virtual void ClassInfo_Delete(ClassInfo_t *info) const
void Delete(void *arena, const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
void RegisterModule(const char *modulename, const char **headers, const char **includePaths, const char *payloadCode, const char *fwdDeclsCode, void(*triggerFunc)(), const FwdDeclArgsToKeepCollection_t &fwdDeclsArgToSkip, const char **classesHeaders)
Inject the module named "modulename" into cling; load all headers.
virtual bool Update(DataMemberInfo_t *info)
Update the TFunction to reflect the new info.
Int_t ReloadAllSharedLibraryMaps()
Reload the library map entries coming from all the loaded shared libraries, after first unloading the...
virtual TObject * FindObject(const char *name) const
Specialize FindObject to do search for the a data member just by name or create it if its not already...
static TClass * LoadClass(const char *requestedname, Bool_t silent)
Helper function used by TClass::GetClass().
void UpdateListOfMethods(TClass *cl) const
Update the list of pointers to method for TClass cl This is now a nop.
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
void * New(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
virtual const char * TypedefInfo_Name(TypedefInfo_t *tinfo) const
void RecursiveRemove(TObject *obj)
Delete object from cling symbol table so it can not be used anymore.
TDataMember * GetDataMember(const char *datamember) const
Return pointer to datamember object with name "datamember".
virtual int ClassInfo_Size(ClassInfo_t *info) const
void UnRegisterTClassUpdate(const TClass *oldcl)
If the dictionary is loaded, we can remove the class from the list (otherwise the class might be load...
virtual Double_t CallFunc_ExecDouble(CallFunc_t *func, void *address) const
Mother of all ROOT objects.
virtual bool ClassInfo_HasMethod(ClassInfo_t *info, const char *name) const
void TCling__LibraryUnloadedRTTI(const void *dyLibHandle, const char *canonicalName)
virtual Long_t MethodArgInfo_Property(MethodArgInfo_t *marginfo) const
void RegisterTemporary(const TInterpreterValue &value)
Global functions class (global functions are obtained from CINT).
virtual void Inspect(TClass *cl, const char *parent, const char *name, const void *addr)
virtual Long_t Getgvp() const
Interface to the CINT global object pointer which was controlling the behavior of the wrapper around ...
TClassRef is used to implement a permanent reference to a TClass object.
void HandleNewDecl(const void *DV, bool isDeserialized, std::set< TClass * > &modifiedClasses)
typedef void((*Func_t)())
void Unload()
Mark 'all func' as being unloaded.
const char * GetDeclFileName() const
virtual bool ClassInfo_IsLoaded(ClassInfo_t *info) const
static TEnum * GetEnum(const std::type_info &ti, ESearchAction sa=kALoadAndInterpLookup)
virtual DeclId_t GetDataMemberWithValue(const void *ptrvalue) const
NOT IMPLEMENTED.
void SetAutoloadingEnabled(bool val=true)
Bridge between cling::Value and ROOT.
virtual const char * MethodInfo_Name(MethodInfo_t *minfo) const
const char * GetUnqualifiedName(const char *name)
Return the start of the unqualified name include in 'original'.
const char * GetFullTypeName() const
Get full type description of method argument, e.g.: "class TDirectory*".
void Unload()
Mark 'all func' as being unloaded.
A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum t...
TDictionary::DeclId_t DeclId_t
virtual void Add(TObject *obj)
TClingMethodInfo GetMethodWithArgs(const char *fname, const char *arglist, long *poffset, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch, EInheritanceMode imode=kWithInheritance) const
virtual bool ClassInfo_IsValid(ClassInfo_t *info) const
virtual Long_t ClassInfo_Tagnum(ClassInfo_t *info) const
R__EXTERN const char * gRootDir
Bool_t fHeaderParsingOnDemand
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
virtual Long_t MethodInfo_ExtraProperty(MethodInfo_t *minfo) const
Each ROOT class (see TClass) has a linked list of methods.
std::vector< std::pair< TClass *, DictFuncPtr_t > > fClassesToUpdate
std::string AtlernateTuple(const char *classname)
virtual void CallFunc_IgnoreExtraArgs(CallFunc_t *func, bool ignore) const
virtual const char * GetSTLIncludePath() const
Return the directory containing CINT's stl cintdlls.
static void * fgSetOfSpecials
virtual const char * MethodInfo_TypeName(MethodInfo_t *minfo) const
static void SetFactory(TVirtualStreamerInfo *factory)
static function: Set the StreamerInfo factory
long ExecInt(void *address)
Int_t SetClassSharedLibs(const char *cls, const char *libs)
Register the autoloading information for a class.
Bool_t IsLoaded(const char *filename) const
Return true if the file has already been loaded by cint.
bool IsValid() const
Return true if the current iterator position is valid.
virtual void ClassInfo_Destruct(ClassInfo_t *info, void *arena) const
virtual const char * ClassInfo_FullName(ClassInfo_t *info) const
virtual void UpdateEnumConstants(TEnum *enumObj, TClass *cl) const
virtual void * OpenDirectory(const char *name)
Open a directory. Returns 0 if directory does not exist.
ROOT::ESTLType GetCollectionType() const
Return the 'type' of the STL the TClass is representing.
Bool_t SetSuspendAutoParsing(Bool_t value)
Suspend the Autoparsing of headers.
virtual const char * BaseClassInfo_TmpltName(BaseClassInfo_t *bcinfo) const
virtual const char * MethodArgInfo_Name(MethodArgInfo_t *marginfo) const
virtual const char * ClassInfo_TmpltName(ClassInfo_t *info) const
static bool R__InitStreamerInfoFactory()
Helper to initialize TVirtualStreamerInfo's factor early.
Bool_t IsErrorMessagesEnabled() const
If error messages are disabled, the interpreter should suppress its failures and warning messages fro...
void IgnoreExtraArgs(bool ignore)
Bool_t fIsAutoParsingSuspended
static void UpdateClassInfoWork(const char *name)
void * DynamicCast(const TClass *base, void *obj, Bool_t up=kTRUE)
Cast obj of this class type up to baseclass cl if up is true.
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
bool TClingLookupHelper__AutoParse(const char *cname)
Allow calling autoparsing from TMetaUtils.
std::hash< std::string > fStringHashFunction
virtual void TypedefInfo_Init(TypedefInfo_t *tinfo, const char *name) const
const char * GetSharedLibs()
Return the list of shared libraries loaded into the process.
TObject * At(Int_t idx) const
bool IsBase(const char *name) const
static const char * FindLibraryName(void(*func)())
Wrapper around dladdr (and friends)
virtual EReturnType MethodInfo_MethodCallReturnType(MethodInfo_t *minfo) const
R__EXTERN TInterpreter * gCling
R__DLLEXPORT TInterpreter * CreateInterpreter(void *interpLibHandle)
virtual void * FindSym(const char *entry) const
Interface to cling function.
void CodeComplete(const std::string &, size_t &, std::vector< std::string > &)
The call to Cling's tab complition.
virtual void Compress()
Remove empty slots from array.
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
bool IsValidMethod(const char *method, const char *proto, Bool_t objectIsConst, long *offset, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch) const
Long_t ProcessLineAsynch(const char *line, EErrorCode *error=0)
Let cling process a command line asynch.
static void output(int code)
virtual void DataMemberInfo_Delete(DataMemberInfo_t *dminfo) const
void TCling__TransactionRollback(const cling::Transaction &T)
virtual const char * GetTitle() const
Returns title of object.
TList * GetListOfMethods(Bool_t load=kTRUE)
Return list containing the TMethods of a class.
std::string NormalizedName(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
Return the normalized name of the type (i.e.
void Unload()
Mark 'all func' as being unloaded.
virtual char * ConcatFileName(const char *dir, const char *name)
Concatenate a directory and a file name. User must delete returned string.
void LoadMacro(const char *filename, EErrorCode *error=0)
Load a macro file in cling's memory.
virtual ClassInfo_t * BaseClassInfo_ClassInfo(BaseClassInfo_t *) const
static DictFuncPtr_t GetDictNorm(const char *cname)
Given the normalized class name returns the Dictionary() function of a class (uses hash of name)...
static ETupleOrdering IsTupleAscending()
const char * TypeName(const char *typeDesc)
Return the absolute type of typeDesc.
virtual EReturnType MethodCallReturnType(TFunction *func) const
static char * skip(char **buf, const char *delimiters)
void LibraryUnloaded(const void *dyLibHandle, const char *canonicalName)
void RewindDictionary()
Rewind Cling dictionary to the point where it was before executing the current macro.
virtual MethodArgInfo_t * MethodArgInfo_FactoryCopy(MethodArgInfo_t *marginfo) const
void AddIncludePath(const char *path)
Add the given path to the list of directories in which the interpreter looks for include files...
void CreateListOfMethods(TClass *cl) const
Create list of pointers to methods for TClass cl.
Int_t DeleteGlobal(void *obj)
Delete obj from Cling symbol table so it cannot be accessed anymore.
virtual TypeInfo_t * TypeInfo_Factory() const
virtual const char * MethodArgInfo_TypeName(MethodArgInfo_t *marginfo) const
TDictionary::DeclId_t GetDeclId() const
virtual void SetErrmsgcallback(void *p) const
Set a callback to receive error messages.
void ResetGlobals()
Reset in Cling the list of global variables to the state saved by the last call to TCling::SaveGlobal...
virtual const char * TypedefInfo_Title(TypedefInfo_t *tinfo) const
Int_t Size() const
Return size of object of this class.
virtual void SetAlloclockfunc(void(*)()) const
[Place holder for Mutex Lock] Provide the interpreter with a way to acquire a lock used to protect cr...
void ExecWithArgsAndReturn(void *address, const void *args[]=0, int nargs=0, void *ret=0)
virtual void CallFunc_SetArg(CallFunc_t *func, Long_t param) const
if(line.BeginsWith("/*"))
virtual Long_t FuncTempInfo_Property(FuncTempInfo_t *) const
Return the property of the function template.
DeclId_t GetDeclId() const
virtual DataMemberInfo_t * DataMemberInfo_FactoryCopy(DataMemberInfo_t *dminfo) const
void ExecWithReturn(void *address, void *ret=0)
virtual int UnloadFile(const char *path) const
virtual int DataMemberInfo_Next(DataMemberInfo_t *dminfo) const
std::map< size_t, std::vector< const char * > > fClassesHeadersMap
Long_t ProcessLineSynch(const char *line, EErrorCode *error=0)
Let cling process a command line synchronously, i.e we are waiting it will be finished.
virtual int ClassInfo_GetMethodNArg(ClassInfo_t *info, const char *method, const char *proto, Bool_t objectIsConst=false, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch) const
TList * GetListOfFunctionTemplates(Bool_t load=kTRUE)
Return list containing the TEnums of a class.
virtual const char * GetClassSharedLibs(const char *cls)=0
long long ExecInt64(void *address)
virtual void FuncTempInfo_Name(FuncTempInfo_t *, TString &name) const
Return the name of this function template.
virtual void TypedefInfo_Delete(TypedefInfo_t *tinfo) const
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.