63#include "RConfigure.h"
64#include "compiledata.h"
83#include "clang/AST/ASTContext.h"
84#include "clang/AST/Decl.h"
85#include "clang/AST/DeclarationName.h"
86#include "clang/AST/GlobalDecl.h"
87#include "clang/AST/RecordLayout.h"
88#include "clang/AST/DeclVisitor.h"
89#include "clang/AST/RecursiveASTVisitor.h"
90#include "clang/AST/Type.h"
91#include "clang/Basic/SourceLocation.h"
92#include "clang/Basic/Specifiers.h"
93#include "clang/Basic/TargetInfo.h"
94#include "clang/CodeGen/ModuleBuilder.h"
95#include "clang/Frontend/CompilerInstance.h"
96#include "clang/Frontend/FrontendDiagnostic.h"
97#include "clang/Lex/HeaderSearch.h"
98#include "clang/Lex/Preprocessor.h"
99#include "clang/Lex/PreprocessorOptions.h"
100#include "clang/Parse/Parser.h"
101#include "clang/Sema/Lookup.h"
102#include "clang/Sema/Sema.h"
103#include "clang/Serialization/ASTReader.h"
104#include "clang/Serialization/GlobalModuleIndex.h"
106#include "cling/Interpreter/ClangInternalState.h"
107#include "cling/Interpreter/DynamicLibraryManager.h"
108#include "cling/Interpreter/Interpreter.h"
109#include "cling/Interpreter/LookupHelper.h"
110#include "cling/Interpreter/Value.h"
111#include "cling/Interpreter/Transaction.h"
112#include "cling/MetaProcessor/MetaProcessor.h"
113#include "cling/Utils/AST.h"
114#include "cling/Utils/ParserStateRAII.h"
115#include "cling/Utils/SourceNormalization.h"
116#include "cling/Interpreter/Exception.h"
118#include "llvm/IR/GlobalValue.h"
119#include "llvm/IR/Module.h"
121#include "llvm/Support/DynamicLibrary.h"
122#include "llvm/Support/raw_ostream.h"
123#include "llvm/Support/Path.h"
124#include "llvm/Support/Process.h"
125#include "llvm/Object/ELFObjectFile.h"
126#include "llvm/Object/ObjectFile.h"
127#include "llvm/Object/SymbolicFile.h"
128#include "llvm/Support/FileSystem.h"
142#include <unordered_map>
143#include <unordered_set>
151#define R__DLLEXPORT __attribute__ ((visibility ("default")))
159#include <mach-o/dyld.h>
160#include <mach-o/loader.h>
167#if defined(R__LINUX) || defined(R__FBSD)
174#if defined(__CYGWIN__)
175#include <sys/cygwin.h>
176#define HMODULE void *
178 __declspec(dllimport)
void * __stdcall GetCurrentProcess();
179 __declspec(dllimport)
bool __stdcall EnumProcessModules(
void *,
void **,
unsigned long,
unsigned long *);
180 __declspec(dllimport)
unsigned long __stdcall GetModuleFileNameExW(
void *,
void *,
wchar_t *,
unsigned long);
187# define STDIN_FILENO 0
190# define STDOUT_FILENO 1
193# define STDERR_FILENO 2
203#undef GetModuleFileName
204#define RTLD_DEFAULT ((void *)::GetModuleHandle(NULL))
205#define dlsym(library, function_name) ::GetProcAddress((HMODULE)library, function_name)
206#define dlopen(library_name, flags) ::LoadLibraryA(library_name)
207#define dlclose(library) ::FreeLibrary((HMODULE)library)
208#define R__DLLEXPORT __declspec(dllexport)
216 return D->getDeclContext();
219 return llvm::dyn_cast<clang::NamespaceDecl>(DC);
222 return llvm::dyn_cast<clang::RecordDecl>(DC);
225 return DC->dumpDeclContext();
234 return ((clang::Decl*)D)->dump();
237 if (clang::NamedDecl* ND = llvm::dyn_cast<clang::NamedDecl>(D)) {
240 llvm::raw_string_ostream OS(
name);
241 ND->getNameForDiagnostic(OS, D->getASTContext().getPrintingPolicy(),
244 printf(
"%s\n",
name.c_str());
252 return D->isInvalidDecl();
256 assert(info && info->
IsValid());
257 return info->
GetDecl()->isInvalidDecl();
260using std::string, std::vector;
261using namespace clang;
265 static const std::string gInterpreterClassDef = R
"ICF(
267#define ClassDef(name, id) \
268_ClassDefInterp_(name,id,virtual,) \
269static int DeclFileLine() { return __LINE__; }
271#define ClassDefNV(name, id) \
272_ClassDefInterp_(name,id,,) \
273static int DeclFileLine() { return __LINE__; }
274#undef ClassDefOverride
275#define ClassDefOverride(name, id) \
276_ClassDefInterp_(name,id,,override) \
277static int DeclFileLine() { return __LINE__; }
280 static const std::string gNonInterpreterClassDef = R
"ICF(
281#define __ROOTCLING__ 1
283#define ClassDef(name,id) \
284_ClassDefOutline_(name,id,virtual,) \
285static int DeclFileLine() { return __LINE__; }
287#define ClassDefNV(name, id)\
288_ClassDefOutline_(name,id,,)\
289static int DeclFileLine() { return __LINE__; }
290#undef ClassDefOverride
291#define ClassDefOverride(name, id)\
292_ClassDefOutline_(name,id,,override)\
293static int DeclFileLine() { return __LINE__; }
297 static const std::string gClassDefInterpMacro = R
"ICF(
300#define _ClassDefInterp_(name,id,virtual_keyword, overrd) \
303 static TClass *Class() { static TClass* sIsA = 0; if (!sIsA) sIsA = TClass::GetClass(#name); return sIsA; } \
304 static const char *Class_Name() { return #name; } \
305 virtual_keyword Bool_t CheckTObjectHashConsistency() const overrd { return true; } \
306 static Version_t Class_Version() { return id; } \
307 static TClass *Dictionary() { return 0; } \
308 virtual_keyword TClass *IsA() const overrd { return name::Class(); } \
309 virtual_keyword void ShowMembers(TMemberInspector&insp) const overrd { ::ROOT::Class_ShowMembers(name::Class(), this, insp); } \
310 virtual_keyword void Streamer(TBuffer&) overrd { ::Error("Streamer", "Cannot stream interpreted class."); } \
311 void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { name::Streamer(ClassDef_StreamerNVirtual_b); } \
312 static const char *DeclFileName() { return __FILE__; } \
313 static int ImplFileLine() { return 0; } \
314 static const char *ImplFileName() { return __FILE__; }
353 return ((
TCling*)
gCling)->LibraryLoadingFailed(errmessage, libStem, permanent, resolved);
392 static vector<const NamedDecl*> updateList;
395 if (entered) topLevel =
kFALSE;
410 updateList.push_back(TD);
413 while (!updateList.empty()) {
415 updateList.pop_back();
422 const clang::Decl* D =
static_cast<const clang::Decl*
>(enumObj->
GetDeclId());
423 if(
const clang::EnumDecl* ED = dyn_cast<clang::EnumDecl>(D)) {
425 for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin(),
426 EDE = ED->enumerator_end(); EDI != EDE; ++EDI) {
428 std::string constbuf;
429 if (
const NamedDecl* END = llvm::dyn_cast<NamedDecl>(*EDI)) {
430 PrintingPolicy Policy((*EDI)->getASTContext().getPrintingPolicy());
431 llvm::raw_string_ostream stream(constbuf);
433 Policy.AnonymousTagLocations =
false;
434 (END)->getNameForDiagnostic(stream, Policy,
false);
436 const char* constantName = constbuf.c_str();
440 const llvm::APSInt valAPSInt = (*EDI)->getInitVal();
441 if (valAPSInt.isSigned()) {
442 value = valAPSInt.getSExtValue();
444 value = valAPSInt.getZExtValue();
451 DataMemberInfo_t* dmInfo = (DataMemberInfo_t*) tcDmInfo;
462 globals->
Add(enumConstant);
474 TEnum* enumType =
nullptr;
475 const clang::Decl* D =
static_cast<const clang::Decl*
>(VD);
477 if (
const EnumDecl* ED = llvm::dyn_cast<EnumDecl>(D)) {
479 PrintingPolicy Policy(ED->getASTContext().getPrintingPolicy());
480 llvm::raw_string_ostream stream(buf);
482 Policy.AnonymousTagLocations =
false;
483 ED->getNameForDiagnostic(stream, Policy,
false);
489 const char*
name = buf.c_str();
500 const clang::Decl* D =
static_cast<const clang::Decl*
>(DV);
502 if (!D->isCanonicalDecl() && !isa<clang::NamespaceDecl>(D)
503 && !dyn_cast<clang::RecordDecl>(D))
return;
505 if (isa<clang::FunctionDecl>(D->getDeclContext())
506 || isa<clang::TagDecl>(D->getDeclContext()))
510 if (
const clang::CXXRecordDecl* RD = dyn_cast<clang::CXXRecordDecl>(D)) {
511 if (RD->getDescribedClassTemplate())
513 }
else if (
const clang::FunctionDecl* FD = dyn_cast<clang::FunctionDecl>(D)) {
514 if (FD->getDescribedFunctionTemplate())
518 if (
const RecordDecl *TD = dyn_cast<RecordDecl>(D)) {
519 if (TD->isCanonicalDecl() || TD->isThisDeclarationADefinition())
522 else if (
const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
524 if (
const TagDecl *TD = dyn_cast<TagDecl>(D)) {
528 }
else if (
const NamespaceDecl* NSD = dyn_cast<NamespaceDecl>(D)) {
533 if (!isa<TranslationUnitDecl>(ND->getDeclContext()))
537 if (isa<EnumDecl>(ND))
542 if (!(isa<VarDecl>(ND)))
546 if (
gROOT->GetListOfGlobals()->FindObject(ND->getNameAsString().c_str()))
550 gROOT->GetListOfGlobals()->Add(
new TGlobal((DataMemberInfo_t *)
552 cast<ValueDecl>(ND),
nullptr)));
584 const char* canonicalName) {
585 ((
TCling*)
gCling)->LibraryLoaded(dyLibHandle, canonicalName);
590 ((
TCling *)
gCling)->RegisterRdictForLoadPCM(pcmFileNameFullPath, pcmContent);
594 const char* canonicalName) {
595 ((
TCling*)
gCling)->LibraryUnloaded(dyLibHandle, canonicalName);
601 return ((
TCling*)
gCling)->GetObjectAddress(Name, LookupCtx);
611 auto tcling =
new TCling(
"C++",
"cling C++ Interpreter", argv, interpLibHandle);
635 return ((
TCling*)
gCling)->GetClassSharedLibs(className, skipCore);
641 return ((
TCling*)
gCling)->IsAutoLoadNamespaceCandidate(nsDecl);
646 string file(fileName);
652 string &args,
string &io,
string &fname)
654 string file(fileName);
655 TString f, amode, arguments, aclicio;
658 io = aclicio.
Data(); fname =
f.Data();
668 char *__unDName(
char *demangled,
const char *mangled,
int out_len,
669 void * (* pAlloc )(
size_t),
void (* pFree )(
void *),
670 unsigned short int flags);
682 using namespace clang;
683 if (NamespaceDecl* nsd = llvm::dyn_cast<NamespaceDecl>(decl)){
687 if (ClassTemplateDecl* ctd = llvm::dyn_cast<ClassTemplateDecl>(decl)){
700 const std::vector<std::string> &headers,
701 const std::vector<std::string> &fwdDecls,
702 const std::vector<std::string> &unknown)
708 if (classes.empty()) {
712 const std::string& className = classes[0];
714 TString fileName =
"AutoDict_";
715 std::string::const_iterator sIt;
716 for (sIt = className.begin(); sIt != className.end(); ++sIt) {
717 if (*sIt ==
'<' || *sIt ==
'>' ||
718 *sIt ==
' ' || *sIt ==
'*' ||
719 *sIt ==
',' || *sIt ==
'&' ||
727 if (classes.size() > 1) {
729 std::vector<std::string>::const_iterator it = classes.begin();
730 while ((++it) != classes.end()) {
732 chk = chk * 3 + it->at(
cursor);
745 static const std::set<std::string> sSTLTypes {
746 "vector",
"list",
"forward_list",
"deque",
"map",
"unordered_map",
"multimap",
747 "unordered_multimap",
"set",
"unordered_set",
"multiset",
"unordered_multiset",
748 "queue",
"priority_queue",
"stack",
"iterator"};
749 std::vector<std::string>::const_iterator it;
750 std::string fileContent(
"");
751 for (it = headers.begin(); it != headers.end(); ++it) {
752 fileContent +=
"#include \"" + *it +
"\"\n";
754 for (it = unknown.begin(); it != unknown.end(); ++it) {
760 while (dirbase.
Length() && dirbase !=
"."
761 && dirbase !=
"include" && dirbase !=
"inc"
762 && dirbase !=
"prec_stl") {
766 fileContent +=
TString(
"#include \"") + header +
"\"\n";
769 for (it = fwdDecls.begin(); it != fwdDecls.end(); ++it) {
770 fileContent +=
"class " + *it +
";\n";
772 fileContent +=
"#ifdef __CLING__ \n";
773 fileContent +=
"#pragma link C++ nestedclasses;\n";
774 fileContent +=
"#pragma link C++ nestedtypedefs;\n";
775 for (it = classes.begin(); it != classes.end(); ++it) {
777 size_t posTemplate =
n.find(
'<');
778 std::set<std::string>::const_iterator iSTLType = sSTLTypes.end();
779 if (posTemplate != std::string::npos) {
780 n.erase(posTemplate, std::string::npos);
781 if (
n.compare(0, 5,
"std::") == 0) {
784 iSTLType = sSTLTypes.find(
n);
786 fileContent +=
"#pragma link C++ class ";
787 fileContent += *it +
"+;\n" ;
788 fileContent +=
"#pragma link C++ class ";
789 if (iSTLType != sSTLTypes.end()) {
793 fileContent += *it +
"::*;\n" ;
798 fileContent += *it +
"::*+;\n" ;
801 fileContent +=
"#endif\n";
805 filePointer = fopen(fileName,
"w");
806 if (filePointer ==
nullptr) {
812 fprintf(filePointer,
"%s", fileContent.c_str());
828 const std::vector<std::string> &headers,
829 const std::vector<std::string> &fwdDecls,
830 const std::vector<std::string> &unknown)
836 std::vector<std::string> classes;
837 classes.push_back(className);
865 void exceptionErrorHandler(
void * ,
868 throw std::runtime_error(std::string(
">>> Interpreter compilation error:\n") + reason);
882 class clangDiagSuppr {
884 clangDiagSuppr(clang::DiagnosticsEngine& diag): fDiagEngine(diag){
885 fOldDiagValue = fDiagEngine.getIgnoreAllWarnings();
886 fDiagEngine.setIgnoreAllWarnings(
true);
890 fDiagEngine.setIgnoreAllWarnings(fOldDiagValue);
893 clang::DiagnosticsEngine& fDiagEngine;
916 if (strncmp(tname.c_str(),
"const ", 6) == 0) {
919 unsigned long end = tname.length();
920 while( end && (tname[end-1]==
'&' || tname[end-1]==
'*' || tname[end-1]==
']') ) {
921 if ( tname[end-1]==
']' ) {
923 while ( end && tname[end-1]!=
'[' ) --end;
927 std::string innerbuf;
929 if (end != tname.length()) {
931 inner = innerbuf.c_str();
933 inner = tname.c_str()+
offset;
937 if (
gROOT->GetListOfClasses()->FindObject(inner)
947 const char *newname =
type->GetFullTypeName();
949 newname =
"Long64_t";
951 newname =
"ULong64_t";
953 if (strcmp(inner,newname) == 0) {
958 if ( end != tname.length() ) {
959 result += tname.substr(end,tname.length()-end);
967 if (lastPos != inner)
971 const auto enName = lastPos;
972 const auto scopeNameSize = ((
Long64_t)lastPos - (
Long64_t)inner) /
sizeof(
decltype(*lastPos)) - 2;
973 char *scopeName =
new char[scopeNameSize + 1];
974 strncpy(scopeName, inner, scopeNameSize);
975 scopeName[scopeNameSize] =
'\0';
977 if (
auto scope =
static_cast<TClass *
>(
gROOT->GetListOfClasses()->FindObject(scopeName))) {
978 auto enumTable =
dynamic_cast<const THashList *
>(scope->GetListOfEnums(
false));
979 if (enumTable && enumTable->THashList::FindObject(enName)) {
delete [] scopeName;
return true; }
983 auto listOfEnums = scope->GetListOfEnums();
985 auto enumTable =
dynamic_cast<const THashList *
>(listOfEnums);
986 if (enumTable && enumTable->THashList::FindObject(enName)) {
delete [] scopeName;
return true; }
993 auto enumTable =
dynamic_cast<const THashList *
>(
gROOT->GetListOfEnums());
994 if (enumTable && enumTable->THashList::FindObject(inner))
return true;
1017 return fContent.c_str();
1025 bool notPresent = fLinesHashSet.emplace(fHashFunc(str)).second;
1039static bool LoadModule(
const std::string &ModuleName, cling::Interpreter &interp)
1049 assert(!currentDir.empty());
1052 ::Info(
"TCling::__LoadModule",
"Preloading module %s. \n",
1053 ModuleName.c_str());
1055 return interp.loadModule(ModuleName,
true);
1061static void LoadModules(
const std::vector<std::string> &modules, cling::Interpreter &interp)
1063 for (
const auto &modName : modules)
1069 const static bool foundSymbol = dlsym(RTLD_DEFAULT,
"usedToIdentifyRootClingByDlSym");
1074static bool HasASTFileOnDisk(clang::Module *M,
const clang::Preprocessor &PP, std::string *FullFileName =
nullptr)
1076 const HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
1078 std::string ModuleFileName;
1079 if (!HSOpts.PrebuiltModulePaths.empty())
1081 ModuleFileName = PP.getHeaderSearchInfo().getPrebuiltModuleFileName(M->Name);
1083 *FullFileName = ModuleFileName;
1085 return !ModuleFileName.empty();
1091 CompilerInstance &CI = *interp.getCI();
1092 Preprocessor &PP = CI.getPreprocessor();
1093 auto ModuleManager = CI.getASTReader();
1094 assert(ModuleManager);
1099 if (ModuleIndexPath.empty())
1102 ModuleManager->resetForReload();
1103 ModuleManager->loadGlobalIndex();
1104 GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
1109 ModuleMap &MMap = PP.getHeaderSearchInfo().getModuleMap();
1110 bool RecreateIndex =
false;
1111 for (ModuleMap::module_iterator
I = MMap.module_begin(), E = MMap.module_end();
I != E; ++
I) {
1112 Module *TheModule =
I->second;
1117 RecreateIndex =
true;
1119 if (RecreateIndex) {
1120 cling::Interpreter::PushTransactionRAII deserRAII(&interp);
1121 clang::GlobalModuleIndex::UserDefinedInterestingIDs IDs;
1123 struct DefinitionFinder :
public RecursiveASTVisitor<DefinitionFinder> {
1124 DefinitionFinder(clang::GlobalModuleIndex::UserDefinedInterestingIDs& IDs,
1125 clang::TranslationUnitDecl* TU) : DefinitionIDs(IDs) {
1128 bool VisitNamedDecl(NamedDecl *ND) {
1129 if (!ND->isFromASTFile())
1131 if (!ND->getIdentifier())
1134 if (ND->getAccess() == AS_protected || ND->getAccess() == AS_private)
1137 if (TagDecl *TD = llvm::dyn_cast<TagDecl>(ND)) {
1138 if (TD->isCompleteDefinition())
1140 }
else if (NamespaceDecl *NSD = llvm::dyn_cast<NamespaceDecl>(ND)) {
1141 Register(NSD,
false);
1143 else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(ND))
1149 clang::GlobalModuleIndex::UserDefinedInterestingIDs &DefinitionIDs;
1150 void Register(
const NamedDecl* ND,
bool AddSingleEntry =
true) {
1151 assert(ND->isFromASTFile());
1154 if (!ND->hasOwningModule()) {
1156 SourceManager &SM = ND->getASTContext().getSourceManager();
1157 SourceLocation Loc = ND->getLocation();
1158 const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(Loc));
1160 assert(FE->getName().contains(
"input_line_"));
1165 Module *OwningModule = ND->getOwningModule()->getTopLevelModule();
1166 assert(OwningModule);
1167 assert(!ND->getName().empty() &&
"Empty name");
1168 if (AddSingleEntry && DefinitionIDs.count(ND->getName()))
1174 DefinitionIDs[ND->getName()].push_back(OwningModule->getASTFile());
1177 DefinitionFinder defFinder(IDs, CI.getASTContext().getTranslationUnitDecl());
1179 llvm::cantFail(GlobalModuleIndex::writeIndex(CI.getFileManager(),
1180 CI.getPCHContainerReader(),
1183 ModuleManager->resetForReload();
1184 ModuleManager->loadGlobalIndex();
1185 GlobalIndex = ModuleManager->getGlobalIndex();
1194 if (!clingInterp.getCI()->getLangOpts().Modules)
1198 cling::Interpreter::PushTransactionRAII deserRAII(&clingInterp);
1216 LoadModule(
"_Builtin_intrinsics", clingInterp);
1220 std::vector<std::string> CoreModules = {
"ROOT_Foundation_C",
1223 "ROOT_Foundation_Stage1_NoRTTI",
1232 std::vector<std::string> CommonModules = {
"MathCore"};
1238 std::vector<std::string> FIXMEModules = {
"Hist"};
1239 clang::CompilerInstance &CI = *clingInterp.getCI();
1240 clang::Preprocessor &PP = CI.getPreprocessor();
1241 ModuleMap &MMap = PP.getHeaderSearchInfo().getModuleMap();
1242 if (MMap.findModule(
"RInterface"))
1243 FIXMEModules.push_back(
"RInterface");
1247 GlobalModuleIndex *GlobalIndex =
nullptr;
1251 GlobalIndex = CI.getASTReader()->getGlobalIndex();
1253 llvm::StringSet<> KnownModuleFileNames;
1255 GlobalIndex->getKnownModuleFileNames(KnownModuleFileNames);
1257 std::vector<std::string> PendingModules;
1258 PendingModules.reserve(256);
1259 for (
auto I = MMap.module_begin(), E = MMap.module_end();
I != E; ++
I) {
1260 clang::Module *M =
I->second;
1264 std::string FullASTFilePath;
1268 if (GlobalIndex && KnownModuleFileNames.count(FullASTFilePath))
1271 if (M->IsUnimportable)
1279 if (std::find(CoreModules.begin(), CoreModules.end(), M->Name) != CoreModules.end())
1287 PendingModules.push_back(M->Name);
1294 assert(clingInterp.getMacro(
"gROOT") &&
"Couldn't load gROOT macro?");
1298 clingInterp.declare(R
"CODE(
1310 std::string PreIncludes;
1311 bool hasCxxModules = clingInterp.getCI()->getLangOpts().Modules;
1317 PreIncludes +=
"#include \"RtypesCore.h\"\n";
1320 PreIncludes +=
"#include \"Rtypes.h\"\n";
1322 PreIncludes += gClassDefInterpMacro +
"\n"
1323 + gInterpreterClassDef +
"\n"
1325 "#define ClassImp(X);\n";
1328 PreIncludes +=
"#include <string>\n";
1333 PreIncludes +=
"#include <cassert>\n";
1335 PreIncludes +=
"using namespace std;\n";
1336 clingInterp.declare(PreIncludes);
1356#ifdef R__USE_CXXMODULES
1360 llvm::install_fatal_error_handler(&exceptionErrorHandler);
1364 std::vector<std::string> clingArgsStorage;
1365 clingArgsStorage.push_back(
"cling4root");
1366 for (
const char*
const* arg = argv; *arg; ++arg)
1367 clingArgsStorage.push_back(*arg);
1370 if (!fromRootCling) {
1375 clingArgsStorage.push_back(
"-I" + interpInclude);
1378 clingArgsStorage.push_back(
"-I" + interpInclude +
"/cling");
1381 clingArgsStorage.push_back(
"-I" + interpInclude +
"/cling/plugins/include");
1392 std::string pchFilename = interpInclude +
"/allDict.cxx.pch";
1397 clingArgsStorage.push_back(
"-include-pch");
1398 clingArgsStorage.push_back(pchFilename);
1401 clingArgsStorage.push_back(
"-Wno-undefined-inline");
1402 clingArgsStorage.push_back(
"-fsigned-char");
1407 clingArgsStorage.push_back(
"-O1");
1410 clingArgsStorage.push_back(
"-mllvm");
1411 clingArgsStorage.push_back(
"-optimize-regalloc=0");
1416 std::optional<std::string> EnvOpt = llvm::sys::Process::GetEnv(
"EXTRA_CLING_ARGS");
1417 if (EnvOpt.has_value()) {
1418 StringRef Env(*EnvOpt);
1419 while (!Env.empty()) {
1421 std::tie(Arg, Env) = Env.split(
' ');
1422 clingArgsStorage.push_back(Arg.str());
1426 auto GetEnvVarPath = [](
const std::string &EnvVar, std::vector<std::string> &Paths) {
1427 std::optional<std::string> EnvOpt = llvm::sys::Process::GetEnv(EnvVar);
1428 if (EnvOpt.has_value()) {
1429 StringRef Env(*EnvOpt);
1430 while (!Env.empty()) {
1433 if (std::find(Paths.begin(), Paths.end(), Arg.str()) == Paths.end())
1434 Paths.push_back(Arg.str());
1440 std::vector<std::string> Paths;
1445 GetEnvVarPath(
"CLING_PREBUILT_MODULE_PATH", Paths);
1446 std::string EnvVarPath;
1447 for (
const std::string& P : Paths)
1450 gSystem->
Setenv(
"CLING_PREBUILT_MODULE_PATH", EnvVarPath.c_str());
1454 EnvOpt = llvm::sys::Process::GetEnv(
"ROOT_CLING_TIMING");
1455 if (EnvOpt.has_value())
1456 clingArgsStorage.push_back(
"-ftime-report");
1463 std::vector<std::string> ModuleMaps;
1466 GetEnvVarPath(
"CLING_MODULEMAP_FILES", ModuleMaps);
1470 if (llvm::sys::fs::exists(cwd + ModuleMapSuffix))
1471 ModuleMaps.push_back(cwd + ModuleMapSuffix);
1473 for (
const std::string& M : ModuleMaps)
1474 clingArgsStorage.push_back(
"-fmodule-map-file=" + M);
1476 std::string ModulesCachePath;
1477 EnvOpt = llvm::sys::Process::GetEnv(
"CLING_MODULES_CACHE_PATH");
1478 if (EnvOpt.has_value()){
1479 StringRef Env(*EnvOpt);
1480 assert(llvm::sys::fs::exists(Env) &&
"Path does not exist!");
1481 ModulesCachePath = Env.str();
1486 clingArgsStorage.push_back(
"-fmodules-cache-path=" + ModulesCachePath);
1489 std::vector<const char*> interpArgs;
1490 for (std::vector<std::string>::const_iterator iArg = clingArgsStorage.begin(),
1491 eArg = clingArgsStorage.end(); iArg != eArg; ++iArg)
1492 interpArgs.push_back(iArg->c_str());
1499 if (!fromRootCling) {
1501 interpArgs.push_back(
"-fmodules");
1502 interpArgs.push_back(
"-fno-implicit-module-maps");
1506 interpArgs.push_back(
"-Rmodule-build");
1512 interpArgs.push_back(
"-fno-autolink");
1517 interpArgs.push_back(
"-ffast-math");
1523 extraArgs && *extraArgs; ++extraArgs) {
1524 if (!strcmp(*extraArgs,
"-resource-dir")) {
1526 llvmResourceDir = *(++extraArgs);
1528 interpArgs.push_back(*extraArgs);
1532 std::vector<std::string> _empty;
1534 for (
const auto &arg: args)
1535 interpArgs.emplace_back(arg.c_str());
1538 cling::Interpreter::ModuleFileExtensions extensions;
1539 EnvOpt = llvm::sys::Process::GetEnv(
"ROOTDEBUG_RDICT");
1540 if (!EnvOpt.has_value())
1541 extensions.push_back(std::make_shared<TClingRdictModuleFileExtension>());
1543 fInterpreter = std::make_unique<cling::Interpreter>(interpArgs.size(),
1545 llvmResourceDir, extensions,
1549 fInterpreter->getCI()->getPreprocessorOpts().DisablePCHOrModuleValidation =
1550 DisableValidationForModuleKind::All;
1554 fInterpreter->getCI()->getLangOpts().SpellChecking =
false;
1557 auto isModulesArg = [](
const char* arg) {
return !strcmp(arg,
"-fmodules"); };
1558 bool hasModulesArg = std::find_if(interpArgs.begin(), interpArgs.end(), isModulesArg) != interpArgs.end();
1559 fInterpreter->getCI()->getLangOpts().Modules = hasModulesArg;
1564 static llvm::raw_fd_ostream fMPOuts (STDOUT_FILENO,
false);
1584 if (!fromRootCling) {
1589 fInterpreter->getRuntimeOptions().AllowRedefinition = 1;
1590 auto &Policy =
const_cast<clang::PrintingPolicy &
>(
fInterpreter->getCI()->getASTContext().getPrintingPolicy());
1594 Policy.SplitTemplateClosers =
true;
1596 Policy.SuppressDefaultTemplateArgs =
false;
1602 std::unique_ptr<TClingCallbacks>
1608 if (!fromRootCling) {
1609 cling::DynamicLibraryManager& DLM = *
fInterpreter->getDynamicLibraryManager();
1614 auto ShouldPermanentlyIgnore = [](llvm::StringRef FileName) ->
bool{
1615 llvm::StringRef stem = llvm::sys::path::stem(FileName);
1616 return stem.startswith(
"libNew") || stem.startswith(
"libcppyy_backend");
1619 DLM.initializeDyld(ShouldPermanentlyIgnore);
1657 assert(
GetRootMapFiles() ==
nullptr &&
"Must be called before LoadLibraryMap!");
1676 auto setFactory = []() {
1680 static bool doneFactory = setFactory();
1692 if (llvm::sys::fs::exists(pcmFileNameFullPath)) {
1693 ::Error(
"TCling::RegisterRdictForLoadPCM",
"Rdict '%s' is both in Module extension and in File system.", pcmFileNameFullPath.c_str());
1710 if (listOfKeys && ((listOfKeys->GetSize() == 0) ||
1711 ((listOfKeys->GetSize() == 1) &&
1712 !strcmp(((
TKey *)listOfKeys->At(0))->GetName(),
"EMPTY")
1719 ::Info(
"TCling::LoadPCMImpl",
"reading protoclasses for %s \n", pcmFile.
GetName());
1725 auto listOfGlobals =
gROOT->GetListOfGlobals();
1726 auto listOfEnums =
dynamic_cast<THashList *
>(
gROOT->GetListOfEnums());
1728 for (
auto selEnum : *enums) {
1729 const char *enumScope = selEnum->
GetTitle();
1730 const char *enumName = selEnum->GetName();
1731 if (strcmp(enumScope,
"") == 0) {
1734 if (!listOfEnums->THashList::FindObject(enumName)) {
1735 ((
TEnum *)selEnum)->SetClass(
nullptr);
1736 listOfEnums->Add(selEnum);
1738 for (
auto enumConstant : *
static_cast<TEnum *
>(selEnum)->GetConstants()) {
1739 if (!listOfGlobals->FindObject(enumConstant)) {
1740 listOfGlobals->Add(enumConstant);
1747 if (!nsTClassEntry) {
1750 auto listOfEnums = nsTClassEntry->
fEnums.load();
1761 if (listOfEnums && !listOfEnums->THashList::FindObject(enumName)) {
1762 ((
TEnum *)selEnum)->SetClass(nsTClassEntry);
1763 listOfEnums->Add(selEnum);
1771 pcmFile.
GetObject(
"__ProtoClasses", protoClasses);
1774 for (
auto obj : *protoClasses) {
1784 for (
auto proto : *protoClasses) {
1792 ::Error(
"TCling::LoadPCM",
"Inconsistent TClassTable for %s",
proto->GetName());
1803 protoClasses->
Clear();
1804 delete protoClasses;
1808 pcmFile.
GetObject(
"__Typedefs", dataTypes);
1810 for (
auto typedf : *dataTypes)
1811 gROOT->GetListOfTypes()->Add(typedf);
1824 assert(!pcmFileNameFullPath.empty());
1825 assert(llvm::sys::path::is_absolute(pcmFileNameFullPath));
1828 TString pcmFileName = pcmFileNameFullPath;
1836 llvm::SaveAndRestore<Int_t> SaveGDebug(
gDebug);
1839 ::Info(
"TCling::LoadPCM",
"Loading ROOT PCM %s", pcmFileName.
Data());
1844 if (llvm::sys::fs::is_symlink_file(pcmFileNameFullPath))
1849 llvm::StringRef pcmContent = pendingRdict->second;
1851 std::string RDictFileOpts = pcmFileNameFullPath +
"?filetype=pcm";
1852 TMemFile pcmMemFile(RDictFileOpts.c_str(), range);
1867 if (!llvm::sys::fs::exists(pcmFileNameFullPath)) {
1868 ::Error(
"TCling::LoadPCM",
"ROOT PCM %s file does not exist",
1869 pcmFileNameFullPath.data());
1872 ::Info(
"TCling::LoadPCM",
"In-memory ROOT PCM candidate %s\n",
1873 rdict.first.c_str());
1877 if (!
gROOT->IsRootFile(pcmFileName)) {
1878 Fatal(
"LoadPCM",
"The file %s is not a ROOT as was expected\n", pcmFileName.
Data());
1881 TFile pcmFile(pcmFileName +
"?filetype=pcm",
"READ");
1888 using namespace clang;
1890 class ExtLexicalStorageAdder:
public RecursiveASTVisitor<ExtLexicalStorageAdder>{
1895 bool VisitRecordDecl(clang::RecordDecl* rcd){
1897 Info(
"ExtLexicalStorageAdder",
1898 "Adding external lexical storage to class %s",
1899 rcd->getNameAsString().c_str());
1900 auto reDeclPtr = rcd->getMostRecentDecl();
1902 reDeclPtr->setHasExternalLexicalStorage();
1903 }
while ((reDeclPtr = reDeclPtr->getPreviousDecl()));
1916 const std::string &ModuleMapName )
const
1918 assert(llvm::sys::path::is_absolute(FullPath));
1919 Preprocessor &PP =
fInterpreter->getCI()->getPreprocessor();
1920 FileManager &FM = PP.getFileManager();
1923 if (
auto DE = FM.getOptionalDirectoryRef(FullPath)) {
1924 HeaderSearch &HS = PP.getHeaderSearchInfo();
1925 HeaderSearchOptions &HSOpts = HS.getHeaderSearchOpts();
1926 const auto &ModPaths = HSOpts.PrebuiltModulePaths;
1927 bool pathExists = std::find(ModPaths.begin(), ModPaths.end(), FullPath) != ModPaths.end();
1929 HSOpts.AddPrebuiltModulePath(FullPath);
1934 llvm::SmallString<256> ModuleMapFileName(DE->getName());
1935 llvm::sys::path::append(ModuleMapFileName, ModuleMapName);
1936 if (
auto FE = FM.getOptionalFileRef(ModuleMapFileName,
false,
1938 if (!HS.loadModuleMapFile(*FE,
false))
1940 Error(
"RegisterPrebuiltModulePath",
"Could not load modulemap in %s", ModuleMapFileName.c_str());
1957 "libforward_listDict",
1965 "libunordered_setDict",
1966 "libunordered_multisetDict",
1967 "libunordered_mapDict",
1968 "libunordered_multimapDict",
1976 char dyLibError[1000];
1977 FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
1978 dyLibError,
sizeof(dyLibError), NULL);
1980 const char *dyLibError = dlerror();
1982 ::Error(
"TCling::RegisterModule",
"Cannot open shared library %s for dictionary %s:\n %s", dyLibName, modulename,
1983 (dyLibError) ? dyLibError :
"");
2020 const char** headers,
2021 const char** includePaths,
2022 const char* payloadCode,
2023 const char* fwdDeclsCode,
2024 void (*triggerFunc)(),
2026 const char** classesHeaders,
2027 Bool_t lateRegistration ,
2034 if (fromRootCling)
return;
2043 bool isACLiC = strstr(modulename,
"_ACLiC_dict") !=
nullptr;
2044 if (hasHeaderParsingOnDemand && isACLiC) {
2046 Info(
"TCling::RegisterModule",
2047 "Header parsing on demand is active but this is an Aclic library. Disabling it for this library.");
2048 hasHeaderParsingOnDemand =
false;
2062 for (
const char** inclPath = includePaths; *inclPath; ++inclPath) {
2065 cling::Transaction* T =
nullptr;
2067 for (
auto& fwdDeclArgToSkipPair : fwdDeclsArgToSkip){
2068 const std::string& fwdDecl = fwdDeclArgToSkipPair.first;
2069 const int nArgsToSkip = fwdDeclArgToSkipPair.second;
2070 auto compRes =
fInterpreter->declare(fwdDecl.c_str(), &T);
2071 assert(cling::Interpreter::kSuccess == compRes &&
2072 "A fwd declaration could not be compiled");
2073 if (compRes!=cling::Interpreter::kSuccess){
2074 Warning(
"TCling::RegisterModule",
2075 "Problems in declaring string '%s' were encountered.",
2090 TString code = gNonInterpreterClassDef;
2092 code += payloadCode;
2094 std::string dyLibName = cling::DynamicLibraryManager::getSymbolLocation(triggerFunc);
2095 assert(!llvm::sys::fs::is_symlink_file(dyLibName));
2097 if (dyLibName.empty()) {
2098 ::Error(
"TCling::RegisterModule",
"Dictionary trigger function for %s not found", modulename);
2103 bool isSharedLib = cling::DynamicLibraryManager::isSharedLibrary(dyLibName);
2105 bool wasDlopened =
false;
2110 if (!lateRegistration) {
2117 void* dyLibHandle = dlopen(dyLibName.c_str(), RTLD_LAZY | RTLD_GLOBAL);
2127 if (hasHeaderParsingOnDemand && fwdDeclsCode){
2130 std::string fwdDeclsCodeLessEnums;
2134 std::string fwdDeclsLine;
2135 std::istringstream fwdDeclsCodeStr(fwdDeclsCode);
2136 std::vector<std::string> scopes;
2137 while (std::getline(fwdDeclsCodeStr, fwdDeclsLine)) {
2138 const auto enumPos = fwdDeclsLine.find(
"enum __attribute__((annotate(\"");
2140 if (enumPos != std::string::npos) {
2147 auto nsPos = fwdDeclsLine.find(
"namespace");
2148 R__ASSERT(nsPos < enumPos &&
"Inconsistent enum and enclosing scope parsing!");
2149 while (nsPos < enumPos && nsPos != std::string::npos) {
2151 const auto nsNameStart = nsPos + 10;
2152 const auto nsNameEnd = fwdDeclsLine.find(
'{', nsNameStart);
2153 const auto nsName = fwdDeclsLine.substr(nsNameStart, nsNameEnd - nsNameStart);
2154 scopes.push_back(nsName);
2155 nsPos = fwdDeclsLine.find(
"namespace", nsNameEnd);
2158 clang::DeclContext* DC =
nullptr;
2159 for (
auto &&aScope: scopes) {
2160 DC = cling::utils::Lookup::Namespace(&
fInterpreter->getSema(), aScope.c_str(), DC);
2166 if (scopes.empty() || DC) {
2170 size_t posEnumName = fwdDeclsLine.rfind(
"\"))) ");
2171 R__ASSERT(posEnumName != std::string::npos &&
"Inconsistent enum fwd decl!");
2173 while (isspace(fwdDeclsLine[posEnumName]))
2175 size_t posEnumNameEnd = fwdDeclsLine.find(
" : ", posEnumName);
2176 R__ASSERT(posEnumNameEnd != std::string::npos &&
"Inconsistent enum fwd decl (end)!");
2177 while (isspace(fwdDeclsLine[posEnumNameEnd]))
2181 std::string enumName = fwdDeclsLine.substr(posEnumName,
2182 posEnumNameEnd - posEnumName + 1);
2184 if (clang::NamedDecl* enumDecl
2185 = cling::utils::Lookup::Named(&
fInterpreter->getSema(),
2186 enumName.c_str(), DC)) {
2189 R__ASSERT(llvm::dyn_cast<clang::EnumDecl>(enumDecl) &&
"not an enum decl!");
2196 fwdDeclsCodeLessEnums += fwdDeclsLine +
"\n";
2200 if (!fwdDeclsCodeLessEnums.empty()){
2201 auto compRes =
fInterpreter->declare(fwdDeclsCodeLessEnums, &T);
2202 assert(cling::Interpreter::kSuccess == compRes &&
2203 "The forward declarations could not be compiled");
2204 if (compRes!=cling::Interpreter::kSuccess){
2205 Warning(
"TCling::RegisterModule",
2206 "Problems in compiling forward declarations for module %s: '%s'",
2207 modulename, fwdDeclsCodeLessEnums.c_str()) ;
2215 ExtLexicalStorageAdder elsa;
2216 for (
auto dciIt = T->decls_begin();dciIt!=T->decls_end();dciIt++){
2217 cling::Transaction::DelayCallInfo& dci = *dciIt;
2218 for(
auto dit = dci.m_DGR.begin(); dit != dci.m_DGR.end(); ++dit) {
2219 clang::Decl* declPtr = *dit;
2220 elsa.TraverseDecl(declPtr);
2234 for (
const char** classesHeader = classesHeaders; *classesHeader; ++classesHeader) {
2235 temp=*classesHeader;
2237 size_t theTemplateHash = 0;
2238 bool addTemplate =
false;
2239 size_t posTemplate = temp.find(
'<');
2240 if (posTemplate != std::string::npos) {
2242 std::string templateName = temp.substr(0, posTemplate);
2248 for (
const char** classesHeader_inner = classesHeader; 0!=strcmp(*classesHeader_inner,
"@"); ++classesHeader_inner,++classesHeader){
2250 if (payloadCode == *classesHeader_inner ){
2252 if (addTemplate)
fPayloads.insert(theTemplateHash);
2255 Info(
"TCling::RegisterModule",
2256 "Adding a header for %s", temp.c_str());
2262 addTemplate =
false;
2270 bool ModuleWasSuccessfullyLoaded =
false;
2272 std::string ModuleName = modulename;
2273 if (llvm::StringRef(modulename).startswith(
"lib"))
2274 ModuleName = llvm::StringRef(modulename).substr(3).str();
2279 clang::Preprocessor &PP = TheSema.getPreprocessor();
2280 std::string ModuleMapName;
2282 ModuleMapName = ModuleName +
".modulemap";
2284 ModuleMapName =
"module.modulemap";
2292 if (!ModuleWasSuccessfullyLoaded) {
2294 clang::HeaderSearch &headerSearch = PP.getHeaderSearchInfo();
2295 clang::ModuleMap &moduleMap = headerSearch.getModuleMap();
2296 if (moduleMap.findModule(ModuleName))
2297 Info(
"TCling::RegisterModule",
"Module %s in modulemap failed to load.", ModuleName.c_str());
2302 llvm::SmallString<256> pcmFileNameFullPath(dyLibName);
2305 llvm::sys::fs::make_absolute(pcmFileNameFullPath);
2306 llvm::sys::path::remove_filename(pcmFileNameFullPath);
2307 llvm::sys::path::append(pcmFileNameFullPath,
2309 LoadPCM(pcmFileNameFullPath.str().str());
2316 clangDiagSuppr diagSuppr(TheSema.getDiagnostics());
2318#if defined(R__MUST_REVISIT)
2319#if R__MUST_REVISIT(6,2)
2320 Warning(
"TCling::RegisterModule",
"Diagnostics suppression should be gone by now.");
2324 if (!ModuleWasSuccessfullyLoaded && !hasHeaderParsingOnDemand){
2327 const cling::Transaction* watermark =
fInterpreter->getLastTransaction();
2328 cling::Interpreter::CompilationResult compRes =
fInterpreter->parseForModule(code.
Data());
2334 assert(cling::Interpreter::kSuccess == compRes &&
2335 "Payload code of a dictionary could not be parsed correctly.");
2336 if (compRes!=cling::Interpreter::kSuccess) {
2337 Warning(
"TCling::RegisterModule",
2338 "Problems declaring payload for module %s.", modulename) ;
2351 if (!ModuleWasSuccessfullyLoaded && !hasHeaderParsingOnDemand) {
2354 "#undef __ROOTCLING__\n"
2355 + gInterpreterClassDef +
2360 assert(isSharedLib);
2363 dlclose(dyLibHandle);
2369 ASTContext &C = CI.getASTContext();
2377 if (IdentifierInfoLookup *External = C.Idents.getExternalIdentifierLookup()) {
2378 std::unique_ptr<IdentifierIterator> Iter(External->getIdentifiers());
2379 for (llvm::StringRef Ident = Iter->Next(); !Ident.empty(); Ident = Iter->Next()) {
2380 std::string
I = Ident.str();
2404 typedef std::vector<std::pair<TClass*,DictFuncPtr_t> >::iterator iterator;
2410 if ( i->first == oldcl ) {
2433 const char* input_line,
2434 cling::Interpreter::CompilationResult& compRes,
2438 return metaProcessor->process(input_line, compRes,
result);
2440 catch (cling::InterpreterException&
ex)
2442 Error(
"HandleInterpreterException",
"%s\n%s",
ex.what(),
"Execution of your code was aborted.");
2444 compRes = cling::Interpreter::kFailure;
2453 if (
auto ie =
dynamic_cast<const cling::InterpreterException*
>(&
e)) {
2479 gROOT->SetLineIsProcessing();
2483 gROOT->SetLineHasBeenProcessed();
2496 gROOT->SetLineIsProcessing();
2498 struct InterpreterFlagsRAII {
2499 cling::Interpreter* fInterpreter;
2500 bool fWasDynamicLookupEnabled;
2502 InterpreterFlagsRAII(cling::Interpreter* interp):
2503 fInterpreter(interp),
2504 fWasDynamicLookupEnabled(interp->isDynamicLookupEnabled())
2506 fInterpreter->enableDynamicLookup(
true);
2508 ~InterpreterFlagsRAII() {
2509 fInterpreter->enableDynamicLookup(fWasDynamicLookupEnabled);
2510 gROOT->SetLineHasBeenProcessed();
2519 cling::Interpreter::CompilationResult compRes = cling::Interpreter::kSuccess;
2520 if (!strncmp(sLine.
Data(),
".L", 2) || !strncmp(sLine.
Data(),
".x", 2) ||
2521 !strncmp(sLine.
Data(),
".X", 2)) {
2529 aclicMode, arguments, io);
2530 if (aclicMode.
Length()) {
2532 R__ASSERT(aclicMode[0]==
'+' &&
"ACLiC mode must start with a +");
2534 if (aclicMode[1]==
'+') {
2540 compRes = cling::Interpreter::kFailure;
2542 if (strncmp(sLine.
Data(),
".L", 2) != 0) {
2545 if (arguments.
Length() == 0) {
2554 mod_line =
function + arguments + io;
2558 }
else if (cling::DynamicLibraryManager::isSharedLibrary(fname.
Data()) &&
2559 strncmp(sLine.
Data(),
".L", 2) != 0) {
2562 compRes = cling::Interpreter::kFailure;
2564 if (arguments.
Length() == 0) {
2578 ext = fname.
Last(
'_');
2584 mod_line =
function + arguments + io;
2589 size_t unnamedMacroOpenCurly;
2592 std::string codeline;
2595 std::ifstream in(fname, std::ifstream::binary);
2597 std::getline(in, codeline);
2598 code += codeline +
"\n";
2600 unnamedMacroOpenCurly
2601 = cling::utils::isUnnamedMacro(code,
fInterpreter->getCI()->getLangOpts());
2605 if (unnamedMacroOpenCurly != std::string::npos) {
2607 unnamedMacroOpenCurly);
2617 if (0!=strncmp(sLine.
Data(),
".autodict ",10) && sLine !=
".autodict") {
2622 bool isInclusionDirective = sLine.
Contains(
"\n#include") || sLine.
BeginsWith(
"#include");
2623 if (isInclusionDirective) {
2640 case cling::Interpreter::kSuccess: *error =
kNoError;
break;
2641 case cling::Interpreter::kFailure: *error =
kRecoverable;
break;
2642 case cling::Interpreter::kMoreInputExpected: *error =
kProcessing;
break;
2645 if (compRes == cling::Interpreter::kSuccess
2676 if (path[0] ==
'-' && path[1] ==
'I')
2683 snprintf(drive, 3,
"%c:", _getdrive() +
'A' - 1);
2708 static const TClassRef clRefString(
"std::string");
2709 if (clRefString == cl) {
2719 const char* cobj = (
const char*) obj;
2726 auto inspInspect = [&] (ptrdiff_t
offset){
2732 switch(complexType) {
2739 inspInspect(
sizeof(
float));
2744 inspInspect(
sizeof(
double));
2749 inspInspect(
sizeof(
int));
2754 inspInspect(
sizeof(
long));
2759 static clang::PrintingPolicy
2761 if (printPol.Indentation) {
2763 printPol.Indentation = 0;
2764 printPol.SuppressInitializers =
true;
2767 const char* clname = cl->
GetName();
2770 const clang::ASTContext& astContext =
fInterpreter->getCI()->getASTContext();
2771 const clang::Decl *scopeDecl =
nullptr;
2772 const clang::Type *recordType =
nullptr;
2776 scopeDecl = clingCI->
GetDecl();
2777 recordType = clingCI->
GetType();
2779 const cling::LookupHelper& lh =
fInterpreter->getLookupHelper();
2781 scopeDecl = lh.findScope(clname, cling::LookupHelper::NoDiagnostics,
2785 Error(
"InspectMembers",
"Cannot find Decl for class %s", clname);
2788 const clang::CXXRecordDecl* recordDecl
2789 = llvm::dyn_cast<const clang::CXXRecordDecl>(scopeDecl);
2791 Error(
"InspectMembers",
"Cannot find Decl for class %s is not a CXXRecordDecl.", clname);
2800 astContext.getASTRecordLayout(recordDecl);
2802 for (clang::RecordDecl::field_iterator iField = recordDecl->field_begin(),
2803 eField = recordDecl->field_end(); iField != eField; ++iField) {}
2806 const clang::ASTRecordLayout& recLayout
2807 = astContext.getASTRecordLayout(recordDecl);
2814 if (cl->
Size() != recLayout.getSize().getQuantity()) {
2815 Error(
"InspectMembers",
"TClass and cling disagree on the size of the class %s, respectively %d %lld\n",
2819 unsigned iNField = 0;
2822 for (clang::RecordDecl::field_iterator iField = recordDecl->field_begin(),
2823 eField = recordDecl->field_end(); iField != eField;
2824 ++iField, ++iNField) {
2827 clang::QualType memberQT = iField->getType();
2832 memberQT = cling::utils::Transform::GetPartiallyDesugaredType(astContext, memberQT,
fNormalizedCtxt->
GetConfig(),
false );
2833 if (memberQT.isNull()) {
2834 std::string memberName;
2835 llvm::raw_string_ostream stream(memberName);
2837 printPol.AnonymousTagLocations =
false;
2838 iField->getNameForDiagnostic(stream, printPol,
true );
2840 Error(
"InspectMembers",
2841 "Cannot retrieve QualType for member %s while inspecting class %s",
2842 memberName.c_str(), clname);
2845 const clang::Type* memType = memberQT.getTypePtr();
2847 std::string memberName;
2848 llvm::raw_string_ostream stream(memberName);
2850 printPol.AnonymousTagLocations =
false;
2851 iField->getNameForDiagnostic(stream, printPol,
true );
2853 Error(
"InspectMembers",
2854 "Cannot retrieve Type for member %s while inspecting class %s",
2855 memberName.c_str(), clname);
2859 const clang::Type* memNonPtrType = memType;
2860 Bool_t ispointer =
false;
2861 if (memNonPtrType->isPointerType()) {
2863 clang::QualType ptrQT
2864 = memNonPtrType->getAs<clang::PointerType>()->getPointeeType();
2869 ptrQT = cling::utils::Transform::GetPartiallyDesugaredType(astContext, ptrQT,
fNormalizedCtxt->
GetConfig(),
false );
2870 if (ptrQT.isNull()) {
2871 std::string memberName;
2872 llvm::raw_string_ostream stream(memberName);
2874 printPol.AnonymousTagLocations =
false;
2875 iField->getNameForDiagnostic(stream, printPol,
true );
2877 Error(
"InspectMembers",
2878 "Cannot retrieve pointee Type for member %s while inspecting class %s",
2879 memberName.c_str(), clname);
2882 memNonPtrType = ptrQT.getTypePtr();
2886 llvm::SmallString<8> arraySize;
2887 const clang::ArrayType* arrType = memNonPtrType->getAsArrayTypeUnsafe();
2888 unsigned arrLevel = 0;
2889 bool haveErrorDueToArray =
false;
2893 const clang::ConstantArrayType* constArrType =
2894 clang::dyn_cast<clang::ConstantArrayType>(arrType);
2896 constArrType->getSize().toStringUnsigned(arraySize);
2899 clang::QualType subArrQT = arrType->getElementType();
2900 if (subArrQT.isNull()) {
2901 std::string memberName;
2902 llvm::raw_string_ostream stream(memberName);
2904 printPol.AnonymousTagLocations =
false;
2905 iField->getNameForDiagnostic(stream, printPol,
true );
2907 Error(
"InspectMembers",
2908 "Cannot retrieve QualType for array level %d (i.e. element type of %s) for member %s while inspecting class %s",
2909 arrLevel, subArrQT.getAsString(printPol).c_str(),
2910 memberName.c_str(), clname);
2911 haveErrorDueToArray =
true;
2914 arrType = subArrQT.getTypePtr()->getAsArrayTypeUnsafe();
2916 if (haveErrorDueToArray) {
2921 std::string fieldName;
2922 if (memType->isPointerType()) {
2927 std::string ioname(iField->getName());
2929 fieldName += ioname;
2930 fieldName += arraySize;
2935 clang::CharUnits
offset(astContext.toCharUnitsFromBits(recLayout.getFieldOffset(iNField)));
2936 ptrdiff_t fieldOffset =
offset.getQuantity();
2946 auto iFiledQtype = iField->getType();
2947 if (
auto tagDecl = iFiledQtype->getAsTagDecl()){
2948 auto declAccess = tagDecl->getAccess();
2949 if (declAccess == AS_private || declAccess == AS_protected) {
2955 insp.
Inspect(
const_cast<TClass*
>(cl), insp.
GetParent(), fieldName.c_str(), cobj + fieldOffset, isTransient);
2958 const clang::CXXRecordDecl* fieldRecDecl = memNonPtrType->getAsCXXRecordDecl();
2959 if (fieldRecDecl && !fieldRecDecl->isAnonymousStructOrUnion()) {
2962 std::string sFieldRecName;
2965 clang::QualType(memNonPtrType,0),
2975 insp.
InspectMember(sFieldRecName.c_str(), cobj + fieldOffset,
2976 (fieldName +
'.').c_str(), transient);
2984 unsigned iNBase = 0;
2985 for (clang::CXXRecordDecl::base_class_const_iterator iBase
2986 = recordDecl->bases_begin(), eBase = recordDecl->bases_end();
2987 iBase != eBase; ++iBase, ++iNBase) {
2988 clang::QualType baseQT = iBase->getType();
2989 if (baseQT.isNull()) {
2990 Error(
"InspectMembers",
2991 "Cannot find QualType for base number %d while inspecting class %s",
2995 const clang::CXXRecordDecl* baseDecl
2996 = baseQT->getAsCXXRecordDecl();
2998 Error(
"InspectMembers",
2999 "Cannot find CXXRecordDecl for base number %d while inspecting class %s",
3004 std::string sBaseName;
3006 std::vector<TClass*> foundClasses;
3008 if (foundClasses.size()==1){
3009 baseCl=foundClasses[0];
3022 std::string qualNameForDiag;
3024 Error(
"InspectMembers",
3025 "Cannot find TClass for base class %s", qualNameForDiag.c_str() );
3030 if (iBase->isVirtual()) {
3033 Error(
"InspectMembers",
3034 "Base %s of class %s is virtual but no object provided",
3035 sBaseName.c_str(), clname);
3043 baseOffset = ci->
GetBaseOffset(baseCi,
const_cast<void*
>(obj),
3045 if (baseOffset == -1) {
3046 Error(
"InspectMembers",
3047 "Error calculating offset of virtual base %s of class %s",
3048 sBaseName.c_str(), clname);
3051 Error(
"InspectMembers",
3052 "Cannot calculate offset of virtual base %s of class %s",
3053 sBaseName.c_str(), clname);
3058 baseOffset = recLayout.getBaseClassOffset(baseDecl).getQuantity();
3105 bool oldDynLookup =
fInterpreter->isDynamicLookupEnabled();
3134 return fInterpreter->getDynamicLibraryManager()->isLibraryLoaded(tLibName.
Data());
3149 llvm::StringRef ModuleName(libname);
3150 ModuleName = llvm::sys::path::stem(ModuleName);
3151 ModuleName.consume_front(
"lib");
3159 clang::ModuleMap &moduleMap =
fInterpreter->getCI()->getPreprocessor().getHeaderSearchInfo().getModuleMap();
3160 clang::Module *M = moduleMap.findModule(ModuleName);
3161 return M && !M->IsUnimportable && M->getASTFile();
3180 size_t at = std::string::npos;
3181 while ((at = file_name.find(
"/./")) != std::string::npos)
3182 file_name.replace(at, 3,
"/");
3184 std::string filesStr =
"";
3185 llvm::raw_string_ostream filesOS(filesStr);
3186 clang::SourceManager &SM =
fInterpreter->getCI()->getSourceManager();
3187 cling::ClangInternalState::printIncludedFiles(filesOS, SM);
3190 llvm::SmallVector<llvm::StringRef, 100> files;
3191 llvm::StringRef(filesStr).split(files,
"\n");
3193 std::set<std::string> fileMap;
3194 llvm::StringRef file_name_ref(file_name);
3196 for (llvm::SmallVector<llvm::StringRef, 100>::const_iterator
3197 iF = files.begin(), iE = files.end(); iF != iE; ++iF) {
3198 if ((*iF) == file_name_ref)
return kTRUE;
3199 fileMap.insert(iF->str());
3202 if (fileMap.empty())
return kFALSE;
3205 TString sFilename(file_name.c_str());
3207 && fileMap.count(sFilename.
Data())) {
3215 while (incPath.
Index(
" :") != -1) {
3219 sFilename = file_name.c_str();
3221 && fileMap.count(sFilename.
Data())) {
3230 clang::ConstSearchDirIterator *CurDir =
nullptr;
3231 clang::Preprocessor &PP =
fInterpreter->getCI()->getPreprocessor();
3232 clang::HeaderSearch &HS = PP.getHeaderSearchInfo();
3233 auto FE = HS.LookupFile(file_name.c_str(),
3234 clang::SourceLocation(),
3237 clang::ArrayRef<std::pair<
const clang::FileEntry *,
3238 const clang::DirectoryEntry *>>(),
3251 clang::SourceManager &SM =
fInterpreter->getCI()->getSourceManager();
3253 clang::FileID FID = SM.translateFile(*FE);
3254 if (!FID.isInvalid() && FID.getHashValue() == 0)
3257 clang::SrcMgr::SLocEntry SLocE = SM.getSLocEntry(FID);
3258 if (SLocE.isFile() && !SLocE.getFile().getContentCache().getBufferIfLoaded())
3260 if (!FID.isInvalid())
3264 sFilename = FE->getName().str();
3266 && fileMap.count(sFilename.
Data())) {
3274#if defined(R__MACOSX)
3282static bool R__UpdateLibFileForLinking(
TString &lib)
3284 const char *mapfile =
nullptr;
3286 mapfile =
"/System/Library/dyld/dyld_shared_cache_x86_64.map";
3288 mapfile =
"/System/Library/dyld/dyld_shared_cache_arm64e.map";
3290 #error unsupported architecture
3292 if (std::ifstream cacheMap{mapfile}) {
3294 while (getline(cacheMap,
line)) {
3295 if (
line.find(lib) != std::string::npos) {
3307#if defined (R__LINUX) || defined (R__FBSD)
3313static int callback_for_dl_iterate_phdr(
struct dl_phdr_info *info,
size_t size,
void *
data)
3316 static std::unordered_set<
decltype(info->dlpi_addr)> sKnownLoadedLibBaseAddrs;
3318 auto newLibs =
static_cast<std::vector<std::string>*
>(
data);
3319 if (!sKnownLoadedLibBaseAddrs.count(info->dlpi_addr)) {
3321 if (info->dlpi_name && info->dlpi_name[0]
3326 && strncmp(info->dlpi_name,
"[vdso]", 6)
3330 && strncmp(info->dlpi_name,
"/libexec/ld-elf.so.1", 20)
3332 && strncmp(info->dlpi_name,
"linux-vdso.so", 13)
3333 && strncmp(info->dlpi_name,
"linux-vdso32.so", 15)
3334 && strncmp(info->dlpi_name,
"linux-vdso64.so", 15)
3335 && strncmp(info->dlpi_name,
"linux-gate.so", 13))
3336 newLibs->emplace_back(info->dlpi_name);
3337 sKnownLoadedLibBaseAddrs.insert(info->dlpi_addr);
3350#if defined(R__WIN32) || defined(__CYGWIN__)
3351 HMODULE hModules[1024];
3353 unsigned long cbModules;
3355 hProcess = (
void *)::GetCurrentProcess();
3356 ::EnumProcessModules(hProcess, hModules,
sizeof(hModules), &cbModules);
3358 for (i = 1; i < (cbModules /
sizeof(
void *)); i++) {
3359 static const int bufsize = 260;
3360 wchar_t winname[bufsize];
3361 char posixname[bufsize];
3362 ::GetModuleFileNameExW(hProcess, hModules[i], winname, bufsize);
3363#if defined(__CYGWIN__)
3364 cygwin_conv_path(CCP_WIN_W_TO_POSIX, winname, posixname, bufsize);
3366 std::wstring wpath = winname;
3367 std::replace(wpath.begin(), wpath.end(),
'\\',
'/');
3368 string path(wpath.begin(), wpath.end());
3369 strncpy(posixname, path.c_str(), bufsize);
3375#elif defined(R__MACOSX)
3379 while (
const mach_header* mh = _dyld_get_image_header(imageIndex)) {
3381 if (mh->filetype == MH_DYLIB) {
3382 if (
const char* imageName = _dyld_get_image_name(imageIndex)) {
3390#elif defined(R__LINUX) || defined(R__FBSD)
3394 std::vector<std::string> newLibs;
3395 dl_iterate_phdr(callback_for_dl_iterate_phdr, &newLibs);
3396 for (
auto &&lib: newLibs)
3399 Error(
"TCling::UpdateListOfLoadedSharedLibraries",
3400 "Platform not supported!");
3406static bool StartsWithStrLit(
const char *haystack,
const char (&needle)[
N]) {
3407 return !strncmp(haystack, needle,
N - 1);
3422 cling::DynamicLibraryManager* DLM =
fInterpreter->getDynamicLibraryManager();
3423 if (!DLM->isLibraryLoaded(
filename)) {
3424 DLM->loadLibrary(
filename,
true ,
true );
3427#if defined(R__MACOSX)
3429 auto lenFilename = strlen(
filename);
3430 auto isInMacOSSystemDir = [](
const char *fn) {
3431 return StartsWithStrLit(fn,
"/usr/lib/") || StartsWithStrLit(fn,
"/System/Library/");
3433 if (!strcmp(
filename,
"cl_kernels")
3436 || StartsWithStrLit(
filename,
"/usr/lib/system/")
3437 || StartsWithStrLit(
filename,
"/usr/lib/libc++")
3438 || StartsWithStrLit(
filename,
"/System/Library/Frameworks/")
3439 || StartsWithStrLit(
filename,
"/System/Library/PrivateFrameworks/")
3440 || StartsWithStrLit(
filename,
"/System/Library/CoreServices/")
3441 || StartsWithStrLit(
filename,
"/usr/lib/libSystem")
3442 || StartsWithStrLit(
filename,
"/usr/lib/libstdc++")
3443 || StartsWithStrLit(
filename,
"/usr/lib/libicucore")
3444 || StartsWithStrLit(
filename,
"/usr/lib/libbsm")
3445 || StartsWithStrLit(
filename,
"/usr/lib/libobjc")
3446 || StartsWithStrLit(
filename,
"/usr/lib/libresolv")
3447 || StartsWithStrLit(
filename,
"/usr/lib/libauto")
3448 || StartsWithStrLit(
filename,
"/usr/lib/libcups")
3449 || StartsWithStrLit(
filename,
"/usr/lib/libDiagnosticMessagesClient")
3450 || StartsWithStrLit(
filename,
"/usr/lib/liblangid")
3451 || StartsWithStrLit(
filename,
"/usr/lib/libCRFSuite")
3452 || StartsWithStrLit(
filename,
"/usr/lib/libpam")
3453 || StartsWithStrLit(
filename,
"/usr/lib/libOpenScriptingUtil")
3454 || StartsWithStrLit(
filename,
"/usr/lib/libextension")
3455 || StartsWithStrLit(
filename,
"/usr/lib/libAudioToolboxUtility")
3456 || StartsWithStrLit(
filename,
"/usr/lib/liboah")
3457 || StartsWithStrLit(
filename,
"/usr/lib/libRosetta")
3458 || StartsWithStrLit(
filename,
"/usr/lib/libCoreEntitlements")
3459 || StartsWithStrLit(
filename,
"/usr/lib/libssl.")
3460 || StartsWithStrLit(
filename,
"/usr/lib/libcrypto.")
3466 || StartsWithStrLit(
filename,
"/usr/lib/system/libsystem_kernel")
3467 || StartsWithStrLit(
filename,
"/usr/lib/system/libsystem_platform")
3468 || StartsWithStrLit(
filename,
"/usr/lib/system/libsystem_pthread")
3473 || (lenFilename > 4 && !strcmp(
filename + lenFilename - 4,
".tbd")))
3476 R__UpdateLibFileForLinking(sFileName);
3478#elif defined(__CYGWIN__)
3480 static const int bufsize = 260;
3481 char posixwindir[bufsize];
3482 char *windir = getenv(
"WINDIR");
3484 cygwin_conv_path(CCP_WIN_A_TO_POSIX, windir, posixwindir, bufsize);
3486 snprintf(posixwindir,
sizeof(posixwindir),
"/Windows/");
3487 if (strstr(
filename, posixwindir) ||
3490#elif defined(R__WIN32)
3493#elif defined (R__LINUX)
3517 assert(!
IsFromRootCling() &&
"Trying to load library from rootcling!");
3521 cling::DynamicLibraryManager* DLM =
fInterpreter->getDynamicLibraryManager();
3522 std::string canonLib = DLM->lookupLibrary(
filename);
3523 cling::DynamicLibraryManager::LoadLibResult res
3524 = cling::DynamicLibraryManager::kLoadLibNotFound;
3525 if (!canonLib.empty()) {
3527 res = DLM->loadLibrary(
filename, system,
true);
3531 cling::Interpreter::CompilationResult compRes;
3533 if (compRes == cling::Interpreter::kSuccess)
3534 res = cling::DynamicLibraryManager::kLoadLibSuccess;
3538 if (res == cling::DynamicLibraryManager::kLoadLibSuccess) {
3542 case cling::DynamicLibraryManager::kLoadLibSuccess:
return 0;
3543 case cling::DynamicLibraryManager::kLoadLibAlreadyLoaded:
return 1;
3593 Warning(
"Calc",
"waiting for cling thread to free");
3596 gROOT->SetLineIsProcessing();
3603 cling::Value valRef;
3604 cling::Interpreter::CompilationResult cr = cling::Interpreter::kFailure;
3608 catch (cling::InterpreterException&
ex)
3610 Error(
"Calc",
"%s.\n%s",
ex.what(),
"Evaluation of your expression was aborted.");
3612 cr = cling::Interpreter::kFailure;
3615 if (cr != cling::Interpreter::kSuccess) {
3623 if (!valRef.isValid()) {
3632 if (valRef.isVoid()) {
3639 gROOT->SetLineHasBeenProcessed();
3649 void (*histaddFunc)(
const char*
line))
3654#if defined(R__MUST_REVISIT)
3655#if R__MUST_REVISIT(6,2)
3656 Warning(
"SetGetline",
"Cling should support the equivalent of SetGetlineFunc(getlineFunc, histaddFunc)");
3669 if ((std::distance(T.decls_begin(), T.decls_end()) != 1)
3670 || T.deserialized_decls_begin() != T.deserialized_decls_end()
3671 || T.macros_begin() != T.macros_end()
3672 || ((!T.getFirstDecl().isNull()) && ((*T.getFirstDecl().begin()) != T.getWrapperFD()))) {
3695 std::set<TObject*>::iterator iSpecial = ((std::set<TObject*>*)
fgSetOfSpecials)->find(obj);
3713#if defined(R__MUST_REVISIT)
3714#if R__MUST_REVISIT(6,2)
3716 Warning(
"Reset",
"Cling should support the equivalent of scratch_upto(&fDictPos)");
3726#if defined(R__MUST_REVISIT)
3727#if R__MUST_REVISIT(6,2)
3729 Warning(
"ResetAll",
"Cling should support the equivalent of complete reset (unload everything but the startup decls.");
3756#if defined(R__MUST_REVISIT)
3757#if R__MUST_REVISIT(6,2)
3759 Warning(
"ResetGlobalVar",
"Cling should support the equivalent of resetglobalvar(obj)");
3771#if defined(R__MUST_REVISIT)
3772#if R__MUST_REVISIT(6,2)
3774 Warning(
"RewindDictionary",
"Cling should provide a way to revert transaction similar to rewinddictionary()");
3785#if defined(R__MUST_REVISIT)
3786#if R__MUST_REVISIT(6,2)
3788 Warning(
"DeleteGlobal",
"Cling should provide the equivalent of deleteglobal(obj), see also DeleteVariable.");
3800#if defined(R__MUST_REVISIT)
3801#if R__MUST_REVISIT(6,2)
3802 Warning(
"DeleteVariable",
"should do more that just reseting the value to zero");
3807 llvm::StringRef srName(
name);
3808 const char* unscopedName =
name;
3809 llvm::StringRef::size_type posScope = srName.rfind(
"::");
3810 const clang::DeclContext* declCtx =
nullptr;
3811 if (posScope != llvm::StringRef::npos) {
3812 const cling::LookupHelper& lh =
fInterpreter->getLookupHelper();
3813 const clang::Decl* scopeDecl
3814 = lh.findScope(srName.substr(0, posScope),
3815 cling::LookupHelper::WithDiagnostics);
3817 Error(
"DeleteVariable",
"Cannot find enclosing scope for variable %s",
3821 declCtx = llvm::dyn_cast<clang::DeclContext>(scopeDecl);
3823 Error(
"DeleteVariable",
3824 "Enclosing scope for variable %s is not a declaration context",
3828 unscopedName += posScope + 2;
3832 clang::NamedDecl* nVarDecl
3833 = cling::utils::Lookup::Named(&
fInterpreter->getSema(), unscopedName, declCtx);
3835 Error(
"DeleteVariable",
"Unknown variable %s",
name);
3838 clang::VarDecl* varDecl = llvm::dyn_cast<clang::VarDecl>(nVarDecl);
3840 Error(
"DeleteVariable",
"Entity %s is not a variable",
name);
3844 clang::QualType qType = varDecl->getType();
3845 const clang::Type*
type = qType->getUnqualifiedDesugaredType();
3848 if (
type->isPointerType()) {
3849 int** ppInt = (
int**)
fInterpreter->getAddressOfGlobal(GlobalDecl(varDecl));
3851 if (ppInt) *ppInt =
nullptr;
3861#if defined(R__MUST_REVISIT)
3862#if R__MUST_REVISIT(6,2)
3864 Warning(
"SaveContext",
"Cling should provide a way to record a state watermark similar to store_dictposition(&fDictPos)");
3874#if defined(R__MUST_REVISIT)
3875#if R__MUST_REVISIT(6,2)
3877 Warning(
"SaveGlobalsContext",
"Cling should provide a way to record a watermark for the list of global variable similar to store_dictposition(&fDictPosGlobals)");
3925 std::tuple<int,double>
value;
3929 size_t offset0 = ((
char*)&(std::get<0>(
value))) - ((
char*)&
value);
3930 size_t offset1 = ((
char*)&(std::get<1>(
value))) - ((
char*)&
value);
3932 size_t ascOffset0 = ((
char*)&(asc.
_0)) - ((
char*)&asc);
3933 size_t ascOffset1 = ((
char*)&(asc.
_1)) - ((
char*)&asc);
3935 size_t desOffset0 = ((
char*)&(des.
_0)) - ((
char*)&des);
3936 size_t desOffset1 = ((
char*)&(des.
_1)) - ((
char*)&des);
3938 if (offset0 == ascOffset0 && offset1 == ascOffset1) {
3940 }
else if (offset0 == desOffset0 && offset1 == desOffset1) {
3947static std::string
AlternateTuple(
const char *classname,
const cling::LookupHelper& lh)
3950 std::string alternateName =
"TEmulatedTuple";
3951 alternateName.append( classname + 5 );
3953 std::string fullname =
"ROOT::Internal::" + alternateName;
3954 if (lh.findScope(fullname, cling::LookupHelper::NoDiagnostics,
3958 std::string guard_name;
3960 std::ostringstream guard;
3961 guard <<
"ROOT_INTERNAL_TEmulated_";
3962 guard << guard_name;
3964 std::ostringstream alternateTuple;
3965 alternateTuple <<
"#ifndef " << guard.str() <<
"\n";
3966 alternateTuple <<
"#define " << guard.str() <<
"\n";
3967 alternateTuple <<
"namespace ROOT { namespace Internal {\n";
3968 alternateTuple <<
"template <class... Types> struct TEmulatedTuple;\n";
3969 alternateTuple <<
"template <> struct " << alternateName <<
" {\n";
3974 unsigned int nMember = 0;
3975 auto iter = tupleContent.
fElements.begin() + 1;
3976 auto theEnd = tupleContent.
fElements.end() - 1;
3977 while (iter != theEnd) {
3978 alternateTuple <<
" " << *iter <<
" _" << nMember <<
";\n";
3985 unsigned int nMember = tupleContent.
fElements.size() - 3;
3986 auto iter = tupleContent.
fElements.rbegin() + 1;
3987 auto theEnd = tupleContent.
fElements.rend() - 1;
3988 while (iter != theEnd) {
3989 alternateTuple <<
" " << *iter <<
" _" << nMember <<
";\n";
3996 Fatal(
"TCling::SetClassInfo::AlternateTuple",
3997 "Layout of std::tuple on this platform is unexpected.");
4002 alternateTuple <<
"};\n";
4003 alternateTuple <<
"}}\n";
4004 alternateTuple <<
"#endif\n";
4006 Error(
"Load",
"Could not declare %s",alternateName.c_str());
4009 alternateName =
"ROOT::Internal::" + alternateName;
4010 return alternateName;
4050 auto SetWithoutClassInfoState = [](
TClass *cl)
4063 if (strncmp(cl->
GetName(),
"tuple<",strlen(
"tuple<"))==0) {
4066 if (reload ||
name.empty()) {
4068 SetWithoutClassInfoState(cl);
4080 SetWithoutClassInfoState(cl);
4097 zombieCandidate =
kTRUE;
4104 zombieCandidate =
kTRUE;
4157 static const char *anonEnum =
"anonymous enum ";
4158 static const int cmplen = strlen(anonEnum);
4185 const char *classname =
name;
4188 class MaybeSuspendAutoLoadParse {
4189 int fStoreAutoLoad = 0;
4190 int fStoreAutoParse = 0;
4191 bool fSuspendedAutoParse =
false;
4193 MaybeSuspendAutoLoadParse(
int autoload) {
4194 fStoreAutoLoad = ((
TCling*)
gCling)->SetClassAutoLoading(autoload);
4198 fSuspendedAutoParse =
true;
4199 fStoreAutoParse = ((
TCling*)
gCling)->SetSuspendAutoParsing(
true);
4202 ~MaybeSuspendAutoLoadParse() {
4203 if (fSuspendedAutoParse)
4204 ((
TCling*)
gCling)->SetSuspendAutoParsing(fStoreAutoParse);
4205 ((
TCling*)
gCling)->SetClassAutoLoading(fStoreAutoLoad);
4209 MaybeSuspendAutoLoadParse autoLoadParseRAII( autoload );
4211 autoLoadParseRAII.SuspendAutoParsing();
4220 const cling::LookupHelper& lh =
fInterpreter->getLookupHelper();
4221 const clang::Type *
type =
nullptr;
4222 const clang::Decl *decl
4223 = lh.findScope(classname,
4224 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4225 : cling::LookupHelper::NoDiagnostics,
4229 decl = lh.findScope(buf,
4230 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4231 : cling::LookupHelper::NoDiagnostics,
4248 clang::ClassTemplateSpecializationDecl *tmpltDecl =
4249 llvm::dyn_cast_or_null<clang::ClassTemplateSpecializationDecl>
4250 (
type->getAsCXXRecordDecl());
4251 if (tmpltDecl && !tmpltDecl->getPointOfInstantiation().isValid()) {
4268 if (tci.
Property() & propertiesMask) {
4269 bool hasClassDefInline =
false;
4270 if (isClassOrNamespaceOnly) {
4276 if (hasDictionary.IsValid() && implLineFunc.IsValid()) {
4278 bool success =
false;
4279 std::tie(success, lineNumber) =
4281 hasClassDefInline = success && (lineNumber == -1);
4289 if (hasClassDefInline)
4328 const cling::LookupHelper& lh =
fInterpreter->getLookupHelper();
4331 const clang::Decl *decl
4332 = lh.findClassTemplate(
name,
4333 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4334 : cling::LookupHelper::NoDiagnostics);
4336 std::string strname =
"std::";
4338 decl = lh.findClassTemplate(strname,
4339 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4340 : cling::LookupHelper::NoDiagnostics);
4342 return nullptr != decl;
4366 cl->
fBase = listOfBase;
4382 D =
fInterpreter->getCI()->getASTContext().getTranslationUnitDecl();
4385 if (
const clang::DeclContext* DC = dyn_cast<clang::DeclContext>(D)) {
4388 llvm::SmallVector< DeclContext *, 4> allDeclContexts;
4389 const_cast< clang::DeclContext *
>(DC)->collectAllContexts(allDeclContexts);
4390 for (llvm::SmallVector<DeclContext*, 4>::iterator declIter = allDeclContexts.begin(), declEnd = allDeclContexts.end();
4391 declIter != declEnd; ++declIter) {
4393 for (clang::DeclContext::decl_iterator DI = (*declIter)->decls_begin(),
4394 DE = (*declIter)->decls_end(); DI != DE; ++DI) {
4395 if (
const clang::EnumDecl* ED = dyn_cast<clang::EnumDecl>(*DI)) {
4398 PrintingPolicy Policy(ED->getASTContext().getPrintingPolicy());
4399 llvm::raw_string_ostream stream(buf);
4401 Policy.AnonymousTagLocations =
false;
4402 ED->getNameForDiagnostic(stream, Policy,
false);
4406 const char*
name = buf.c_str();
4430 D =
fInterpreter->getCI()->getASTContext().getTranslationUnitDecl();
4434 if (
const clang::DeclContext* DC = dyn_cast<clang::DeclContext>(D)) {
4437 llvm::SmallVector< DeclContext *, 4> allDeclContexts;
4438 const_cast< clang::DeclContext *
>(DC)->collectAllContexts(allDeclContexts);
4439 for (llvm::SmallVector<DeclContext*, 4>::iterator declIter = allDeclContexts.begin(),
4440 declEnd = allDeclContexts.end(); declIter != declEnd; ++declIter) {
4442 for (clang::DeclContext::decl_iterator DI = (*declIter)->decls_begin(),
4443 DE = (*declIter)->decls_end(); DI != DE; ++DI) {
4444 if (
const clang::FunctionTemplateDecl* FTD = dyn_cast<clang::FunctionTemplateDecl>(*DI)) {
4445 funcTempList->
Get(FTD);
4503 if (
m->fMethodArgs) {
4514 m->fMethodArgs = arglist;
4559 if (llvm::isa<clang::NamespaceDecl>(cli->
GetDecl())) {
4568 Error(
"GenerateTClass",
4569 "Cannot find %s::Class_Version()! Class version might be wrong.",
4576 if (newvers == -1) {
4584 newvers = callfunc.
ExecInt(
nullptr);
4586 Error(
"GenerateTClass",
4587 "Cannot invoke %s::Class_Version()! Class version might be wrong.",
4591 if (newvers != oldvers) {
4608static void GenerateTClass_GatherInnerIncludes(cling::Interpreter *interp,
TString &includes,
TClingClassInfo *info)
4612 const clang::ClassTemplateSpecializationDecl *templateCl
4613 = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(info->
GetDecl());
4615 for(
unsigned int i=0; i < templateCl->getTemplateArgs().
size(); ++i) {
4616 const clang::TemplateArgument &arg( templateCl->getTemplateArgs().get(i) );
4617 if (arg.getKind() == clang::TemplateArgument::Type) {
4620 if (!uType->isFundamentalType() && !uType->isEnumeralType()) {
4622 const clang::CXXRecordDecl *argdecl = uType->getAsCXXRecordDecl();
4625 TClingClassInfo subinfo(interp,*(argdecl->getASTContext().getRecordType(argdecl).getTypePtr()));
4626 GenerateTClass_GatherInnerIncludes(interp, includes, &subinfo);
4629 llvm::raw_string_ostream OS(Result);
4630 arg.print(argdecl->getASTContext().getPrintingPolicy(),OS);
4631 Warning(
"TCling::GenerateTClass",
"Missing header file for %s",OS.str().c_str());
4646 if (!info || !info->
IsValid()) {
4647 Fatal(
"GenerateTClass",
"Requires a valid ClassInfo object");
4652 std::string classname;
4656 Info(
"GenerateTClass",
"Will (try to) generate the compiled TClass for %s.",classname.c_str());
4660 GenerateTClass_GatherInnerIncludes(
fInterpreter,includes,info);
4666 Error(
"GenerateTClass",
"Even though the dictionary generation for %s seemed successful we can't find the TClass bootstrap!",classname.c_str());
4670 if (cl ==
nullptr) {
4672 cl =
new TClass(classinfo, version,
nullptr,
nullptr, -1, -1, silent);
4677 cl =
new TClass(classinfo, 1,
nullptr,
nullptr, -1, -1, silent);
4702 if (classes ==
nullptr || classes[0] == 0) {
4703 Error(
"TCling::GenerateDictionary",
"Cannot generate dictionary without passing classes.");
4707 std::vector<std::string> listClasses;
4709 const char* current = classes, *prev = classes;
4713 if (*current ==
';') {
4714 listClasses.push_back(std::string(prev, current - prev));
4717 else if (*(current + 1) == 0) {
4718 listClasses.push_back(std::string(prev, current + 1 - prev));
4722 std::vector<std::string> listIncludes;
4726 const char* current = includes, *prev = includes;
4730 if (*current ==
';') {
4731 listIncludes.push_back(std::string(prev, current - prev));
4734 else if (*(current + 1) == 0) {
4735 listIncludes.push_back(std::string(prev, current + 1 - prev));
4741 std::vector<std::string>(), std::vector<std::string>());
4765 if (
const ValueDecl* decl = (
const ValueDecl*)
d){
4768 if (hasIoName && ioName !=
name)
return nullptr;
4780 using namespace clang;
4782 DeclarationName DName = &SemaR.Context.Idents.get(
name);
4784 LookupResult
R(SemaR, DName, SourceLocation(), Sema::LookupOrdinaryName,
4785 Sema::ForExternalRedeclaration);
4787 cling::utils::Lookup::Named(&SemaR,
R);
4789 LookupResult::Filter
F =
R.makeFilter();
4791 while (
F.hasNext()) {
4792 NamedDecl *D =
F.next();
4793 if (isa<VarDecl>(D) || isa<FieldDecl>(D) || isa<EnumConstantDecl>(D) ||
4794 isa<IndirectFieldDecl>(D))
4800 if (
R.isSingleResult())
4801 return R.getFoundDecl();
4813 const clang::Decl* possibleEnum =
nullptr;
4818 const clang::DeclContext* dc =
nullptr;
4819 if (
const clang::Decl* D = cci->
GetDecl()) {
4820 if (!(dc = dyn_cast<clang::NamespaceDecl>(D))) {
4821 dc = dyn_cast<clang::RecordDecl>(D);
4828 possibleEnum = cling::utils::Lookup::Tag(&
fInterpreter->getSema(),
name, dc);
4830 Error(
"TCling::GetEnum",
"DeclContext not found for %s .\n",
name);
4839 if (possibleEnum && (possibleEnum != (clang::Decl*)-1)
4840 && isa<clang::EnumDecl>(possibleEnum)) {
4841 return possibleEnum;
4851 if (!gv)
return nullptr;
4853 llvm::StringRef mangled_name = gv->getName();
4868 std::string scopename(demangled_name_c);
4869 free(demangled_name_c);
4875 std::string dataname;
4877 if (!strncmp(scopename.c_str(),
"typeinfo for ",
sizeof(
"typeinfo for ")-1)) {
4878 scopename.erase(0,
sizeof(
"typeinfo for ")-1);
4879 }
else if (!strncmp(scopename.c_str(),
"vtable for ",
sizeof(
"vtable for ")-1)) {
4880 scopename.erase(0,
sizeof(
"vtable for ")-1);
4883 std::string::size_type pos = scopename.rfind(
'(');
4884 if (pos != std::string::npos) {
4888 pos = scopename.rfind(
':');
4889 if (pos != std::string::npos) {
4890 if ((pos != 0) && (scopename[pos-1] ==
':')) {
4891 dataname = scopename.substr(pos+1);
4892 scopename.erase(pos-1);
4896 dataname = scopename;
4904 if (scopename.size()) {
4920 Error(
"GetDataMemberWithValue()",
"not implemented");
4930 Error(
"GetDataMemberAtAddr()",
"not implemented");
4940 const char* params,
Bool_t objectIsConst )
4958 return mangled_name;
4973 GetMethod(method,
proto, objectIsConst,
nullptr ,
mode).GetMangledName();
4985 const char* params,
Bool_t objectIsConst )
5026 std::vector<DeclId_t>& res)
const
5029 clang::ASTContext& Ctx = S.Context;
5030 const clang::Decl* CtxDecl
5032 Ctx.getTranslationUnitDecl();
5033 auto RecDecl = llvm::dyn_cast<const clang::RecordDecl>(CtxDecl);
5034 const clang::DeclContext* DeclCtx = RecDecl;
5037 DeclCtx = dyn_cast<clang::NamespaceDecl>(CtxDecl);
5038 if (!DeclCtx)
return;
5040 clang::DeclarationName DName;
5045 if (RecDecl->getNameAsString() == funcname) {
5046 clang::QualType QT = Ctx.getTypeDeclType(RecDecl);
5047 DName = Ctx.DeclarationNames.getCXXConstructorName(Ctx.getCanonicalType(QT));
5048 }
else if (funcname[0] ==
'~' && RecDecl->getNameAsString() == funcname + 1) {
5049 clang::QualType QT = Ctx.getTypeDeclType(RecDecl);
5050 DName = Ctx.DeclarationNames.getCXXDestructorName(Ctx.getCanonicalType(QT));
5052 DName = &Ctx.Idents.get(funcname);
5055 DName = &Ctx.Idents.get(funcname);
5059 clang::LookupResult
R(S, DName, clang::SourceLocation(),
5060 Sema::LookupOrdinaryName, clang::Sema::NotForRedeclaration);
5061 R.suppressDiagnostics();
5062 S.LookupQualifiedName(
R,
const_cast<DeclContext*
>(DeclCtx));
5063 if (
R.empty())
return;
5065 res.reserve(res.size() + (
R.end() -
R.begin()));
5066 for (clang::LookupResult::iterator IR =
R.begin(), ER =
R.end();
5068 if (
const clang::FunctionDecl* FD
5069 = llvm::dyn_cast<const clang::FunctionDecl>(*IR)) {
5070 if (!FD->getDescribedFunctionTemplate()) {
5073 }
else if (
const auto *USD = llvm::dyn_cast<const clang::UsingShadowDecl>(*IR)) {
5075 if (llvm::isa<clang::FunctionDecl>(USD->getTargetDecl())) {
5096 GetMethod(method,
proto, objectIsConst,
nullptr ,
mode).InterfaceMethod();
5235 const char* params,
Bool_t objectIsConst,
int* error)
5255 const char* params,
int* error)
5257 Execute(obj,cl,method,params,
false,error);
5272 Error(
"Execute",
"No method was defined");
5281 if (argc > nparms) {
5282 Error(
"Execute",
"Too many parameters to call %s, got %d but expected at most %d.",method->
GetName(),argc,nparms);
5285 if (nparms != argc) {
5295 Int_t firstDefault = -1;
5296 for (
Int_t i = 0; i < nparms; i ++) {
5303 if (firstDefault >= 0) {
5304 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);
5306 Error(
"Execute",
"Too few arguments to call %s, got only %d but expected %d.",method->
GetName(),argc,nparms);
5312 const char* listpar =
"";
5317 for (
Int_t i = 0; i < argc; i ++) {
5326 chpar += (nxtpar->
String()).ReplaceAll(
"\"",
"\\\"");
5333 complete += nxtpar->
String();
5336 listpar = complete.
Data();
5363 const void* args[] ,
5368 Error(
"ExecuteWithArgsAndReturn",
"No method was defined");
5395 Warning(
"GetTopLevelMacroName",
"Must change return type!");
5442#if defined(R__MUST_REVISIT)
5443#if R__MUST_REVISIT(6,0)
5444 Warning(
"GetCurrentMacroName",
"Must change return type!");
5457 TTHREAD_TLS_DECL(std::string,t);
5459 if (!strstr(typeDesc,
"(*)(")) {
5460 const char *s = strchr(typeDesc,
' ');
5461 const char *template_start = strchr(typeDesc,
'<');
5462 if (!strcmp(typeDesc,
"long long")) {
5465 else if (!strncmp(typeDesc,
"unsigned ", s + 1 - typeDesc)) {
5472 else if (s && (template_start ==
nullptr || (s < template_start))) {
5482 auto l = t.length();
5483 while (
l > 0 && (t[
l - 1] ==
'*' || t[
l - 1] ==
'&'))
5491 assert(rootmapfile && *rootmapfile);
5493 llvm::StringRef libName = llvm::sys::path::filename(rootmapfile);
5494 libName.consume_back(
".rootmap");
5496 return !
gInterpreter->HasPCMForLibrary(libName.str().c_str());
5507 if (!(rootmapfile && *rootmapfile))
5514 const std::map<char, unsigned int> keyLenMap = {{
'c',6},{
'n',10},{
't',8},{
'h',7},{
'e',5},{
'v',4}};
5516 std::string rootmapfileNoBackslash(rootmapfile);
5518 std::replace(rootmapfileNoBackslash.begin(), rootmapfileNoBackslash.end(),
'\\',
'/');
5525 std::string lineDirective = std::string(
"\n#line 2 \"Forward declarations from ") + rootmapfileNoBackslash +
"\"\n";
5527 std::ifstream file(rootmapfileNoBackslash);
5530 std::string lib_name;
5532 bool newFormat =
false;
5533 while (getline(file,
line,
'\n')) {
5534 if (!newFormat && (
line.compare(0, 8,
"Library.") == 0 ||
line.compare(0, 8,
"Declare.") == 0)) {
5540 if (
line.compare(0, 9,
"{ decls }") == 0) {
5543 while (getline(file,
line,
'\n')) {
5546 if (!uniqueString) {
5547 Error(
"ReadRootmapFile",
"Cannot handle \"{ decls }\" sections in custom rootmap file %s",
5548 rootmapfileNoBackslash.c_str());
5551 if (!lineDirective.empty())
5552 uniqueString->
Append(lineDirective);
5556 const char firstChar =
line[0];
5557 if (firstChar ==
'[') {
5559 auto brpos =
line.find(
']');
5560 if (brpos == string::npos)
5562 lib_name =
line.substr(1, brpos - 1);
5564 lib_name.erase(lib_name.find_last_not_of(
' ') + 1);
5565 lib_name.erase(0, lib_name.find_first_not_of(
' '));
5567 TString lib_nameTstr(lib_name.c_str());
5572 Info(
"ReadRootmapFile",
"%s: New section for %s", rootmapfile, lib_nameTstr.
Data());
5574 Info(
"ReadRootmapFile",
"%s: Section for %s (library does not exist)", rootmapfile, lib_nameTstr.
Data());
5580 auto keyLenIt = keyLenMap.find(firstChar);
5581 if (keyLenIt == keyLenMap.end())
5583 unsigned int keyLen = keyLenIt->second;
5585 const char *keyname =
line.c_str() + keyLen;
5587 Info(
"ReadRootmapFile",
"%s: class %s in %s", rootmapfile, keyname, lib_name.c_str());
5590 if (lib_name != isThere->
GetValue()) {
5591 if (firstChar ==
'n') {
5593 Info(
"ReadRootmapFile",
5594 "While processing %s, namespace %s was found to be associated to %s although it is already "
5596 rootmapfile, keyname, lib_name.c_str(), isThere->
GetValue());
5597 }
else if (firstChar ==
'h') {
5603 "While processing %s, %s %s was found to be associated to %s although it is already "
5605 rootmapfile,
line.substr(0, keyLen - 1).c_str(), keyname, lib_name.c_str(),
5610 Info(
"ReadRootmapFile",
"While processing %s, key %s was found to be already defined for %s",
5611 rootmapfile, keyname, lib_name.c_str());
5672 using namespace clang;
5674 class ExtVisibleStorageAdder:
public RecursiveASTVisitor<ExtVisibleStorageAdder>{
5680 ExtVisibleStorageAdder(std::unordered_set<const NamespaceDecl*>& nsSet): fNSSet(nsSet) {};
5681 bool VisitNamespaceDecl(NamespaceDecl* nsDecl) {
5686 nsDecl->setHasExternalVisibleStorage();
5687 fNSSet.insert(nsDecl);
5690 bool VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl* specDecl) {
5693 if (specDecl->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
5695 specDecl->setHasExternalLexicalStorage();
5707 std::unordered_set<const NamespaceDecl*>& fNSSet;
5754 for (
Int_t j = 0; j < i; j++) {
5765 Info(
"LoadLibraryMap",
"%s",
d.Data());
5770 if (
f.EndsWith(
".rootmap")) {
5776 Info(
"LoadLibraryMap",
" rootmap file: %s",
p.Data());
5794 if (
f.BeginsWith(
"rootmap")) {
5799 Warning(
"LoadLibraryMap",
"please rename %s to end with \".rootmap\"",
p.Data());
5812 if (rootmapfile && *rootmapfile) {
5819 else if (res == -3) {
5829 while ((rec = (
TEnvRec*) next())) {
5831 if (!strncmp(cls.
Data(),
"Library.", 8) && cls.
Length() > 8) {
5833 TString libs = rec->GetValue();
5850 Info(
"LoadLibraryMap",
"class %s in %s", cls.
Data(), wlib);
5853 Info(
"LoadLibraryMap",
"class %s in %s (library does not exist)", cls.
Data(), lib);
5859 else if (!strncmp(cls.
Data(),
"Declare.", 8) && cls.
Length() > 8) {
5869 cling::Transaction* T =
nullptr;
5871 assert(cling::Interpreter::kSuccess == compRes &&
"A declaration in a rootmap could not be compiled");
5873 if (compRes!=cling::Interpreter::kSuccess){
5875 "Problems in %s declaring '%s' were encountered.", rootmapfile, uniqueString.
Data()) ;
5880 for (
auto declIt = T->decls_begin(); declIt < T->decls_end(); ++declIt) {
5881 if (declIt->m_DGR.isSingleDecl()) {
5882 if (Decl* D = declIt->m_DGR.getSingleDecl()) {
5883 if (clang::isa<TagDecl>(D) || clang::isa<NamespaceDecl>(D)) {
5884 evsAdder.TraverseDecl(D);
5919 for (
Int_t ilib = 0; ilib < nrSharedLibs; ilib++) {
5926 TString rootMapBaseStr = sharedLibBaseStr;
5927 if (sharedLibBaseStr.
EndsWith(
".dll")) {
5930 else if (sharedLibBaseStr.
EndsWith(
".DLL")) {
5933 else if (sharedLibBaseStr.
EndsWith(
".so")) {
5936 else if (sharedLibBaseStr.
EndsWith(
".sl")) {
5939 else if (sharedLibBaseStr.
EndsWith(
".dl")) {
5942 else if (sharedLibBaseStr.
EndsWith(
".a")) {
5946 Error(
"ReloadAllSharedLibraryMaps",
"Unknown library type %s", sharedLibBaseStr.
Data());
5950 rootMapBaseStr +=
".rootmap";
5953 Error(
"ReloadAllSharedLibraryMaps",
"Could not find rootmap %s in path", rootMapBaseStr.
Data());
5960 Error(
"ReloadAllSharedLibraryMaps",
"Error loading map %s", rootMap);
5995 if (!
fMapfile || !library || !*library) {
6008 while ((rec = (
TEnvRec *) next())) {
6012 TString libs = rec->GetValue();
6019 if (!strncmp(cls.
Data(),
"Library.", 8) && cls.
Length() > 8) {
6028 if (!strncmp(lib, libname.
Data(),
len)) {
6030 Error(
"UnloadLibraryMap",
"entry for <%s, %s> not found in library map table", cls.
Data(), lib);
6038 TString library_rootmap(library);
6039 if (!library_rootmap.
EndsWith(
".rootmap"))
6040 library_rootmap.
Append(
".rootmap");
6091 if (err)
return nullptr;
6093 free(demangled_name);
6111 std::string demangled_name(demangled_name_c);
6112 free(demangled_name_c);
6144 if (
gROOT->LoadClass(cls, deplib) == 0) {
6147 "loaded dependent library %s for %s", deplib, cls);
6152 "failure loading dependent library %s for %s",
6157 if (lib && lib[0]) {
6158 if (
gROOT->LoadClass(cls, lib) == 0) {
6161 "loaded library %s for %s", lib, cls);
6167 "failure loading library %s for %s", lib, cls);
6182 bool nameIsNormalized)
6188 if (!visited.insert(std::string(cls)).second)
6198 for (
auto element :
proto->GetData()) {
6199 if (element->IsBasic())
6201 const char *subtypename = element->GetTypeName();
6217 if (classinfo &&
gInterpreter->ClassInfo_IsValid(classinfo)
6221 while (
gInterpreter->DataMemberInfo_Next(memberinfo)) {
6254 Info(
"TCling::AutoLoad",
"Explicitly disabled (the class name is %s)", cls);
6274 Info(
"TCling::AutoLoad",
6275 "Trying to autoload for %s", cls);
6280 Info(
"TCling::AutoLoad",
6281 "Disabled due to gROOT or gInterpreter being invalid/not ready (the class name is %s)", cls);
6302 std::unordered_set<std::string> visited;
6311 cling::Interpreter *interpreter)
6313 std::string code = gNonInterpreterClassDef ;
6320 code += (
"#include \"");
6324 code += (
"#ifdef __ROOTCLING__\n"
6325 "#undef __ROOTCLING__\n"
6326 + gInterpreterClassDef +
6329 cling::Interpreter::CompilationResult cr;
6335 Sema &SemaR = interpreter->getSema();
6337 clangDiagSuppr diagSuppr(SemaR.getDiagnostics());
6339 #if defined(R__MUST_REVISIT)
6340 #if R__MUST_REVISIT(6,2)
6341 Warning(
"TCling::RegisterModule",
"Diagnostics suppression should be gone by now.");
6345 cr = interpreter->parseForModule(code);
6363 Int_t nHheadersParsed = 0;
6364 unsigned long offset = 0;
6365 if (strncmp(cls,
"const ", 6) == 0) {
6370 bool skipFirstEntry =
false;
6371 std::vector<std::string> autoparseKeys;
6372 if (strchr(cls,
'<')) {
6378 if (!autoparseKeys.empty() && !autoparseKeys[0].empty()) {
6383 TString templateName(autoparseKeys[0]);
6384 auto tokens = templateName.
Tokenize(
"::");
6385 clang::NamedDecl* previousScopeAsNamedDecl =
nullptr;
6386 clang::DeclContext* previousScopeAsContext =
fInterpreter->getCI()->getASTContext().getTranslationUnitDecl();
6388 previousScopeAsContext =
fInterpreter->getSema().getStdNamespace();
6390 for (
Int_t tk = 0; tk < nTokens; ++tk) {
6391 auto scopeObj = tokens->UncheckedAt(tk);
6392 auto scopeName = ((
TObjString*) scopeObj)->String().Data();
6393 previousScopeAsNamedDecl = cling::utils::Lookup::Named(&
fInterpreter->getSema(), scopeName, previousScopeAsContext);
6395 if ((clang::NamedDecl*)-1 == previousScopeAsNamedDecl)
break;
6396 previousScopeAsContext = llvm::dyn_cast_or_null<clang::DeclContext>(previousScopeAsNamedDecl);
6397 if (!previousScopeAsContext)
break;
6401 if ((clang::NamedDecl*)-1 != previousScopeAsNamedDecl) {
6402 if (
auto templateDecl = llvm::dyn_cast_or_null<clang::ClassTemplateDecl>(previousScopeAsNamedDecl)) {
6403 if (
auto templatedDecl = templateDecl->getTemplatedDecl()) {
6404 skipFirstEntry = templatedDecl->hasDefinition();
6411 if (topLevel) autoparseKeys.emplace_back(cls);
6413 for (
const auto & apKeyStr : autoparseKeys) {
6414 if (skipFirstEntry) {
6415 skipFirstEntry=
false;
6418 if (apKeyStr.empty())
continue;
6419 const char *apKey = apKeyStr.c_str();
6423 Info(
"TCling::AutoParse",
6424 "Starting autoparse for %s\n", apKey);
6429 const cling::Transaction *T =
fInterpreter->getCurrentTransaction();
6431 auto const &hNamesPtrs = iter->second;
6433 Info(
"TCling::AutoParse",
6434 "We can proceed for %s. We have %s headers.", apKey, std::to_string(hNamesPtrs.size()).c_str());
6436 for (
auto & hName : hNamesPtrs) {
6438 if (0 !=
fPayloads.count(normNameHash)) {
6439 float initRSSval=0.f, initVSIZEval=0.f;
6441 (void) initVSIZEval;
6444 "Parsing full payload for %s", apKey);
6451 if (cRes != cling::Interpreter::kSuccess) {
6452 if (hName[0] ==
'\n')
6453 Error(
"AutoParse",
"Error parsing payload code for class %s with content:\n%s", apKey, hName);
6462 Info(
"Autoparse",
">>> RSS key %s - before %.3f MB - after %.3f MB - delta %.3f MB", apKey, initRSSval, endRSSval, endRSSval-initRSSval);
6463 Info(
"Autoparse",
">>> VSIZE key %s - before %.3f MB - after %.3f MB - delta %.3f MB", apKey, initVSIZEval, endVSIZEval, endVSIZEval-initVSIZEval);
6469 "Parsing single header %s", hName);
6472 if (cRes != cling::Interpreter::kSuccess) {
6473 Error(
"AutoParse",
"Error parsing headerfile %s for class %s.", hName, apKey);
6485 if (strchr(apKey,
'<')) {
6492 return nHheadersParsed;
6502 if (llvm::StringRef(cls).contains(
"(lambda)"))
6516 Info(
"TCling::AutoParse",
6517 "Trying to autoparse for %s", cls);
6539 return nHheadersParsed > 0 ? 1 : 0;
6547 StringRef errMsg(errmessage);
6548 if (errMsg.contains(
"undefined symbol: ")) {
6550 std::string mangled_name = std::string(errMsg.split(
"undefined symbol: ").second);
6551 void* res = ((
TCling*)
gCling)->LazyFunctionCreatorAutoload(mangled_name);
6552 cling::DynamicLibraryManager* DLM =
fInterpreter->getDynamicLibraryManager();
6553 if (res && DLM && (DLM->loadLibrary(libStem, permanent, resolved) == cling::DynamicLibraryManager::kLoadLibSuccess))
6572 if (
void* Addr = llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(dlsym_mangled_name))
6575 const cling::DynamicLibraryManager &DLM = *
GetInterpreterImpl()->getDynamicLibraryManager();
6578 auto LibLoader = [](
const std::string& LibName) ->
bool {
6579 if (
gSystem->
Load(LibName.c_str(),
"",
false) < 0) {
6580 ::Error(
"TCling__LazyFunctionCreatorAutoloadForModule",
6581 "Failed to load library %s", LibName.c_str());
6587 std::string libName = DLM.searchLibrariesForSymbol(mangled_name,
6590 assert(!llvm::StringRef(libName).startswith(
"libNew") &&
6591 "We must not resolve symbols from libNew!");
6593 if (libName.empty())
6596 if (!LibLoader(libName))
6599 return llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(dlsym_mangled_name);
6619 const NamedDecl *oldDef = llvm::dyn_cast_or_null<NamedDecl>(cci->
GetDecl());
6620 if (!oldDef || (def && def != oldDef)) {
6634 if (!alias && def !=
nullptr)
6656 const TagDecl *td = dyn_cast<TagDecl>(ND);
6657 const NamespaceDecl *ns = dyn_cast<NamespaceDecl>(ND);
6658 const NamedDecl *canon =
nullptr;
6661 TagDecl* tdDef =
nullptr;
6663 canon = tdDef = td->getDefinition();
6667 if (!tdDef->isCompleteDefinition() || llvm::isa<clang::FunctionDecl>(tdDef->getDeclContext())) {
6673 auto declName = tdDef->getNameAsString();
6684 clang::QualType
type(tdDef->getTypeForDecl(), 0);
6687 canon = ns->getCanonicalDecl();
6688 name = ND->getQualifiedNameAsString();
6690 name = ND->getQualifiedNameAsString();
6739 std::set<TClass*> modifiedTClasses;
6744 bool isTUTransaction =
false;
6745 if (!T.empty() && T.decls_begin() + 1 == T.decls_end() && !T.hasNestedTransactions()) {
6746 clang::Decl* FirstDecl = *(T.decls_begin()->m_DGR.begin());
6747 if (llvm::isa<clang::TranslationUnitDecl>(FirstDecl)) {
6750 isTUTransaction =
true;
6754 std::set<const void*> TransactionDeclSet;
6755 if (!isTUTransaction && T.decls_end() - T.decls_begin()) {
6756 const clang::Decl* WrapperFD = T.getWrapperFD();
6757 for (cling::Transaction::const_iterator
I = T.decls_begin(), E = T.decls_end();
6759 if (
I->m_Call != cling::Transaction::kCCIHandleTopLevelDecl
6760 &&
I->m_Call != cling::Transaction::kCCIHandleTagDeclDefinition)
6763 for (DeclGroupRef::const_iterator DI =
I->m_DGR.begin(),
6764 DE =
I->m_DGR.end(); DI != DE; ++DI) {
6765 if (*DI == WrapperFD)
6767 TransactionDeclSet.insert(*DI);
6768 ((
TCling*)
gCling)->HandleNewDecl(*DI,
false, modifiedTClasses);
6775 for (cling::Transaction::const_iterator
I = T.deserialized_decls_begin(),
6776 E = T.deserialized_decls_end();
I != E; ++
I) {
6777 for (DeclGroupRef::const_iterator DI =
I->m_DGR.begin(),
6778 DE =
I->m_DGR.end(); DI != DE; ++DI)
6779 if (TransactionDeclSet.find(*DI) == TransactionDeclSet.end()) {
6795 std::vector<TClass*> modifiedTClassesDiff(modifiedTClasses.size());
6796 std::vector<TClass*>::iterator it;
6797 it = set_difference(modifiedTClasses.begin(), modifiedTClasses.end(),
6800 modifiedTClassesDiff.begin());
6801 modifiedTClassesDiff.resize(it - modifiedTClassesDiff.begin());
6804 ((
TCling*)
gCling)->GetModTClasses().insert(modifiedTClassesDiff.begin(),
6805 modifiedTClassesDiff.end());
6806 for (std::vector<TClass*>::const_iterator
I = modifiedTClassesDiff.begin(),
6807 E = modifiedTClassesDiff.end();
I != E; ++
I) {
6809 if (!
gROOT->GetListOfClasses()->FindObject(*
I)) {
6831 cling::Transaction::const_nested_iterator iNested = T.nested_begin();
6832 for (cling::Transaction::const_iterator
I = T.decls_begin(), E = T.decls_end();
6834 if (
I->m_Call == cling::Transaction::kCCIHandleVTable)
6836 if (
I->m_Call == cling::Transaction::kCCINone) {
6842 for (
auto &D :
I->m_DGR)
6868 if (D->isFromASTFile())
6876 if (isa<VarDecl>(D) || isa<FieldDecl>(D) || isa<EnumConstantDecl>(D)) {
6882 }
else if (isa<FunctionDecl>(D)) {
6884 }
else if (isa<FunctionTemplateDecl>(D)) {
6886 }
else if (isa<EnumDecl>(D)) {
6897 }
else if (isa<RecordDecl>(D) || isa<NamespaceDecl>(D)) {
6898 if (isa<RecordDecl>(D) && !cast<RecordDecl>(D)->isCompleteDefinition())
6901 std::vector<TClass *> Classes;
6904 for (
auto &C : Classes) {
6909 for (
auto &
I : cast<DeclContext>(D)->decls())
6913 if (D->getKind() != Decl::Namespace
6914 || cast<NamespaceDecl>(D)->isOriginalNamespace())
6915 C->ResetClassInfo();
6927 std::size_t normNameHash = triter->second;
6933 auto const &hNamesPtrs = iter->second;
6934 for (
auto &hName : hNamesPtrs) {
6936 Info(
"TransactionRollback",
6937 "Restoring ability to autoaparse: %s", hName);
6974 using namespace clang;
6975 if (
const Decl *D = LH.findScope(cls, cling::LookupHelper::NoDiagnostics,
6977 if (!D->isFromASTFile()) {
6979 Warning(
"GetClassSharedLibsForModule",
"Decl found for %s is not part of a module", cls);
6982 class ModuleCollector :
public ConstDeclVisitor<ModuleCollector> {
6983 llvm::DenseSet<Module *> &m_TopLevelModules;
6986 ModuleCollector(llvm::DenseSet<Module *> &TopLevelModules) : m_TopLevelModules(TopLevelModules) {}
6987 void Collect(
const Decl *D) { Visit(D); }
6989 void VisitDecl(
const Decl *D)
6999 if (!D->hasOwningModule())
7001 if (Module *M = D->getOwningModule()->getTopLevelModule())
7002 m_TopLevelModules.insert(M);
7005 void VisitTemplateArgument(
const TemplateArgument &
TA)
7007 switch (
TA.getKind()) {
7008 case TemplateArgument::Null:
7009 case TemplateArgument::Integral:
7010 case TemplateArgument::Pack:
7011 case TemplateArgument::NullPtr:
7012 case TemplateArgument::Expression:
7013 case TemplateArgument::Template:
7014 case TemplateArgument::TemplateExpansion:
return;
7015 case TemplateArgument::Type:
7016 if (
const TagType *TagTy = dyn_cast<TagType>(
TA.getAsType()))
7017 return Visit(TagTy->getDecl());
7019 case TemplateArgument::Declaration:
return Visit(
TA.getAsDecl());
7021 llvm_unreachable(
"Invalid TemplateArgument::Kind!");
7024 void VisitClassTemplateSpecializationDecl(
const ClassTemplateSpecializationDecl *CTSD)
7026 if (CTSD->getOwningModule())
7029 VisitDecl(CTSD->getSpecializedTemplate());
7030 const TemplateArgumentList &ArgList = CTSD->getTemplateArgs();
7031 for (
const TemplateArgument *Arg = ArgList.data(), *ArgEnd = Arg + ArgList.size(); Arg != ArgEnd; ++Arg) {
7032 VisitTemplateArgument(*Arg);
7037 llvm::DenseSet<Module *> TopLevelModules;
7038 ModuleCollector
m(TopLevelModules);
7041 for (
auto M : TopLevelModules) {
7044 if (!M->LinkLibraries.size())
7047 if (M->Name ==
"Core" && skipCore)
7049 assert(M->LinkLibraries.size() == 1);
7052 result += M->LinkLibraries[0].Library;
7075 llvm::StringRef className = cls;
7081 if (className.contains(
"(lambda)"))
7085 cling::LookupHelper &LH =
fInterpreter->getLookupHelper();
7087 if (!libs.empty()) {
7093 if (!cls || !*cls) {
7098 TEnvRec* libs_record =
nullptr;
7101 const char* libs = libs_record->
GetValue();
7102 return (*libs) ? libs :
nullptr;
7116 TEnvRec* libs_record =
nullptr;
7119 const char* libs = libs_record->
GetValue();
7120 return (*libs) ? libs :
nullptr;
7134 cling::Interpreter *interp,
7135 bool skipLoadedLibs =
true)
7138 if (!llvm::sys::path::is_absolute(lib)) {
7140 Error(
"TCling__GetSharedLibImmediateDepsSlow",
"Cannot find library '%s'", lib.c_str());
7144 assert(llvm::sys::fs::exists(lib) &&
"Must exist!");
7145 lib = llvm::sys::path::filename(lib).str();
7148 auto ObjF = llvm::object::ObjectFile::createObjectFile(LibFullPath.
Data());
7150 Warning(
"TCling__GetSharedLibImmediateDepsSlow",
"Failed to read object file %s", lib.c_str());
7154 llvm::object::ObjectFile *BinObjFile = ObjF.get().getBinary();
7156 std::set<string> DedupSet;
7157 std::string Result = lib +
' ';
7158 for (
const auto &S : BinObjFile->symbols()) {
7159 uint32_t Flags = llvm::cantFail(S.getFlags());
7161 if (!(Flags & llvm::object::SymbolRef::SF_Undefined))
7165 if (Flags & llvm::object::SymbolRef::SF_Weak)
7167 llvm::Expected<StringRef> SymNameErr = S.getName();
7169 Warning(
"GetSharedLibDepsForModule",
"Failed to read symbol");
7172 llvm::StringRef SymName = SymNameErr.get();
7173 if (SymName.empty())
7176 if (BinObjFile->isELF()) {
7180 if (SymName.contains(
"@GLIBCXX") || SymName.contains(
"@CXXABI") ||
7181 SymName.contains(
"@GLIBC") || SymName.contains(
"@GCC"))
7189 static constexpr llvm::StringRef RegisterClasses(
"_Jv_RegisterClasses");
7190 static constexpr llvm::StringRef RegisterCloneTable(
"_ITM_registerTMCloneTable");
7191 static constexpr llvm::StringRef DeregisterCloneTable(
"_ITM_deregisterTMCloneTable");
7192 if (SymName == RegisterClasses ||
7193 SymName == RegisterCloneTable ||
7194 SymName == DeregisterCloneTable)
7199 if (skipLoadedLibs) {
7201 if (llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(SymNameForDlsym))
7206 std::string found = interp->getDynamicLibraryManager()->searchLibrariesForSymbol(SymName,
false);
7212 if (!found.empty()) {
7213 std::string cand = llvm::sys::path::filename(found).str();
7214 if (!DedupSet.insert(cand).second)
7217 Result += cand +
' ';
7227 llvm::SmallString<256> rootmapName;
7228 if (!lib.startswith(
"lib"))
7229 rootmapName.append(
"lib");
7231 rootmapName.append(llvm::sys::path::filename(lib));
7232 llvm::sys::path::replace_extension(rootmapName,
"rootmap");
7238 llvm::StringRef rootmapNameNoLib = rootmapName.str();
7239 if (rootmapNameNoLib.consume_front(
"lib"))
7263 if (llvm::sys::path::is_absolute(lib) && !llvm::sys::fs::exists(lib))
7267 llvm::SmallString<512> rootmapName(lib);
7268 llvm::sys::path::replace_extension(rootmapName,
"rootmap");
7269 if (llvm::sys::fs::exists(rootmapName)) {
7271 Info(
"Load",
"loading %s", rootmapName.c_str());
7278 Warning(
"TCling::GetSharedLibDeps",
"Precomputed dependencies available but scanning '%s'", lib);
7283 if (!libs.empty()) {
7289 if (!
fMapfile || !lib || !lib[0]) {
7300 while ((rec = (
TEnvRec*) next())) {
7301 const char* libs = rec->GetValue();
7302 if (!strncmp(libs, libname.
Data(),
len) && strlen(libs) >=
len
7303 && (!libs[
len] || libs[
len] ==
' ' || libs[
len] ==
'.')) {
7316#if defined(R__MUST_REVISIT)
7317#if R__MUST_REVISIT(6,2)
7318 Warning(
"IsErrorMessagesEnabled",
"Interface not available yet.");
7330#if defined(R__MUST_REVISIT)
7331#if R__MUST_REVISIT(6,2)
7332 Warning(
"SetErrorMessages",
"Interface not available yet.");
7348 llvm::SmallVector<std::string, 10> includePaths;
7350 fInterpreter->GetIncludePaths(includePaths,
false,
true);
7351 if (
const size_t nPaths = includePaths.size()) {
7352 assert(!(nPaths & 1) &&
"GetIncludePath, number of paths and options is not equal");
7354 for (
size_t i = 0; i < nPaths; i += 2) {
7359 if (includePaths[i] !=
"-I")
7393 assert(fout !=
nullptr &&
"DisplayIncludePath, 'fout' parameter is null");
7395 llvm::SmallVector<std::string, 10> includePaths;
7397 fInterpreter->GetIncludePaths(includePaths,
false,
true);
7398 if (
const size_t nPaths = includePaths.size()) {
7399 assert(!(nPaths & 1) &&
"DisplayIncludePath, number of paths and options is not equal");
7401 std::string allIncludes(
"include path:");
7402 for (
size_t i = 0; i < nPaths; i += 2) {
7404 allIncludes += includePaths[i];
7406 if (includePaths[i] !=
"-I")
7408 allIncludes += includePaths[i + 1];
7411 fprintf(fout,
"%s\n", allIncludes.c_str());
7431#if defined(R__MUST_REVISIT)
7432#if R__MUST_REVISIT(6,2)
7433 Warning(
"GenericError",
"Interface not available yet.");
7461#if defined(R__MUST_REVISIT)
7462#if R__MUST_REVISIT(6,2)
7463 Warning(
"GetSecurityError",
"Interface not available yet.");
7476 cling::Interpreter::CompilationResult compRes;
7478 return compRes == cling::Interpreter::kFailure;
7497 TTHREAD_TLS_DECL(std::string,buffer);
7499 return buffer.c_str();
7580#if defined(R__MUST_REVISIT)
7581#if R__MUST_REVISIT(6,2)
7582 Warning(
"SetErrmsgcallback",
"Interface not available yet.");
7591 &
fInterpreter->getDiagnostics().getDiagnosticOptions(),
7593 [] (clang::DiagnosticsEngine::Level Level,
const std::string &
Info) {
7594 if (Level == clang::DiagnosticsEngine::Warning) {
7595 ::Warning(
"cling",
"%s", Info.c_str());
7596 }
else if (Level == clang::DiagnosticsEngine::Error
7597 || Level == clang::DiagnosticsEngine::Fatal) {
7603 fInterpreter->replaceDiagnosticConsumer(consumer,
true);
7605 fInterpreter->replaceDiagnosticConsumer(
nullptr);
7624 cling::DynamicLibraryManager* DLM =
fInterpreter->getDynamicLibraryManager();
7625 std::string canonical = DLM->lookupLibrary(path);
7626 if (canonical.empty()) {
7630 cling::Interpreter::CompilationResult compRes;
7632 return compRes == cling::Interpreter::kFailure;
7636 return std::unique_ptr<TInterpreterValue>(
new TClingValue);
7643 std::vector<std::string>& completions)
7652 auto V =
reinterpret_cast<cling::Value*
>(
value.GetValAddr());
7654 return compRes!=cling::Interpreter::kSuccess ? 0 : 1 ;
7661 using namespace cling;
7675 if (
value.isValid() &&
value.needsManagedAllocation()) {
7696 auto iSpecObj = iSpecObjMap->second.find(Name);
7697 if (iSpecObj != iSpecObjMap->second.end()) {
7699 return iSpecObj->second;
7706 ASTContext& C = SemaR.getASTContext();
7707 Preprocessor &PP = SemaR.getPreprocessor();
7708 Parser& P =
const_cast<Parser&
>(
fInterpreter->getParser());
7709 Preprocessor::CleanupAndRestoreCacheRAII cleanupRAII(PP);
7710 Parser::ParserCurTokRestoreRAII savedCurToken(P);
7713 Token& Tok =
const_cast<Token&
>(P.getCurToken());
7714 Tok.setKind(tok::semi);
7720 Sema::ContextAndScopeRAII pushedDCAndS(SemaR, C.getTranslationUnitDecl(),
7723 TObject* specObj =
gROOT->FindSpecialObject(Name, LookupCtx);
7726 Error(
"GetObjectAddress",
"Got a special object without LookupCtx!");
7740 clang::CXXRecordDecl* klass)
const
7742 using namespace clang;
7743 ASTContext& Ctx = klass->getASTContext();
7744 FriendDecl::FriendUnion friendUnion(
function);
7747 FriendDecl* friendDecl = FriendDecl::Create(Ctx, klass, sl, friendUnion, sl);
7748 klass->pushFriendDecl(friendDecl);
7762 if (func)
return ((
TClingCallFunc*)func)->GetDecl()->getCanonicalDecl();
7833 f->
Exec(address, &val);
7847 const void* args[] ,
8014 f->SetFunc(ci, method, params,
offset);
8023 f->SetFunc(ci, method, params, objectIsConst,
offset);
8061 llvm::SmallVector<clang::QualType, 4> funcProto;
8062 for (std::vector<TypeInfo_t*>::const_iterator iter =
proto.begin(), end =
proto.end();
8063 iter != end; ++iter) {
8064 funcProto.push_back( ((
TClingTypeInfo*)(*iter))->GetQualType() );
8066 f->SetFuncProto(ci, method, funcProto,
offset,
mode);
8076 llvm::SmallVector<clang::QualType, 4> funcProto;
8077 for (std::vector<TypeInfo_t*>::const_iterator iter =
proto.begin(), end =
proto.end();
8078 iter != end; ++iter) {
8079 funcProto.push_back( ((
TClingTypeInfo*)(*iter))->GetQualType() );
8081 f->SetFuncProto(ci, method, funcProto, objectIsConst,
offset,
mode);
8087 std::string wrapper_name;
8088 std::string wrapper;
8108 const clang::DeclContext *ctxt =
nullptr;
8110 ctxt = clang::Decl::castToDeclContext(((
TClingClassInfo*)info)->GetDecl());
8112 ctxt =
fInterpreter->getCI()->getASTContext().getTranslationUnitDecl();
8117 const clang::Decl *decl =
reinterpret_cast<const clang::Decl*
>(declid);
8121 const clang::DeclContext *declDC = decl->getDeclContext();
8124 if (declDC->isTransparentContext()) {
8125 declDC = declDC->getParent();
8128 if (
const auto *declRD = llvm::dyn_cast<clang::RecordDecl>(declDC)) {
8129 if (declRD->isAnonymousStructOrUnion()) {
8130 declDC = declRD->getParent();
8134 if (
const auto *declNS = llvm::dyn_cast<clang::NamespaceDecl>(declDC)) {
8135 if (declNS->isAnonymousNamespace() || declNS->isInlineNamespace()) {
8136 declDC = declNS->getParent();
8143 return declDC->Equals(ctxt);
8254 TClinginfo->
Init(tagnum);
8327 return TClinginfo->
Next();
8375 return TClinginfo->
Size();
8383 return TClinginfo->
Tagnum();
8399 TTHREAD_TLS_DECL(std::string,
output);
8409 return TClinginfo->
Name();
8417 return TClinginfo->
Title();
8454 ClassInfo_t* base)
const
8467 return TClinginfo->
Next();
8475 return TClinginfo->
Next(onlyDirect);
8483 return TClinginfo->
Offset(address, isDerivedObject);
8496 return TClinginfo->
GetBaseOffset(TClinginfoBase, address, isDerivedObject);
8512 return (ClassInfo_t *)TClinginfo->
GetBase();
8520 return TClinginfo->
Tagnum();
8528 TTHREAD_TLS_DECL(std::string,
output);
8538 return TClinginfo->
Name();
8583 const clang::Decl* decl =
reinterpret_cast<const clang::Decl*
>(declid);
8584 const clang::ValueDecl* vd = llvm::dyn_cast_or_null<clang::ValueDecl>(decl);
8617 return TClinginfo->
Next();
8625 return TClinginfo->
Offset();
8673 return TClinginfo->
Name();
8681 return TClinginfo->
Title();
8688 TTHREAD_TLS_DECL(std::string,
result);
8699 Decl* decl =
static_cast<Decl*
>(
const_cast<void*
>(declId));
8700 ASTContext &C = decl->getASTContext();
8701 decl->addAttr(AnnotateAttr::CreateImplicit(C, attribute));
8712 cling::Interpreter &interp,
8715 const clang::TypeDecl* td = llvm::dyn_cast<clang::TypeDecl>(decl->getDeclContext());
8718 clang::QualType qualType(td->getTypeForDecl(),0);
8720 unsigned int level = 0;
8723 else if (
name[
cursor] ==
'<' && level) --level;
8724 else if (level == 0 &&
name[
cursor] ==
':') {
8737 const auto *FD = llvm::dyn_cast<clang::FunctionDecl>(decl);
8738 if (
const auto *USD = llvm::dyn_cast<clang::UsingShadowDecl>(decl)) {
8739 FD = llvm::dyn_cast<clang::FunctionDecl>(USD->getTargetDecl());
8742 Error(
"GetFunctionName",
"NULL Decl!");
8749 if (llvm::isa<clang::CXXConstructorDecl>(FD))
8753 }
else if (llvm::isa<clang::CXXDestructorDecl>(decl))
8758 llvm::raw_string_ostream stream(
output);
8759 auto printPolicy = decl->getASTContext().getPrintingPolicy();
8761 printPolicy.AnonymousTagLocations =
false;
8762 FD->getNameForDiagnostic(stream, printPolicy,
false);
8792 return (FuncTempInfo_t*)
const_cast<void*
>(declid);
8803 return (FuncTempInfo_t*)ft_info;
8814 return t_info !=
nullptr;
8823 if (!ft_info)
return 0;
8824 const clang::FunctionTemplateDecl *ft = (
const clang::FunctionTemplateDecl*)ft_info;
8825 return ft->getTemplateParameters()->size();
8834 if (!ft_info)
return 0;
8835 const clang::FunctionTemplateDecl *ft = (clang::FunctionTemplateDecl*)ft_info;
8836 return ft->getTemplateParameters()->getMinRequiredArguments();
8844 if (!ft_info)
return 0;
8849 const clang::FunctionTemplateDecl *ft = (clang::FunctionTemplateDecl*)ft_info;
8851 switch (ft->getAccess()) {
8852 case clang::AS_public:
8855 case clang::AS_protected:
8858 case clang::AS_private:
8861 case clang::AS_none:
8862 if (ft->getDeclContext()->isNamespace())
8870 const clang::FunctionDecl *fd = ft->getTemplatedDecl();
8871 if (
const clang::CXXMethodDecl *md =
8872 llvm::dyn_cast<clang::CXXMethodDecl>(fd)) {
8873 if (md->getMethodQualifiers().hasConst()) {
8876 if (md->isVirtual()) {
8882 if (
const clang::CXXConstructorDecl *cd =
8883 llvm::dyn_cast<clang::CXXConstructorDecl>(md)) {
8884 if (cd->isExplicit()) {
8888 else if (
const clang::CXXConversionDecl *cd =
8889 llvm::dyn_cast<clang::CXXConversionDecl>(md)) {
8890 if (cd->isExplicit()) {
8904 if (!ft_info)
return 0;
8909 const clang::FunctionTemplateDecl *ft = (clang::FunctionTemplateDecl*)ft_info;
8910 const clang::FunctionDecl *fd = ft->getTemplatedDecl();
8912 if (fd->isOverloadedOperator())
8914 if (llvm::isa<clang::CXXConversionDecl>(fd))
8916 if (llvm::isa<clang::CXXConstructorDecl>(fd))
8918 if (llvm::isa<clang::CXXDestructorDecl>(fd))
8920 if (fd->isInlined())
8931 if (!ft_info)
return;
8932 const clang::FunctionTemplateDecl *ft = (clang::FunctionTemplateDecl*)ft_info;
8944 if (!ft_info)
return;
8945 const clang::FunctionTemplateDecl *ft = (
const clang::FunctionTemplateDecl*)ft_info;
8949 if (
const RedeclarableTemplateDecl *AnnotFD
8951 if (AnnotateAttr *A = AnnotFD->getAttr<AnnotateAttr>()) {
8952 output = A->getAnnotation().str();
8956 if (!ft->isFromASTFile()) {
9007 const clang::Decl* decl =
reinterpret_cast<const clang::Decl*
>(declid);
9041 return info->
NArg();
9057 return info->
Next();
9084 return (TypeInfo_t*)info->
Type();
9092 TTHREAD_TLS_DECL(
TString, mangled_name);
9095 return mangled_name;
9113 return info->
Name();
9143 return info->
Title();
9151 return MethodInfo_MethodCallReturnType(func->fInfo);
9153 return EReturnType::kOther;
9162 if (info && info->
IsValid()) {
9164 clang::QualType QT( typeinfo->
GetQualType().getCanonicalType() );
9165 if (QT->isEnumeralType()) {
9166 return EReturnType::kLong;
9167 }
else if (QT->isPointerType()) {
9169 QT = llvm::cast<clang::PointerType>(QT)->getPointeeType();
9170 if ( QT->isCharType() ) {
9171 return EReturnType::kString;
9173 return EReturnType::kOther;
9175 }
else if ( QT->isFloatingType() ) {
9176 int sz = typeinfo->
Size();
9177 if (sz == 4 || sz == 8) {
9179 return EReturnType::kDouble;
9181 return EReturnType::kOther;
9183 }
else if ( QT->isIntegerType() ) {
9184 int sz = typeinfo->
Size();
9193 return EReturnType::kLong;
9195 return EReturnType::kOther;
9198 return EReturnType::kOther;
9201 return EReturnType::kOther;
9237 return (MethodArgInfo_t*)
9254 return info->
Next();
9278 return info->
Name();
9302 return (TypeInfo_t*) info->
Type();
9362 return TClinginfo->
Name();
9386 return TClinginfo->
Size();
9444 const char*
name)
const
9464 return TClinginfo->
Next();
9480 return TClinginfo->
Size();
9496 return TClinginfo->
Name();
9504 return TClinginfo->
Title();
9511 clang::QualType QT1 = clang::QualType::getFromOpaquePtr(QualTypePtr1);
9512 clang::QualType QT2 = clang::QualType::getFromOpaquePtr(QualTypePtr2);
9513 return fInterpreter->getCI()->getASTContext().hasSameType(QT1, QT2);
9520 clang::QualType QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9521 return QT->hasIntegerRepresentation();
9528 clang::QualType QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9529 return QT->hasSignedIntegerRepresentation();
9536 clang::QualType QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9537 return QT->hasUnsignedIntegerRepresentation();
9544 clang::QualType QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9545 return QT->hasFloatingRepresentation();
9552 clang::QualType QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9553 return QT->hasPointerRepresentation();
9560 clang::QualType QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9561 return QT->isVoidPointerType();
9568 clang::FunctionDecl *FD = (clang::FunctionDecl *) fdeclid;
9569 return llvm::isa_and_nonnull<clang::CXXMethodDecl>(FD);
9578 Error(
"SnapshotMutexState",
"fRecurseCount != 0 even though initial mutex state is unset!");
9594 Error(
"ForgetMutexState",
"mutex state's recurse count already 0!");
9610 std::unique_ptr<MutexStateAndRecurseCountDelta> uniqueP{typedDelta};
9624 Error(
"ApplyToInterpreterMutex",
9625 "After returning from user code that turned on thread safety support, we notice that fInitialMutex is already used ... "
9626 "so the rest of this function/stack execution might have race condition (with the other thread that thinks it has exclusive access to the interpreter state.");
9642 return uniqueP.release();
The file contains utilities which are foundational and could be used across the core component of ROO...
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
unsigned long long ULong64_t
TClass *(* DictFuncPtr_t)()
R__EXTERN TApplication * gApplication
R__EXTERN TClassTable * gClassTable
static bool IsFromRootCling()
static void indent(ostringstream &buf, int indent_level)
The file contains facilities to work with C++ module files extensions used to store rdict files.
void TCling__RestoreInterpreterMutex(void *delta)
Re-apply the lock count delta that TCling__ResetInterpreterMutex() caused.
void TCling__TransactionRollback(const cling::Transaction &T)
static void RegisterPreIncludedHeaders(cling::Interpreter &clingInterp)
static bool hasParsedRootmapForLibrary(llvm::StringRef lib)
void TCling__InvalidateGlobal(const clang::Decl *D)
bool TClingLookupHelper__AutoParse(const char *cname)
Allow calling autoparsing from TMetaUtils.
void * TCling__LockCompilationDuringUserCodeExecution()
Lock the interpreter.
void TCling__UpdateListsOnUnloaded(const cling::Transaction &T)
void TCling__GetNormalizedContext(const ROOT::TMetaUtils::TNormalizedCtxt *&normCtxt)
int TCling__LoadLibrary(const char *library)
Load a library.
void TCling__DEBUG__dump(clang::DeclContext *DC)
ETupleOrdering
Check in what order the member of a tuple are layout.
bool TCling__LibraryLoadingFailed(const std::string &errmessage, const std::string &libStem, bool permanent, bool resolved)
Lookup libraries in LD_LIBRARY_PATH and DYLD_LIBRARY_PATH with mangled_name, which is extracted by er...
static const std::unordered_set< std::string > gIgnoredPCMNames
List of dicts that have the PCM information already in the PCH.
static Bool_t s_IsLibraryLoaded(const char *libname, cling::Interpreter *fInterpreter)
static std::string AlternateTuple(const char *classname, const cling::LookupHelper &lh)
const char * TCling__GetClassSharedLibs(const char *className, bool skipCore)
static GlobalModuleIndex * loadGlobalModuleIndex(cling::Interpreter &interp)
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.
static bool HasASTFileOnDisk(clang::Module *M, const clang::Preprocessor &PP, std::string *FullFileName=nullptr)
Checks if there is an ASTFile on disk for the given module M.
void TCling__UnlockCompilationDuringUserCodeExecution(void *)
Unlock the interpreter.
static bool R__InitStreamerInfoFactory()
Helper to initialize TVirtualStreamerInfo's factor early.
int TCling__AutoParseCallback(const char *className)
clang::RecordDecl * TCling__DEBUG__DCtoRecordDecl(clang::DeclContext *DC)
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)
static bool HaveFullGlobalModuleIndex
bool TCling__TEST_isInvalidDecl(clang::Decl *D)
void TCling__LibraryUnloadedRTTI(const void *dyLibHandle, const char *canonicalName)
void TCling__UpdateListsOnCommitted(const cling::Transaction &T, cling::Interpreter *)
const Decl * TCling__GetObjectDecl(TObject *obj)
static ETupleOrdering IsTupleAscending()
void TCling__RegisterRdictForLoadPCM(const std::string &pcmFileNameFullPath, llvm::StringRef *pcmContent)
static void TCling__UpdateClassInfo(const NamedDecl *TD)
Update TClingClassInfo for a class (e.g. upon seeing a definition).
clang::DeclContext * TCling__DEBUG__getDeclContext(clang::Decl *D)
int TCling__CompileMacro(const char *fileName, const char *options)
void * TCling__ResetInterpreterMutex()
Reset the interpreter lock to the state it had before interpreter-related calls happened.
void TCling__DEBUG__decl_dump(void *D)
int TCling__AutoLoadCallback(const char *className)
static bool LoadModule(const std::string &ModuleName, cling::Interpreter &interp)
static void RegisterCxxModules(cling::Interpreter &clingInterp)
static void ConstructorName(std::string &name, const clang::Decl *decl, cling::Interpreter &interp, const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt)
void TCling__PrintStackTrace()
Print a StackTrace!
static int HandleInterpreterException(cling::MetaProcessor *metaProcessor, const char *input_line, cling::Interpreter::CompilationResult &compRes, cling::Value *result)
Let cling process a command line.
static std::string GetSharedLibImmediateDepsSlow(std::string lib, cling::Interpreter *interp, bool skipLoadedLibs=true)
This interface returns a list of dependent libraries in the form: lib libA.so libB....
void TCling__DEBUG__printName(clang::Decl *D)
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...
static void PrintDlError(const char *dyLibName, const char *modulename)
TInterpreter * CreateInterpreter(void *interpLibHandle, const char *argv[])
static std::string GetClassSharedLibsForModule(const char *cls, cling::LookupHelper &LH, bool skipCore)
void TCling__LibraryLoadedRTTI(const void *dyLibHandle, const char *canonicalName)
static cling::Interpreter::CompilationResult ExecAutoParse(const char *what, Bool_t header, cling::Interpreter *interpreter)
Parse the payload or header.
static bool requiresRootMap(const char *rootmapfile)
clang::NamespaceDecl * TCling__DEBUG__DCtoNamespace(clang::DeclContext *DC)
TObject * TCling__GetObjectAddress(const char *Name, void *&LookupCtx)
static void LoadModules(const std::vector< std::string > &modules, cling::Interpreter &interp)
Loads the C++ modules that we require to run any ROOT program.
int TCling__IsAutoLoadNamespaceCandidate(const clang::NamespaceDecl *nsDecl)
void DestroyInterpreter(TInterpreter *interp)
static bool hasPrecomputedLibraryDeps(llvm::StringRef lib)
void TCling__SplitAclicMode(const char *fileName, string &mode, string &args, string &io, string &fname)
void Info(const char *location, const char *msgfmt,...)
Use this function for informational messages.
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Int_t gErrorIgnoreLevel
Error handling routines.
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
void Fatal(const char *location, const char *msgfmt,...)
Use this function in case of a fatal error. It will abort the program.
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void input
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t cursor
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char filename
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h offset
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h length
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char cname
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t UChar_t len
Option_t Option_t TPoint TPoint const char mode
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t property
Option_t Option_t TPoint TPoint const char text
R__EXTERN TVirtualMutex * gInterpreterMutex
#define R__LOCKGUARD_CLING(mutex)
R__EXTERN TInterpreter * gCling
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Bool_t R_ISREG(Int_t mode)
R__EXTERN TSystem * gSystem
R__EXTERN TVirtualMutex * gGlobalMutex
#define R__LOCKGUARD(mutex)
#define R__WRITE_LOCKGUARD(mutex)
#define R__READ_LOCKGUARD(mutex)
virtual std::unique_ptr< StateDelta > Rewind(const State &earlierState)=0
virtual void Apply(std::unique_ptr< StateDelta > &&delta)=0
virtual std::unique_ptr< State > GetStateBefore()=0
static Longptr_t ExecuteFile(const char *file, Int_t *error=nullptr, Bool_t keep=kFALSE)
Execute a file containing a C++ macro (static method).
virtual TApplicationImp * GetApplicationImp()
virtual Bool_t IsCmdThread()
Each class (see TClass) has a linked list of its base class(es).
TClassRef is used to implement a permanent reference to a TClass object.
static DictFuncPtr_t GetDict(const char *cname)
Given the class name returns the Dictionary() function of a class (uses hash of name).
static TProtoClass * GetProtoNorm(const char *cname)
Given the class normalized name returns the TClassProto object for the class.
static DictFuncPtr_t GetDictNorm(const char *cname)
Given the normalized class name returns the Dictionary() function of a class (uses hash of name).
static TProtoClass * GetProto(const char *cname)
Given the class name returns the TClassProto object for the class.
static Bool_t Check(const char *cname, std::string &normname)
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).
TClass instances represent classes, structs and namespaces in the ROOT type system.
TDataMember * GetDataMember(const char *datamember) const
Return pointer to datamember object with name "datamember".
ROOT::ESTLType GetCollectionType() const
Return the 'type' of the STL the TClass is representing.
EState fState
cached of the streaming method to use
std::atomic< TList * > fBase
static void AddClassToDeclIdMap(TDictionary::DeclId_t id, TClass *cl)
static: Add a TClass* to the map of classes.
TList * GetListOfFunctionTemplates(Bool_t load=kTRUE)
Return TListOfFunctionTemplates for a class.
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.
static void RemoveClassDeclId(TDictionary::DeclId_t id)
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::atomic< TListOfEnums * > fEnums
static Bool_t HasNoInfoOrEmuOrFwdDeclaredDecl(const char *)
virtual void PostLoadCheck()
Do the initialization that can only be done after the CINT dictionary has been fully populated and ca...
static TClass * LoadClass(const char *requestedname, Bool_t silent)
Helper function used by TClass::GetClass().
Int_t Size() const
Return size of object of this class.
TObjArray * fStreamerInfo
Bool_t IsLoaded() const
Return true if the shared library of this class is currently in the a process's memory.
ClassInfo_t * GetClassInfo() const
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
void ResetCaches()
To clean out all caches.
Long_t Property() const override
Returns the properties of the TClass as a bit field stored as a Long_t value.
static Int_t ReadRules()
Read the class.rules files from the default location:.
Version_t GetClassVersion() const
std::atomic< Bool_t > fHasRootPcmInfo
C++ Property of the class (is abstract, has virtual table, etc.)
const char * GetDeclFileName() const
Return name of the file containing the declaration of this class.
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.
Emulation of the CINT BaseClassInfo class.
const char * TmpltName() const
const char * Name() const
ptrdiff_t Offset(void *address=0, bool isDerivedObject=true) const
void FullName(std::string &output, const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
TClingClassInfo * GetBase() const
Emulation of the CINT CallFunc class.
void ExecWithReturn(void *address, void *ret=nullptr)
void SetArgs(const char *args)
double ExecDouble(void *address)
void SetArgArray(Longptr_t *argArr, int narg)
Longptr_t ExecInt(void *address)
TInterpreter::CallFuncIFacePtr_t IFacePtr()
void SetFunc(const TClingClassInfo *info, const char *method, const char *arglist, Longptr_t *poffset)
void ExecWithArgsAndReturn(void *address, const void *args[]=0, int nargs=0, void *ret=0)
void Exec(void *address, TInterpreterValue *interpVal=0)
TClingMethodInfo * FactoryMethod() const
int get_wrapper_code(std::string &wrapper_name, std::string &wrapper)
void IgnoreExtraArgs(bool ignore)
long long ExecInt64(void *address)
bool IsAutoLoadingEnabled() const
void SetAutoParsingSuspended(bool val=true)
void SetAutoLoadingEnabled(bool val=true)
Emulation of the CINT ClassInfo class.
static bool IsEnum(cling::Interpreter *interp, const char *name)
long ClassProperty() const
void Init(const char *name)
void FullName(std::string &output, const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
EDataType GetUnderlyingType() const
const char * TmpltName() const
const clang::Type * GetType() const
ptrdiff_t GetBaseOffset(TClingClassInfo *toBase, void *address, bool isDerivedObject)
bool IsScopedEnum() const
ROOT::TMetaUtils::EIOCtorCategory HasDefaultConstructor(bool checkio=false, std::string *type_name=nullptr) const
TClingMethodInfo GetMethodWithArgs(const char *fname, const char *arglist, Longptr_t *poffset, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch, EInheritanceMode imode=kWithInheritance) const
const clang::FunctionTemplateDecl * GetFunctionTemplate(const char *fname) const
int GetMethodNArg(const char *method, const char *proto, Bool_t objectIsConst, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch) const
bool IsValidMethod(const char *method, const char *proto, Bool_t objectIsConst, Longptr_t *offset, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch) const
bool HasMethod(const char *name) const
TDictionary::DeclId_t GetDeclId() const
void DeleteArray(void *arena, bool dtorOnly, const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
void * New(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
TClingMethodInfo GetMethod(const char *fname) const
const clang::ValueDecl * GetDataMember(const char *name) const
void Destruct(void *arena, const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
std::vector< std::string > GetUsingNamespaces()
bool IsBase(const char *name) const
void Delete(void *arena, const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
Emulation of the CINT DataMemberInfo class.
const char * TypeName() const
const char * TypeTrueName(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
int MaxIndex(int dim) const
llvm::StringRef ValidArrayIndex() const
const char * Name() const override
long TypeProperty() const
virtual const char * Name() const
virtual bool IsValid() const
virtual const clang::Decl * GetDecl() const
Uses clang::TextDiagnosticPrinter to format diagnostics, which are then passed to a user-specified fu...
Emulation of the CINT MethodInfo class.
bool IsValid() const override
const char * DefaultValue() const
const TClingTypeInfo * Type() const
const char * TypeName() const
Emulation of the CINT MethodInfo class.
std::string GetMangledName() const
const char * TypeName() const
const char * Name() const override
const clang::FunctionDecl * GetTargetFunctionDecl() const
Get the FunctionDecl, or if this represents a UsingShadowDecl, the underlying target FunctionDecl.
const char * GetPrototype()
long ExtraProperty() const
void * InterfaceMethod() const
void CreateSignature(TString &signature) const
TDictionary::DeclId_t GetDeclId() const
TClingTypeInfo * Type() const
Emulation of the CINT TypeInfo class.
std::string NormalizedName(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
Return the normalized name of the type (i.e.
const char * Name() const override
void * QualTypePtr() const
Return the QualType as a void pointer.
bool IsValid() const override
clang::QualType GetQualType() const
void Init(const char *name)
const char * TrueName(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
Return the normalized name of the type (i.e.
Emulation of the CINT TypedefInfo class.
const char * TrueName(const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) const
Get the name of the underlying type of the current typedef.
long Property() const
Return a bit mask of metadata about the current typedef.
const char * Name() const override
Get the name of the current typedef.
void Init(const char *name)
Lookup named typedef and reset the iterator to point to it.
int Next()
Increment the iterator.
int Size() const
Return the size in bytes of the underlying type of the current typedef.
Bridge between cling::Value and ROOT.
bool Append(const std::string &str)
Append string to the storage if not added already.
This class defines an interface to the cling C++ interpreter.
static Int_t DeepAutoLoadImpl(const char *cls, std::unordered_set< std::string > &visited, bool nameIsNormalized)
const char * MethodArgInfo_DefaultValue(MethodArgInfo_t *marginfo) const final
bool ClassInfo_IsScopedEnum(ClassInfo_t *info) const final
const char * TypeInfo_Name(TypeInfo_t *) const final
void * MethodInfo_InterfaceMethod(MethodInfo_t *minfo) const final
void LoadEnums(TListOfEnums &cl) const final
Create list of pointers to enums for TClass cl.
void UpdateListOfGlobals() final
No op: see TClingCallbacks (used to update the list of globals)
bool TypedefInfo_IsValid(TypedefInfo_t *tinfo) const final
Int_t AutoLoad(const char *classname, Bool_t knowDictNotLoaded=kFALSE) final
Load library containing the specified class.
void CallFunc_Init(CallFunc_t *func) const final
void SetGetline(const char *(*getlineFunc)(const char *prompt), void(*histaddFunc)(const char *line)) final
Set a getline function to call when input is needed.
bool LibraryLoadingFailed(const std::string &, const std::string &, bool, bool)
void GenericError(const char *error) const final
Let the interpreter issue a generic error, and set its error state.
std::vector< void * > fRegisterModuleDyLibs
void CallFunc_ExecWithReturn(CallFunc_t *func, void *address, void *ret) const final
TypeInfo_t * MethodInfo_Type(MethodInfo_t *minfo) const final
std::vector< std::string > fAutoLoadLibStorage
void CallFunc_Delete(CallFunc_t *func) const final
int LoadFile(const char *path) const final
Load a source file or library called path into the interpreter.
void ResetAll() final
Reset the Cling state to its initial state.
void SetDeclAttr(DeclId_t, const char *) final
void HandleNewDecl(const void *DV, bool isDeserialized, std::set< TClass * > &modifiedClasses)
void InvalidateCachedDecl(const std::tuple< TListOfDataMembers *, TListOfFunctions *, TListOfFunctionTemplates *, TListOfEnums * > &Lists, const clang::Decl *D)
Invalidate cached TCling information for the given declaration, and removed it from the appropriate o...
Long_t MethodInfo_Property(MethodInfo_t *minfo) const final
virtual void LoadFunctionTemplates(TClass *cl) const final
Create list of pointers to function templates for TClass cl.
bool ClassInfo_IsValidMethod(ClassInfo_t *info, const char *method, const char *proto, Longptr_t *offset, ROOT::EFunctionMatchMode=ROOT::kConversionMatch) const final
Long_t DataMemberInfo_Property(DataMemberInfo_t *dminfo) const final
int SetClassAutoparsing(int) final
Enable/Disable the Autoparsing of headers.
std::vector< const char * > fCurExecutingMacros
void CreateListOfDataMembers(TClass *cl) const final
Create list of pointers to data members for TClass cl.
void RewindDictionary() final
Rewind Cling dictionary to the point where it was before executing the current macro.
bool ClassInfo_IsValid(ClassInfo_t *info) const final
void UpdateListsOnCommitted(const cling::Transaction &T)
int TypeInfo_RefType(TypeInfo_t *) const final
void CreateListOfBaseClasses(TClass *cl) const final
Create list of pointers to base class(es) for TClass cl.
ClassInfo_t * ClassInfo_Factory(Bool_t all=kTRUE) const final
const char * MethodInfo_Name(MethodInfo_t *minfo) const final
BaseClassInfo_t * BaseClassInfo_Factory(ClassInfo_t *info) const final
void SetClassInfo(TClass *cl, Bool_t reload=kFALSE) final
Set pointer to the TClingClassInfo in TClass.
Bool_t LoadText(const char *text) const final
Load the declarations from text into the interpreter.
const char * GetSharedLibDeps(const char *lib, bool tryDyld=false) final
Get the list a libraries on which the specified lib depends.
EReturnType MethodInfo_MethodCallReturnType(MethodInfo_t *minfo) const final
TObject * GetObjectAddress(const char *Name, void *&LookupCtx)
If the interpreter encounters Name, check whether that is an object ROOT could retrieve.
Longptr_t ProcessLineAsynch(const char *line, EErrorCode *error=nullptr)
Let cling process a command line asynch.
bool MethodInfo_IsValid(MethodInfo_t *minfo) const final
FuncTempInfo_t * FuncTempInfo_Factory(DeclId_t declid) const final
Construct a FuncTempInfo_t.
TypeInfo_t * TypeInfo_Factory() const final
bool IsClassAutoLoadingEnabled() const
Returns if class AutoLoading is currently enabled.
void InvalidateGlobal(const clang::Decl *D)
Invalidate cached TCling information for the given global declaration.
int Evaluate(const char *, TInterpreterValue &) final
Get the interpreter value corresponding to the statement.
std::unique_ptr< TInterpreterValue > MakeInterpreterValue() const final
void UpdateListOfLoadedSharedLibraries()
const char * TypedefInfo_Title(TypedefInfo_t *tinfo) const final
void CallFunc_SetFuncProto(CallFunc_t *func, ClassInfo_t *info, const char *method, const char *proto, Longptr_t *Offset, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch) const final
Interface to cling function.
void InitRootmapFile(const char *name)
Create a resource table and read the (possibly) three resource files, i.e.
Int_t AutoParse(const char *cls) final
Parse the headers relative to the class Returns 1 in case of success, 0 in case of failure.
bool FunctionDeclId_IsMethod(DeclId_t fdeclid) const
void LoadPCM(std::string pcmFileNameFullPath)
Tries to load a rdict PCM, issues diagnostics if it fails.
void UpdateListOfMethods(TClass *cl) const final
Update the list of pointers to method for TClass cl This is now a nop.
virtual ~TCling()
Destroy the interpreter interface.
void AddFriendToClass(clang::FunctionDecl *, clang::CXXRecordDecl *) const
Inject function as a friend into klass.
void PrintIntro() final
No-op; see TRint instead.
Bool_t fCxxModulesEnabled
int BaseClassInfo_Next(BaseClassInfo_t *bcinfo) const final
void RefreshClassInfo(TClass *cl, const clang::NamedDecl *def, bool alias)
Internal function. Actually do the update of the ClassInfo when seeing.
CallFunc_t * CallFunc_FactoryCopy(CallFunc_t *func) const final
Double_t CallFunc_ExecDouble(CallFunc_t *func, void *address) const final
void CallFunc_ResetArg(CallFunc_t *func) const final
const char * GetCurrentMacroName() const final
Return the file name of the currently interpreted file, included or not.
Bool_t IsLoaded(const char *filename) const final
Return true if the file has already been loaded by cint.
void SaveGlobalsContext() final
Save the current Cling state of global objects.
void CallFunc_IgnoreExtraArgs(CallFunc_t *func, bool ignore) const final
void ApplyToInterpreterMutex(void *delta)
Re-apply the lock count delta that TCling__ResetInterpreterMutex() caused.
void * LazyFunctionCreatorAutoload(const std::string &mangled_name)
Autoload a library based on a missing symbol.
Int_t GenerateDictionary(const char *classes, const char *includes="", const char *options=nullptr) final
Generate the dictionary for the C++ classes listed in the first argument (in a semi-colon separated l...
Bool_t ClassInfo_Contains(ClassInfo_t *info, DeclId_t declid) const final
Return true if the entity pointed to by 'declid' is declared in the context described by 'info'.
Bool_t IsLibraryLoaded(const char *libname) const final
Long_t GetExecByteCode() const final
This routines used to return the address of the internal wrapper function (of the interpreter) that w...
int DataMemberInfo_ArrayDim(DataMemberInfo_t *dminfo) const final
TypeInfo_t * MethodArgInfo_TypeInfo(MethodArgInfo_t *marginfo) const
DataMemberInfo_t * DataMemberInfo_FactoryCopy(DataMemberInfo_t *dminfo) const final
Bool_t HandleNewTransaction(const cling::Transaction &T)
Helper function to increase the internal Cling count of transactions that change the AST.
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...
std::map< SpecialObjectLookupCtx_t, SpecialObjectMap_t > fSpecialObjectMaps
int ClassInfo_Next(ClassInfo_t *info) const final
void SetErrmsgcallback(void *p) const final
Set a callback to receive error messages.
bool MethodArgInfo_IsValid(MethodArgInfo_t *marginfo) const final
int TypeInfo_Size(TypeInfo_t *tinfo) const final
Int_t DeleteGlobal(void *obj) final
Delete obj from Cling symbol table so it cannot be accessed anymore.
int GetSecurityError() const final
Interface to cling function.
void SetTempLevel(int val) const final
Create / close a scope for temporaries.
std::set< size_t > fPayloads
UInt_t FuncTempInfo_TemplateNargs(FuncTempInfo_t *) const final
Return the maximum number of template arguments of the function template described by ft_info.
DeclId_t GetFunctionWithPrototype(ClassInfo_t *cl, const char *method, const char *proto, Bool_t objectIsConst=kFALSE, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch) final
Return pointer to cling interface function for a method of a class with a certain prototype,...
TypedefInfo_t * TypedefInfo_Factory() const final
TObjArray * fRootmapFiles
bool IsVoidPointerType(const void *QualTypePtr) const
Longptr_t ProcessLine(const char *line, EErrorCode *error=nullptr) final
int ClassInfo_Size(ClassInfo_t *info) const final
const char * MethodArgInfo_TypeName(MethodArgInfo_t *marginfo) const final
cling::Interpreter * GetInterpreterImpl() const
Longptr_t ExecuteMacro(const char *filename, EErrorCode *error=nullptr) final
Execute a cling macro.
std::vector< std::pair< TClass *, DictFuncPtr_t > > fClassesToUpdate
int DataMemberInfo_Next(DataMemberInfo_t *dminfo) const final
const char * TypedefInfo_Name(TypedefInfo_t *tinfo) const final
void BaseClassInfo_Delete(BaseClassInfo_t *bcinfo) const final
Long_t MethodInfo_ExtraProperty(MethodInfo_t *minfo) const final
void LoadMacro(const char *filename, EErrorCode *error=nullptr) final
Load a macro file in cling's memory.
FuncTempInfo_t * FuncTempInfo_FactoryCopy(FuncTempInfo_t *) const final
Construct a FuncTempInfo_t.
int DataMemberInfo_MaxIndex(DataMemberInfo_t *dminfo, Int_t dim) const final
Bool_t FuncTempInfo_IsValid(FuncTempInfo_t *) const final
Check validity of a FuncTempInfo_t.
void AddIncludePath(const char *path) final
Add a directory to the list of directories in which the interpreter looks for include files.
bool ClassInfo_IsBase(ClassInfo_t *info, const char *name) const final
void RecursiveRemove(TObject *obj) final
Delete object from cling symbol table so it can not be used anymore.
const char * DataMemberInfo_TypeName(DataMemberInfo_t *dminfo) const final
DeclId_t GetDataMemberAtAddr(const void *addr) const final
Return pointer to cling DeclId for a data member with a given name.
void CallFunc_SetArgArray(CallFunc_t *func, Longptr_t *paramArr, Int_t nparam) const final
std::string CallFunc_GetWrapperCode(CallFunc_t *func) const final
void * RewindInterpreterMutex()
Reset the interpreter lock to the state it had before interpreter-related calls happened.
const char * MethodArgInfo_Name(MethodArgInfo_t *marginfo) const final
Bool_t HasPCMForLibrary(const char *libname) const final
Return true if ROOT has cxxmodules pcm for a given library name.
void TypedefInfo_Init(TypedefInfo_t *tinfo, const char *name) const final
const char * DataMemberInfo_Title(DataMemberInfo_t *dminfo) const final
Longptr_t CallFunc_ExecInt(CallFunc_t *func, void *address) const final
void ClearStack() final
Delete existing temporary values.
void SetAlloclockfunc(void(*)()) const final
[Place holder for Mutex Lock] Provide the interpreter with a way to acquire a lock used to protect cr...
Bool_t SetErrorMessages(Bool_t enable=kTRUE) final
If error messages are disabled, the interpreter should suppress its failures and warning messages fro...
MethodInfo_t * CallFunc_FactoryMethod(CallFunc_t *func) const final
bool IsUnsignedIntegerType(const void *QualTypePtr) const
TypedefInfo_t * TypedefInfo_FactoryCopy(TypedefInfo_t *tinfo) const final
void GetFunctionOverloads(ClassInfo_t *cl, const char *funcname, std::vector< DeclId_t > &res) const final
Insert overloads of name in cl to res.
void UnRegisterTClassUpdate(const TClass *oldcl) final
If the dictionary is loaded, we can remove the class from the list (otherwise the class might be load...
std::string MethodArgInfo_TypeNormalizedName(MethodArgInfo_t *marginfo) const final
DeclId_t GetEnum(TClass *cl, const char *name) const final
Return pointer to cling Decl of global/static variable that is located at the address given by addr.
Long_t MethodArgInfo_Property(MethodArgInfo_t *marginfo) const final
int TypedefInfo_Size(TypedefInfo_t *tinfo) const final
void CallFunc_ExecWithArgsAndReturn(CallFunc_t *func, void *address, const void *args[]=nullptr, int nargs=0, void *ret=nullptr) const final
void GetInterpreterTypeName(const char *name, std::string &output, Bool_t full=kFALSE) final
The 'name' is known to the interpreter, this function returns the internal version of this name (usua...
std::map< std::string, llvm::StringRef > fPendingRdicts
static void UpdateClassInfoWork(const char *name)
Int_t Load(const char *filenam, Bool_t system=kFALSE) final
Load a library file in cling's memory.
int TypedefInfo_Next(TypedefInfo_t *tinfo) const final
void * GetInterfaceMethod(TClass *cl, const char *method, const char *params, Bool_t objectIsConst=kFALSE) final
Return pointer to cling interface function for a method of a class with parameters params (params is ...
void TypeInfo_Init(TypeInfo_t *tinfo, const char *funcname) const final
Bool_t SetSuspendAutoParsing(Bool_t value) final
Suspend the Autoparsing of headers.
int DataMemberInfo_TypeSize(DataMemberInfo_t *dminfo) const final
static void * fgSetOfSpecials
const char * ClassInfo_Title(ClassInfo_t *info) const final
const char * DataMemberInfo_Name(DataMemberInfo_t *dminfo) const final
const char * TypeName(const char *typeDesc) final
Return the absolute type of typeDesc.
ROOT::TMetaUtils::TNormalizedCtxt * fNormalizedCtxt
bool IsSignedIntegerType(const void *QualTypePtr) const
void ForgetMutexState() final
int MethodInfo_Next(MethodInfo_t *minfo) const final
Long_t ClassInfo_ClassProperty(ClassInfo_t *info) const final
void MethodInfo_Delete(MethodInfo_t *minfo) const final
Interface to cling function.
void MethodArgInfo_Delete(MethodArgInfo_t *marginfo) const final
DataMemberInfo_t * DataMemberInfo_Factory(ClassInfo_t *clinfo, TDictionary::EMemberSelection selection) const final
void ClassInfo_Destruct(ClassInfo_t *info, void *arena) const final
TClass * GetClass(const std::type_info &typeinfo, Bool_t load) const final
Demangle the name (from the typeinfo) and then request the class via the usual name based interface (...
Int_t UnloadAllSharedLibraryMaps() final
Unload the library map entries coming from all the loaded shared libraries.
void ClassInfo_Init(ClassInfo_t *info, const char *funcname) const final
std::set< TClass * > & GetModTClasses()
ClassInfo_t * BaseClassInfo_ClassInfo(BaseClassInfo_t *) const final
TClingCallbacks * fClingCallbacks
Long64_t CallFunc_ExecInt64(CallFunc_t *func, void *address) const final
Long_t ClassInfo_Property(ClassInfo_t *info) const final
Longptr_t ClassInfo_GetBaseOffset(ClassInfo_t *fromDerived, ClassInfo_t *toBase, void *address, bool isDerivedObject) const final
void UpdateEnumConstants(TEnum *enumObj, TClass *cl) const final
void ExecuteWithArgsAndReturn(TMethod *method, void *address, const void *args[]=nullptr, int nargs=0, void *ret=nullptr) const final
Bool_t IsErrorMessagesEnabled() const final
If error messages are disabled, the interpreter should suppress its failures and warning messages fro...
int DisplayIncludePath(FILE *fout) const final
Interface to cling function.
void TransactionRollback(const cling::Transaction &T)
Long_t FuncTempInfo_Property(FuncTempInfo_t *) const final
Return the property of the function template.
TEnum * CreateEnum(void *VD, TClass *cl) const final
const char * TypeInfo_TrueName(TypeInfo_t *tinfo) const final
Int_t UnloadLibraryMap(const char *library) final
Unload library map entries coming from the specified library.
void RegisterTemporary(const TInterpreterValue &value)
MutexStateAndRecurseCount fInitialMutex
const char * GetSharedLibs() final
Return the list of shared libraries loaded into the process.
int MethodArgInfo_Next(MethodArgInfo_t *marginfo) const final
void SnapshotMutexState(ROOT::TVirtualRWMutex *mtx) final
Long_t TypeInfo_Property(TypeInfo_t *tinfo) const final
const char * MethodInfo_GetPrototype(MethodInfo_t *minfo) const final
UInt_t FuncTempInfo_TemplateMinReqArgs(FuncTempInfo_t *) const final
Return the number of required template arguments of the function template described by ft_info.
std::vector< cling::Value > * fTemporaries
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, Bool_t lateRegistration=false, Bool_t hasCxxModule=false) final
Inject the module named "modulename" into cling; load all headers.
static Int_t ShallowAutoLoadImpl(const char *cls)
void MethodInfo_CreateSignature(MethodInfo_t *minfo, TString &signature) const final
Bool_t CheckClassTemplate(const char *name) final
Return true if there is a class template by the given name ...
void LibraryLoaded(const void *dyLibHandle, const char *canonicalName)
void RegisterTClassUpdate(TClass *oldcl, DictFuncPtr_t dict) final
Register classes that already existed prior to their dictionary loading and that already had a ClassI...
TObjArray * GetRootMapFiles() const final
bool DataMemberInfo_IsValid(DataMemberInfo_t *dminfo) const final
bool ClassInfo_IsEnum(const char *name) const final
int MethodInfo_NDefaultArg(MethodInfo_t *minfo) const final
void CreateListOfMethods(TClass *cl) const final
Create list of pointers to methods for TClass cl.
Int_t RescanLibraryMap() final
Scan again along the dynamic path for library maps.
std::map< const cling::Transaction *, size_t > fTransactionHeadersMap
void ReportDiagnosticsToErrorHandler(bool enable=true) final
Report diagnostics to the ROOT error handler (see TError.h).
const char * MethodInfo_GetMangledName(MethodInfo_t *minfo) const final
Bool_t fHeaderParsingOnDemand
bool IsIntegerType(const void *QualTypePtr) const
std::hash< std::string > fStringHashFunction
static void RemoveAndInvalidateObject(List &L, Object *O)
void * GetInterfaceMethodWithPrototype(TClass *cl, const char *method, const char *proto, Bool_t objectIsConst=kFALSE, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch) final
Return pointer to cling interface function for a method of a class with a certain prototype,...
void * ClassInfo_New(ClassInfo_t *info) const final
int DisplayClass(FILE *fout, const char *name, int base, int start) const final
virtual void GetFunctionName(const clang::Decl *decl, std::string &name) const
void CreateListOfMethodArgs(TFunction *m) const final
Create list of pointers to method arguments for TMethod m.
virtual const char * GetSTLIncludePath() const final
Return the directory containing CINT's stl cintdlls.
MethodArgInfo_t * MethodArgInfo_FactoryCopy(MethodArgInfo_t *marginfo) const final
Longptr_t BaseClassInfo_Offset(BaseClassInfo_t *toBaseClassInfo, void *address, bool isDerivedObject) const final
ECheckClassInfo CheckClassInfo(const char *name, Bool_t autoload, Bool_t isClassOrNamespaceOnly=kFALSE) final
Checks if an entity with the specified name is defined in Cling.
void * FindSym(const char *entry) const final
Interface to cling function.
void RegisterLoadedSharedLibrary(const char *name)
Register a new shared library name with the interpreter; add it to fSharedLibs.
void TypeInfo_Delete(TypeInfo_t *tinfo) const final
int MethodInfo_NArg(MethodInfo_t *minfo) const final
DeclId_t GetDataMemberWithValue(const void *ptrvalue) const final
NOT IMPLEMENTED.
std::unordered_set< const clang::NamespaceDecl * > fNSFromRootmaps
EReturnType MethodCallReturnType(TFunction *func) const final
void ProcessClassesToUpdate()
DeclId_t GetFunctionWithValues(ClassInfo_t *cl, const char *method, const char *params, Bool_t objectIsConst=kFALSE) final
Return pointer to cling DeclId for a method of a class with a certain prototype, i....
TString GetMangledName(TClass *cl, const char *method, const char *params, Bool_t objectIsConst=kFALSE) final
Return the cling mangled name for a method of a class with parameters params (params is a string of a...
const char * MethodInfo_Title(MethodInfo_t *minfo) const final
const char * BaseClassInfo_TmpltName(BaseClassInfo_t *bcinfo) const final
Bool_t Declare(const char *code) final
Declare code to the interpreter, without any of the interpreter actions that could trigger a re-inter...
const char * BaseClassInfo_FullName(BaseClassInfo_t *bcinfo) const final
void CallFunc_SetArgs(CallFunc_t *func, const char *param) const final
int UnloadFile(const char *path) const final
void CallFunc_Exec(CallFunc_t *func, void *address) const final
bool IsPointerType(const void *QualTypePtr) const
bool IsFloatingType(const void *QualTypePtr) const
Long_t FuncTempInfo_ExtraProperty(FuncTempInfo_t *) const final
Return the property not already defined in Property See TDictionary's EFunctionProperty.
bool CallFunc_IsValid(CallFunc_t *func) const final
const char * BaseClassInfo_Name(BaseClassInfo_t *bcinfo) const final
ROOT::TMetaUtils::TClingLookupHelper * fLookupHelper
const char * DataMemberInfo_ValidArrayIndex(DataMemberInfo_t *dminfo) const final
Int_t GetMore() const final
Return whether we are waiting for more input either because the collected input contains unbalanced b...
Bool_t fIsAutoParsingSuspended
std::string ToString(const char *type, void *obj) final
DeclId_t GetDeclId(const llvm::GlobalValue *gv) const
Return pointer to cling DeclId for a global value.
void Execute(const char *function, const char *params, int *error=nullptr) final
Execute a global function with arguments params.
bool ClassInfo_IsLoaded(ClassInfo_t *info) const final
Longptr_t ClassInfo_Tagnum(ClassInfo_t *info) const final
Long_t BaseClassInfo_Property(BaseClassInfo_t *bcinfo) const final
void CallFunc_SetFunc(CallFunc_t *func, ClassInfo_t *info, const char *method, const char *params, Longptr_t *Offset) const final
std::vector< std::string > GetUsingNamespaces(ClassInfo_t *cl) const final
Get the scopes representing using declarations of namespace.
const char * ClassInfo_FileName(ClassInfo_t *info) const final
void FuncTempInfo_Title(FuncTempInfo_t *, TString &name) const final
Return the comments associates with this function template.
const char * ClassInfo_TmpltName(ClassInfo_t *info) const final
void SaveContext() final
Save the current Cling state.
void LoadPCMImpl(TFile &pcmFile)
Tries to load a PCM from TFile; returns true on success.
Bool_t IsAutoLoadNamespaceCandidate(const clang::NamespaceDecl *nsDecl)
void ResetGlobals() final
Reset in Cling the list of global variables to the state saved by the last call to TCling::SaveGlobal...
void CodeComplete(const std::string &, size_t &, std::vector< std::string > &) final
The call to Cling's tab complition.
void ResetGlobalVar(void *obj) final
Reset the Cling 'user' global objects/variables state to the state saved by the last call to TCling::...
const char * MapCppName(const char *) const final
Interface to cling function.
Longptr_t Calc(const char *line, EErrorCode *error=nullptr) final
Directly execute an executable statement (e.g.
Int_t ReloadAllSharedLibraryMaps() final
Reload the library map entries coming from all the loaded shared libraries, after first unloading the...
void UpdateListOfGlobalFunctions() final
No op: see TClingCallbacks (used to update the list of global functions)
void DataMemberInfo_Delete(DataMemberInfo_t *dminfo) const final
const char * GetTopLevelMacroName() const final
Return the file name of the current un-included interpreted file.
void * fPrevLoadedDynLibInfo
void UpdateListOfDataMembers(TClass *cl) const
Update the list of pointers to data members for TClass cl This is now a nop.
void InspectMembers(TMemberInspector &, const void *obj, const TClass *cl, Bool_t isTransient) final
Visit all members over members, recursing over base classes.
Int_t SetClassSharedLibs(const char *cls, const char *libs) final
Register the AutoLoading information for a class.
MethodInfo_t * MethodInfo_FactoryCopy(MethodInfo_t *minfo) const final
std::set< const char * > fParsedPayloadsAddresses
CallFuncIFacePtr_t CallFunc_IFacePtr(CallFunc_t *func) const final
MethodArgInfo_t * MethodArgInfo_Factory() const final
static void UpdateClassInfo(char *name, Long_t tagnum)
No op: see TClingCallbacks.
DeclId_t GetFunction(ClassInfo_t *cl, const char *funcname) final
Return pointer to cling interface function for a method of a class with a certain name.
void ClassInfo_Delete(ClassInfo_t *info) const final
std::unique_ptr< cling::Interpreter > fInterpreter
EDataType ClassInfo_GetUnderlyingType(ClassInfo_t *info) const final
void FuncTempInfo_Delete(FuncTempInfo_t *) const final
Delete the FuncTempInfo_t.
DeclId_t GetFunctionTemplate(ClassInfo_t *cl, const char *funcname) final
Return pointer to cling interface function for a method of a class with a certain name.
Int_t DeleteVariable(const char *name) final
Undeclare obj called name.
const char * GetClassSharedLibs(const char *cls, bool skipCore=true) final
Get the list of shared libraries containing the code for class cls.
Longptr_t DataMemberInfo_Offset(DataMemberInfo_t *dminfo) const final
CallFunc_t * CallFunc_Factory() const final
MethodInfo_t * MethodInfo_Factory() const final
Long_t DataMemberInfo_TypeProperty(DataMemberInfo_t *dminfo) const final
void ClearFileBusy() final
Reset the interpreter internal state in case a previous action was not correctly terminated.
cling::MetaProcessor * GetMetaProcessorImpl() const
bool DiagnoseIfInterpreterException(const std::exception &e) const final
void SetAllocunlockfunc(void(*)()) const final
[Place holder for Mutex Unlock] Provide the interpreter with a way to release a lock used to protect ...
std::set< size_t > fLookedUpClasses
virtual void AddAvailableIndentifiers(TSeqCollection &Idents) final
void TypedefInfo_Delete(TypedefInfo_t *tinfo) const final
void Reset() final
Pressing Ctrl+C should forward here.
const char * TypedefInfo_TrueName(TypedefInfo_t *tinfo) const final
int SetClassAutoLoading(int) const final
Enable/Disable the AutoLoading of libraries.
const char * ClassInfo_FullName(ClassInfo_t *info) const final
UInt_t AutoParseImplRecurse(const char *cls, bool topLevel)
Helper routine for TCling::AutoParse implementing the actual call to the parser and looping over temp...
const char * MethodInfo_TypeName(MethodInfo_t *minfo) const final
void CallFunc_SetArg(CallFunc_t *func, Long_t param) const final
const char * GetIncludePath() final
Refresh the list of include paths known to the interpreter and return it with -I prepended.
void UpdateListsOnUnloaded(const cling::Transaction &T)
Invalidate stored TCling state for declarations included in transaction ‘T’.
void UpdateClassInfoWithDecl(const clang::NamedDecl *ND)
Internal function. Inform a TClass about its new TagDecl or NamespaceDecl.
bool IsSameType(const void *QualTypePtr1, const void *QualTypePtr2) const
virtual void Initialize() final
Initialize the interpreter, once TROOT::fInterpreter is set.
int ClassInfo_GetMethodNArg(ClassInfo_t *info, const char *method, const char *proto, Bool_t objectIsConst=false, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch) const final
DeclId_t GetDataMember(ClassInfo_t *cl, const char *name) const final
Return pointer to cling Decl of global/static variable that is located at the address given by addr.
void FuncTempInfo_Name(FuncTempInfo_t *, TString &name) const final
Return the name of this function template.
std::unique_ptr< cling::MetaProcessor > fMetaProcessor
bool TypeInfo_IsValid(TypeInfo_t *tinfo) const final
bool RegisterPrebuiltModulePath(const std::string &FullPath, const std::string &ModuleMapName="module.modulemap") const final
std::string MethodInfo_TypeNormalizedName(MethodInfo_t *minfo) const final
const char * ClassInfo_Name(ClassInfo_t *info) const final
TClass * GenerateTClass(const char *classname, Bool_t emulation, Bool_t silent=kFALSE) final
Generate a TClass for the given class.
ULong64_t fTransactionCount
bool ClassInfo_HasDefaultConstructor(ClassInfo_t *info, Bool_t testio=kFALSE) const final
void EndOfLineAction() final
It calls a "fantom" method to synchronize user keyboard input and ROOT prompt line.
TypeInfo_t * TypeInfo_FactoryCopy(TypeInfo_t *) const final
void * TypeInfo_QualTypePtr(TypeInfo_t *tinfo) const
bool ClassInfo_HasMethod(ClassInfo_t *info, const char *name) const final
void ClassInfo_DeleteArray(ClassInfo_t *info, void *arena, bool dtorOnly) const final
std::map< size_t, std::vector< const char * > > fClassesHeadersMap
const char * DataMemberInfo_TypeTrueName(DataMemberInfo_t *dminfo) const final
virtual void ShutDown() final
void UpdateListOfTypes() final
No op: see TClingCallbacks (used to update the list of types)
Long_t TypedefInfo_Property(TypedefInfo_t *tinfo) const final
void RegisterRdictForLoadPCM(const std::string &pcmFileNameFullPath, llvm::StringRef *pcmContent)
Register Rdict data for future loading by LoadPCM;.
Longptr_t ProcessLineSynch(const char *line, EErrorCode *error=nullptr) final
Let cling process a command line synchronously, i.e we are waiting it will be finished.
TString GetMangledNameWithPrototype(TClass *cl, const char *method, const char *proto, Bool_t objectIsConst=kFALSE, ROOT::EFunctionMatchMode mode=ROOT::kConversionMatch) final
Return the cling mangled name for a method of a class with a certain prototype, i....
static void UpdateAllCanvases()
Update all canvases at end the terminal input command.
Int_t LoadLibraryMap(const char *rootmapfile=nullptr) final
Load map between class and library.
Longptr_t BaseClassInfo_Tagnum(BaseClassInfo_t *bcinfo) const final
void LibraryUnloaded(const void *dyLibHandle, const char *canonicalName)
Collection abstract base class.
virtual Int_t GetEntries() const
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
virtual void Add(TObject *obj)=0
TObject * FindObject(const char *name) const override
Find an object in this collection using its name.
Bool_t Contains(const char *name) const
All ROOT classes may have RTTI (run time type identification) support added.
Bool_t IsPersistent() const
Basic data type descriptor (datatype information is obtained from CINT).
EMemberSelection
Kinds of members to include in lists.
TList * GetListOfKeys() const override
TDirectory::TContext keeps track and restore the current directory.
void GetObject(const char *namecycle, T *&ptr)
Get an object with proper type checking.
The TEnumConstant class implements the constants of the enum type.
The TEnum class implements the enum type.
const TSeqCollection * GetConstants() const
static TEnum * GetEnum(const std::type_info &ti, ESearchAction sa=kALoadAndInterpLookup)
DeclId_t GetDeclId() const
const char * GetValue() const
The TEnv class reads config files, by default named .rootrc.
THashList * GetTable() const
Bool_t IgnoreDuplicates(Bool_t ignore)
If set to true, no warnings in case of duplicates are issued.
virtual void SetRcName(const char *name)
virtual Int_t ReadFile(const char *fname, EEnvLevel level)
Read and parse the resource file for a certain level.
virtual void SetValue(const char *name, const char *value, EEnvLevel level=kEnvChange, const char *type=nullptr)
Set the value of a resource or create a new resource.
virtual TEnvRec * Lookup(const char *n) const
Loop over all resource records and return the one with name.
A ROOT file is an on-disk file, usually with extension .root, that stores objects in a file-system-li...
Global functions class (global functions are obtained from CINT).
Global variables class (global variables are obtained from CINT).
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
TObject * Remove(TObject *obj) override
Remove object from the list.
THashTable implements a hash table to store TObject's.
This class defines an abstract interface to a generic command line interpreter.
virtual bool RegisterPrebuiltModulePath(const std::string &FullPath, const std::string &ModuleMapName="module.modulemap") const =0
virtual Bool_t HasPCMForLibrary(const char *libname) const =0
virtual Int_t AutoParse(const char *cls)=0
int(* AutoLoadCallBack_t)(const char *)
virtual Bool_t Declare(const char *code)=0
virtual const char * GetClassSharedLibs(const char *cls, bool skipCore=true)=0
std::vector< std::pair< std::string, int > > FwdDeclArgsToKeepCollection_t
TDictionary::DeclId_t DeclId_t
virtual TObjArray * GetRootMapFiles() const =0
Book space in a file, create I/O buffers, to fill them, (un)compress them.
A collection of TDataMember objects designed for fast access given a DeclId_t and for keep track of T...
TObject * FindObject(const char *name) const override
Specialize FindObject to do search for the a data member just by name or create it if its not already...
TDictionary * Find(DeclId_t id) const
Return (after creating it if necessary) the TDataMember describing the data member corresponding to t...
TClass * GetClass() const
A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum t...
A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum t...
TEnum * Find(DeclId_t id) const
Return the TEnum corresponding to the Decl 'id' or NULL if it does not exist.
TEnum * Get(DeclId_t id, const char *name)
Return (after creating it if necessary) the TEnum describing the enum corresponding to the Decl 'id'.
TClass * GetClass() const
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
TFunctionTemplate * Get(DeclId_t id)
Return (after creating it if necessary) the TMethod or TFunction describing the function correspondin...
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
TFunction * Find(DeclId_t id) const
Return the TMethod or TFunction describing the function corresponding to the Decl 'id'.
void Add(TObject *obj) override
TObject * At(Int_t idx) const override
Returns the object at position idx. Returns 0 if idx is out of range.
A TMemFile is like a normal TFile except that it reads and writes only from memory.
Abstract base class for accessing the data-members of a class.
const char * GetParent() const
virtual void Inspect(TClass *cl, const char *parent, const char *name, const void *addr)
EObjectPointerState GetObjectValidity() const
virtual Bool_t IsTreatingNonAccessibleTypes()
void SetObjectValidity(EObjectPointerState val)
void InspectMember(const T &obj, const char *name, Bool_t isTransient)
Each ROOT method (see TMethod) has a linked list of its arguments.
const char * GetFullTypeName() const
Get full type description of method argument, e.g.: "class TDirectory*".
const char * GetDefault() const
Get default value of method argument.
Each ROOT class (see TClass) has a linked list of methods.
virtual TList * GetListOfMethodArgs()
Returns methodarg list and additionally updates fDataMember in TMethod by calling FindDataMember();.
The TNamed class is the base class for all named ROOT classes.
const char * GetName() const override
Returns name of object.
Int_t GetEntriesFast() const
virtual void Expand(Int_t newSize)
Expand or shrink the array to newSize elements.
void Clear(Option_t *option="") override
Remove all objects from the array.
virtual void Compress()
Remove empty slots from array.
Int_t GetEntries() const override
Return the number of objects in array (i.e.
TObject * At(Int_t idx) const override
TObject * Remove(TObject *obj) override
Remove object from array.
TObject * FindObject(const char *name) const override
Find an object in this collection using its name.
void Add(TObject *obj) override
Collectable string class.
Mother of all ROOT objects.
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
R__ALWAYS_INLINE Bool_t IsOnHeap() const
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
virtual TObject * FindObject(const char *name) const
Must be redefined in derived classes.
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
virtual const char * GetTitle() const
Returns title of object.
virtual TClass * IsA() const
@ kInvalidObject
if object ctor succeeded but object should not be used
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Persistent version of a TClass.
static const TString & GetIncludeDir()
Get the include directory in the installation. Static utility function.
static const char * GetMacroPath()
Get macro search path. Static utility function.
static const std::vector< std::string > & AddExtraInterpreterArgs(const std::vector< std::string > &args)
Provide command line arguments to the interpreter construction.
static const TString & GetEtcDir()
Get the sysconfig directory in the installation. Static utility function.
static const char **& GetExtraInterpreterArgs()
INTERNAL function! Used by rootcling to inject interpreter arguments through a C-interface layer.
static const TString & GetSharedLibDir()
Get the shared libraries directory in the installation. Static utility function.
Sequenceable collection abstract base class.
void Add(TObject *obj) override
Describes a persistent version of a class.
Bool_t EndsWith(const char *pat, ECaseCompare cmp=kExact) const
Return true if string ends with the specified string.
const char * Data() const
TString & ReplaceAll(const TString &s1, const TString &s2)
Ssiz_t Last(char c) const
Find last occurrence of a character c.
TObjArray * Tokenize(const TString &delim) const
This function is used to isolate sequential tokens in a TString.
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
TString & Prepend(const char *cs)
TString & Remove(Ssiz_t pos)
TString & Append(const char *cs)
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Ssiz_t Index(const char *pat, Ssiz_t i=0, ECaseCompare cmp=kExact) const
virtual Bool_t ExpandPathName(TString &path)
Expand a pathname getting rid of special shell characters like ~.
virtual void FreeDirectory(void *dirp)
Free a directory.
virtual void * OpenDirectory(const char *name)
Open a directory. Returns 0 if directory does not exist.
virtual const char * Getenv(const char *env)
Get environment variable.
virtual const char * GetIncludePath()
Get the list of include path.
virtual TString SplitAclicMode(const char *filename, TString &mode, TString &args, TString &io) const
This method split a filename of the form:
virtual char * ConcatFileName(const char *dir, const char *name)
Concatenate a directory and a file name. User must delete returned string.
virtual const char * FindFile(const char *search, TString &file, EAccessMode mode=kFileExists)
Find location of file in a search path.
virtual int Load(const char *module, const char *entry="", Bool_t system=kFALSE)
Load a shared library.
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.
virtual const char * PrependPathName(const char *dir, TString &name)
Concatenate a directory and a file name.
virtual Bool_t AccessPathName(const char *path, EAccessMode mode=kFileExists)
Returns FALSE if one can access a file using the specified access mode.
virtual const char * GetDirEntry(void *dirp)
Get a directory entry. Returns 0 if no more entries.
virtual int GetProcInfo(ProcInfo_t *info) const
Returns cpu and memory used by this process into the ProcInfo_t structure.
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
virtual const char * GetDynamicPath()
Return the dynamic path (used to find shared libraries).
virtual const char * FindDynamicLibrary(TString &lib, Bool_t quiet=kFALSE)
Find a dynamic library using the system search paths.
virtual void Sleep(UInt_t milliSec)
Sleep milliSec milli seconds.
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 * WorkingDirectory()
Return working directory.
virtual char * Which(const char *search, const char *file, EAccessMode mode=kFileExists)
Find location of file in a search path.
virtual void Setenv(const char *name, const char *value)
Set environment variable.
virtual const char * HomeDirectory(const char *userName=nullptr)
Return the user's home directory.
virtual TString GetDirName(const char *pathname)
Return the directory name in pathname.
virtual void StackTrace()
Print a stack trace.
char * DynamicPathName(const char *lib, Bool_t quiet=kFALSE)
Find a dynamic library called lib using the system search paths.
virtual TVirtualMutex * Factory(Bool_t=kFALSE)=0
TVirtualPad is an abstract base class for the Pad and Canvas classes.
static void SetFactory(TVirtualStreamerInfo *factory)
static function: Set the StreamerInfo factory
@ kNeedObjectForVirtualBaseClass
const std::string & GetPathSeparator()
const char & GetEnvPathSeparator()
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
R__EXTERN TVirtualRWMutex * gCoreMutex
bool IsStdPairBase(std::string_view name)
bool IsStdArray(std::string_view name)
bool IsStdClass(const char *type)
return true if the class belongs to the std namespace
bool IsStdPair(std::string_view name)
std::string InsertStd(const char *tname)
std::string GetLong64_Name(const char *original)
Replace 'long long' and 'unsigned long long' by 'Long64_t' and 'ULong64_t'.
char * DemangleTypeIdName(const std::type_info &ti, int &errorCode)
Demangle in a portable way the type id name.
const char * GetUnqualifiedName(const char *name)
Return the start of the unqualified name include in 'original'.
void Init(TClassEdit::TInterpreterLookupHelper *helper)
ROOT::ESTLType IsSTLCont(std::string_view type)
type : type name: vector<list<classA,allocator>,allocator> result: 0 : not stl container code of cont...
char * DemangleName(const char *mangled_name, int &errorCode)
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.
EComplexType GetComplexType(const char *)
RAII used to store Parser, Sema, Preprocessor state for recursive parsing.
std::vector< std::string > fElements
void ShortType(std::string &answer, int mode)
Return the absolute type of typeDesc into the string answ.
std::unique_ptr< ROOT::TVirtualRWMutex::State > fState
State of gCoreMutex when the first interpreter-related function was invoked.
Int_t fRecurseCount
Interpreter-related functions will push the "entry" lock state to *this.
A read-only memory range which we do not control.