62#include "RConfigure.h"
63#include "compiledata.h"
80#include "clang/AST/ASTContext.h"
81#include "clang/AST/Decl.h"
82#include "clang/AST/DeclarationName.h"
83#include "clang/AST/GlobalDecl.h"
84#include "clang/AST/RecordLayout.h"
85#include "clang/AST/DeclVisitor.h"
86#include "clang/AST/RecursiveASTVisitor.h"
87#include "clang/AST/Type.h"
88#include "clang/Basic/SourceLocation.h"
89#include "clang/Basic/Specifiers.h"
90#include "clang/Basic/TargetInfo.h"
91#include "clang/CodeGen/ModuleBuilder.h"
92#include "clang/Frontend/CompilerInstance.h"
93#include "clang/Frontend/FrontendDiagnostic.h"
94#include "clang/Lex/HeaderSearch.h"
95#include "clang/Lex/Preprocessor.h"
96#include "clang/Lex/PreprocessorOptions.h"
97#include "clang/Parse/Parser.h"
98#include "clang/Sema/Lookup.h"
99#include "clang/Sema/Sema.h"
100#include "clang/Serialization/ASTReader.h"
101#include "clang/Serialization/GlobalModuleIndex.h"
103#include "cling/Interpreter/ClangInternalState.h"
104#include "cling/Interpreter/DynamicLibraryManager.h"
105#include "cling/Interpreter/Interpreter.h"
106#include "cling/Interpreter/LookupHelper.h"
107#include "cling/Interpreter/Value.h"
108#include "cling/Interpreter/Transaction.h"
109#include "cling/MetaProcessor/MetaProcessor.h"
110#include "cling/Utils/AST.h"
111#include "cling/Utils/ParserStateRAII.h"
112#include "cling/Utils/SourceNormalization.h"
113#include "cling/Interpreter/Exception.h"
115#include "llvm/IR/GlobalValue.h"
116#include "llvm/IR/Module.h"
118#include "llvm/Support/DynamicLibrary.h"
119#include "llvm/Support/raw_ostream.h"
120#include "llvm/Support/Path.h"
121#include "llvm/Support/Process.h"
122#include "llvm/Object/ELFObjectFile.h"
123#include "llvm/Object/ObjectFile.h"
124#include "llvm/Object/SymbolicFile.h"
125#include "llvm/Support/FileSystem.h"
139#include <unordered_map>
140#include <unordered_set>
147#define R__DLLEXPORT __attribute__ ((visibility ("default")))
155#include <mach-o/dyld.h>
156#include <mach-o/loader.h>
170#if defined(__CYGWIN__)
171#include <sys/cygwin.h>
172#define HMODULE void *
174 __declspec(dllimport)
void * __stdcall GetCurrentProcess();
175 __declspec(dllimport)
bool __stdcall EnumProcessModules(
void *,
void **,
unsigned long,
unsigned long *);
176 __declspec(dllimport)
unsigned long __stdcall GetModuleFileNameExW(
void *,
void *,
wchar_t *,
unsigned long);
183# define STDIN_FILENO 0
186# define STDOUT_FILENO 1
189# define STDERR_FILENO 2
198#undef GetModuleFileName
199#define RTLD_DEFAULT ((void *)::GetModuleHandle(NULL))
200#define dlsym(library, function_name) ::GetProcAddress((HMODULE)library, function_name)
201#define dlopen(library_name, flags) ::LoadLibraryA(library_name)
202#define dlclose(library) ::FreeLibrary((HMODULE)library)
203#define R__DLLEXPORT __declspec(dllexport)
211 class TCling_UnloadMarker {
213 ~TCling_UnloadMarker() {
219 static TCling_UnloadMarker gTClingUnloadMarker;
228 return D->getDeclContext();
231 return llvm::dyn_cast<clang::NamespaceDecl>(DC);
234 return llvm::dyn_cast<clang::RecordDecl>(DC);
237 return DC->dumpDeclContext();
246 return ((clang::Decl*)D)->dump();
249 if (clang::NamedDecl* ND = llvm::dyn_cast<clang::NamedDecl>(D)) {
252 llvm::raw_string_ostream OS(
name);
253 ND->getNameForDiagnostic(OS, D->getASTContext().getPrintingPolicy(),
256 printf(
"%s\n",
name.c_str());
264 return D->isInvalidDecl();
268 assert(info && info->
IsValid());
269 return info->
GetDecl()->isInvalidDecl();
273using namespace clang;
277 static const std::string gInterpreterClassDef = R
"ICF(
279#define ClassDef(name, id) \
280_ClassDefInterp_(name,id,virtual,) \
281static int DeclFileLine() { return __LINE__; }
283#define ClassDefNV(name, id) \
284_ClassDefInterp_(name,id,,) \
285static int DeclFileLine() { return __LINE__; }
286#undef ClassDefOverride
287#define ClassDefOverride(name, id) \
288_ClassDefInterp_(name,id,,override) \
289static int DeclFileLine() { return __LINE__; }
292 static const std::string gNonInterpreterClassDef = R
"ICF(
293#define __ROOTCLING__ 1
295#define ClassDef(name,id) \
296_ClassDefOutline_(name,id,virtual,) \
297static int DeclFileLine() { return __LINE__; }
299#define ClassDefNV(name, id)\
300_ClassDefOutline_(name,id,,)\
301static int DeclFileLine() { return __LINE__; }
302#undef ClassDefOverride
303#define ClassDefOverride(name, id)\
304_ClassDefOutline_(name,id,,override)\
305static int DeclFileLine() { return __LINE__; }
309 static const std::string gClassDefInterpMacro = R
"ICF(
312#define _ClassDefInterp_(name,id,virtual_keyword, overrd) \
315 static TClass *Class() { static TClass* sIsA = 0; if (!sIsA) sIsA = TClass::GetClass(#name); return sIsA; } \
316 static const char *Class_Name() { return #name; } \
317 virtual_keyword Bool_t CheckTObjectHashConsistency() const overrd { return true; } \
318 static Version_t Class_Version() { return id; } \
319 static TClass *Dictionary() { return 0; } \
320 virtual_keyword TClass *IsA() const overrd { return name::Class(); } \
321 virtual_keyword void ShowMembers(TMemberInspector&insp) const overrd { ::ROOT::Class_ShowMembers(name::Class(), this, insp); } \
322 virtual_keyword void Streamer(TBuffer&) overrd { ::Error("Streamer", "Cannot stream interpreted class."); } \
323 void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { name::Streamer(ClassDef_StreamerNVirtual_b); } \
324 static const char *DeclFileName() { return __FILE__; } \
325 static int ImplFileLine() { return 0; } \
326 static const char *ImplFileName() { return __FILE__; }
357 return ((
TCling*)
gCling)->LibraryLoadingFailed(errmessage, libStem, permanent, resolved);
396 static vector<const NamedDecl*> updateList;
399 if (entered) topLevel =
kFALSE;
414 updateList.push_back(TD);
417 while (!updateList.empty()) {
419 updateList.pop_back();
426 const clang::Decl* D =
static_cast<const clang::Decl*
>(enumObj->
GetDeclId());
427 if(
const clang::EnumDecl* ED = dyn_cast<clang::EnumDecl>(D)) {
429 for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin(),
430 EDE = ED->enumerator_end(); EDI != EDE; ++EDI) {
432 std::string constbuf;
433 if (
const NamedDecl* END = llvm::dyn_cast<NamedDecl>(*EDI)) {
434 PrintingPolicy Policy((*EDI)->getASTContext().getPrintingPolicy());
435 llvm::raw_string_ostream stream(constbuf);
437 Policy.AnonymousTagLocations =
false;
438 (END)->getNameForDiagnostic(stream, Policy,
false);
440 const char* constantName = constbuf.c_str();
444 const llvm::APSInt valAPSInt = (*EDI)->getInitVal();
445 if (valAPSInt.isSigned()) {
446 value = valAPSInt.getSExtValue();
448 value = valAPSInt.getZExtValue();
455 DataMemberInfo_t* dmInfo = (DataMemberInfo_t*) tcDmInfo;
459 enumConstant =
new TEnumConstant(dmInfo, constantName, value, enumObj);
466 globals->
Add(enumConstant);
479 const clang::Decl* D =
static_cast<const clang::Decl*
>(VD);
481 if (
const EnumDecl* ED = llvm::dyn_cast<EnumDecl>(D)) {
483 PrintingPolicy Policy(ED->getASTContext().getPrintingPolicy());
484 llvm::raw_string_ostream stream(buf);
486 Policy.AnonymousTagLocations =
false;
487 ED->getNameForDiagnostic(stream, Policy,
false);
493 const char*
name = buf.c_str();
504 const clang::Decl* D =
static_cast<const clang::Decl*
>(DV);
506 if (!D->isCanonicalDecl() && !isa<clang::NamespaceDecl>(D)
507 && !dyn_cast<clang::RecordDecl>(D))
return;
509 if (isa<clang::FunctionDecl>(D->getDeclContext())
510 || isa<clang::TagDecl>(D->getDeclContext()))
514 if (
const clang::CXXRecordDecl* RD = dyn_cast<clang::CXXRecordDecl>(D)) {
515 if (RD->getDescribedClassTemplate())
517 }
else if (
const clang::FunctionDecl* FD = dyn_cast<clang::FunctionDecl>(D)) {
518 if (FD->getDescribedFunctionTemplate())
522 if (
const RecordDecl *TD = dyn_cast<RecordDecl>(D)) {
523 if (TD->isCanonicalDecl() || TD->isThisDeclarationADefinition())
526 else if (
const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
528 if (
const TagDecl *TD = dyn_cast<TagDecl>(D)) {
532 }
else if (
const NamespaceDecl* NSD = dyn_cast<NamespaceDecl>(D)) {
537 if (!isa<TranslationUnitDecl>(ND->getDeclContext()))
541 if (isa<EnumDecl>(ND))
546 if (!(isa<VarDecl>(ND)))
550 if (
gROOT->GetListOfGlobals()->FindObject(ND->getNameAsString().c_str()))
554 gROOT->GetListOfGlobals()->Add(
new TGlobal((DataMemberInfo_t *)
556 cast<ValueDecl>(ND), 0)));
588 const char* canonicalName) {
589 ((
TCling*)
gCling)->LibraryLoaded(dyLibHandle, canonicalName);
594 ((
TCling *)
gCling)->RegisterRdictForLoadPCM(pcmFileNameFullPath, pcmContent);
598 const char* canonicalName) {
599 ((
TCling*)
gCling)->LibraryUnloaded(dyLibHandle, canonicalName);
615 cling::DynamicLibraryManager::ExposeHiddenSharedLibrarySymbols(interpLibHandle);
616 return new TCling(
"C++",
"cling C++ Interpreter", argv);
638 return ((
TCling*)
gCling)->GetClassSharedLibs(className);
644 return ((
TCling*)
gCling)->IsAutoLoadNamespaceCandidate(nsDecl);
649 string file(fileName);
655 string &args,
string &io,
string &fname)
657 string file(fileName);
658 TString f, amode, arguments, aclicio;
660 mode = amode.
Data(); args = arguments.
Data();
661 io = aclicio.
Data(); fname =
f.Data();
671 char *__unDName(
char *demangled,
const char *mangled,
int out_len,
672 void * (* pAlloc )(
size_t),
void (* pFree )(
void *),
673 unsigned short int flags);
685 using namespace clang;
686 if (NamespaceDecl* nsd = llvm::dyn_cast<NamespaceDecl>(decl)){
690 if (ClassTemplateDecl* ctd = llvm::dyn_cast<ClassTemplateDecl>(decl)){
702 return ((
TCling*)
gCling)->LazyFunctionCreatorAutoload(mangled_name);
711 const std::vector<std::string> &headers,
712 const std::vector<std::string> &fwdDecls,
713 const std::vector<std::string> &unknown)
719 if (classes.empty()) {
723 const std::string& className = classes[0];
725 TString fileName =
"AutoDict_";
726 std::string::const_iterator sIt;
727 for (sIt = className.begin(); sIt != className.end(); ++sIt) {
728 if (*sIt ==
'<' || *sIt ==
'>' ||
729 *sIt ==
' ' || *sIt ==
'*' ||
730 *sIt ==
',' || *sIt ==
'&' ||
738 if (classes.size() > 1) {
740 std::vector<std::string>::const_iterator it = classes.begin();
741 while ((++it) != classes.end()) {
742 for (
UInt_t cursor = 0; cursor != it->length(); ++cursor) {
743 chk = chk * 3 + it->at(cursor);
756 static const std::set<std::string> sSTLTypes {
757 "vector",
"list",
"forward_list",
"deque",
"map",
"unordered_map",
"multimap",
758 "unordered_multimap",
"set",
"unordered_set",
"multiset",
"unordered_multiset",
759 "queue",
"priority_queue",
"stack",
"iterator"};
760 std::vector<std::string>::const_iterator it;
761 std::string fileContent(
"");
762 for (it = headers.begin(); it != headers.end(); ++it) {
763 fileContent +=
"#include \"" + *it +
"\"\n";
765 for (it = unknown.begin(); it != unknown.end(); ++it) {
771 while (dirbase.
Length() && dirbase !=
"."
772 && dirbase !=
"include" && dirbase !=
"inc"
773 && dirbase !=
"prec_stl") {
777 fileContent +=
TString(
"#include \"") + header +
"\"\n";
780 for (it = fwdDecls.begin(); it != fwdDecls.end(); ++it) {
781 fileContent +=
"class " + *it +
";\n";
783 fileContent +=
"#ifdef __CINT__ \n";
784 fileContent +=
"#pragma link C++ nestedclasses;\n";
785 fileContent +=
"#pragma link C++ nestedtypedefs;\n";
786 for (it = classes.begin(); it != classes.end(); ++it) {
788 size_t posTemplate =
n.find(
'<');
789 std::set<std::string>::const_iterator iSTLType = sSTLTypes.end();
790 if (posTemplate != std::string::npos) {
791 n.erase(posTemplate, std::string::npos);
792 if (
n.compare(0, 5,
"std::") == 0) {
795 iSTLType = sSTLTypes.find(
n);
797 fileContent +=
"#pragma link C++ class ";
798 fileContent += *it +
"+;\n" ;
799 fileContent +=
"#pragma link C++ class ";
800 if (iSTLType != sSTLTypes.end()) {
804 fileContent += *it +
"::*;\n" ;
809 fileContent += *it +
"::*+;\n" ;
812 fileContent +=
"#endif\n";
816 filePointer = fopen(fileName,
"w");
817 if (filePointer == NULL) {
823 fprintf(filePointer,
"%s", fileContent.c_str());
839 const std::vector<std::string> &headers,
840 const std::vector<std::string> &fwdDecls,
841 const std::vector<std::string> &unknown)
847 std::vector<std::string> classes;
848 classes.push_back(className);
876 void exceptionErrorHandler(
void * ,
877 const std::string& reason,
879 throw std::runtime_error(std::string(
">>> Interpreter compilation error:\n") + reason);
893 class clangDiagSuppr {
895 clangDiagSuppr(clang::DiagnosticsEngine& diag): fDiagEngine(diag){
896 fOldDiagValue = fDiagEngine.getIgnoreAllWarnings();
897 fDiagEngine.setIgnoreAllWarnings(
true);
901 fDiagEngine.setIgnoreAllWarnings(fOldDiagValue);
904 clang::DiagnosticsEngine& fDiagEngine;
926 unsigned long offset = 0;
927 if (strncmp(tname.c_str(),
"const ", 6) == 0) {
930 unsigned long end = tname.length();
931 while( end && (tname[end-1]==
'&' || tname[end-1]==
'*' || tname[end-1]==
']') ) {
932 if ( tname[end-1]==
']' ) {
934 while ( end && tname[end-1]!=
'[' ) --end;
938 std::string innerbuf;
940 if (end != tname.length()) {
941 innerbuf = tname.substr(offset,end-offset);
942 inner = innerbuf.c_str();
944 inner = tname.c_str()+offset;
948 if (
gROOT->GetListOfClasses()->FindObject(inner)
958 const char *newname =
type->GetFullTypeName();
960 newname =
"Long64_t";
962 newname =
"ULong64_t";
964 if (strcmp(inner,newname) == 0) {
967 if (offset) result =
"const ";
969 if ( end != tname.length() ) {
970 result += tname.substr(end,tname.length()-end);
972 if (result == tname) result.clear();
978 if (lastPos != inner)
982 const auto enName = lastPos;
983 const auto scopeNameSize = ((
Long64_t)lastPos - (
Long64_t)inner) /
sizeof(
decltype(*lastPos)) - 2;
984 char *scopeName =
new char[scopeNameSize + 1];
985 strncpy(scopeName, inner, scopeNameSize);
986 scopeName[scopeNameSize] =
'\0';
988 if (
auto scope =
static_cast<TClass *
>(
gROOT->GetListOfClasses()->FindObject(scopeName))) {
989 auto enumTable =
dynamic_cast<const THashList *
>(scope->GetListOfEnums(
false));
990 if (enumTable && enumTable->THashList::FindObject(enName)) {
delete [] scopeName;
return true; }
994 auto listOfEnums = scope->GetListOfEnums();
996 auto enumTable =
dynamic_cast<const THashList *
>(listOfEnums);
997 if (enumTable && enumTable->THashList::FindObject(enName)) {
delete [] scopeName;
return true; }
1000 delete [] scopeName;
1004 auto enumTable =
dynamic_cast<const THashList *
>(
gROOT->GetListOfEnums());
1005 if (enumTable && enumTable->THashList::FindObject(inner))
return true;
1028 return fContent.c_str();
1036 bool notPresent = fLinesHashSet.emplace(fHashFunc(str)).second;
1050static bool LoadModule(
const std::string &ModuleName, cling::Interpreter &interp)
1060 assert(!currentDir.empty());
1063 ::Info(
"TCling::__LoadModule",
"Preloading module %s. \n",
1064 ModuleName.c_str());
1066 return interp.loadModule(ModuleName,
true);
1072static void LoadModules(
const std::vector<std::string> &modules, cling::Interpreter &interp)
1074 for (
const auto &modName : modules)
1080 const static bool foundSymbol = dlsym(RTLD_DEFAULT,
"usedToIdentifyRootClingByDlSym");
1085static bool HasASTFileOnDisk(clang::Module *M,
const clang::Preprocessor &PP, std::string *FullFileName =
nullptr)
1087 const HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
1089 std::string ModuleFileName;
1090 if (!HSOpts.PrebuiltModulePaths.empty())
1092 ModuleFileName = PP.getHeaderSearchInfo().getModuleFileName(M->Name,
"",
true);
1094 *FullFileName = ModuleFileName;
1096 return !ModuleFileName.empty();
1102 CompilerInstance &CI = *interp.getCI();
1103 Preprocessor &PP = CI.getPreprocessor();
1104 auto ModuleManager = CI.getModuleManager();
1105 assert(ModuleManager);
1110 if (ModuleIndexPath.empty())
1113 ModuleManager->resetForReload();
1114 ModuleManager->loadGlobalIndex();
1115 GlobalModuleIndex *GlobalIndex = ModuleManager->getGlobalIndex();
1120 ModuleMap &MMap = PP.getHeaderSearchInfo().getModuleMap();
1121 bool RecreateIndex =
false;
1122 for (ModuleMap::module_iterator
I = MMap.module_begin(),
E = MMap.module_end();
I !=
E; ++
I) {
1123 Module *TheModule =
I->second;
1128 RecreateIndex =
true;
1130 if (RecreateIndex) {
1131 GlobalModuleIndex::writeIndex(CI.getFileManager(), CI.getPCHContainerReader(), ModuleIndexPath);
1132 ModuleManager->resetForReload();
1133 ModuleManager->loadGlobalIndex();
1134 GlobalIndex = ModuleManager->getGlobalIndex();
1143 if (!clingInterp.getCI()->getLangOpts().Modules)
1160 LoadModule(
"_Builtin_intrinsics", clingInterp);
1164 std::vector<std::string> CoreModules = {
"ROOT_Foundation_C",
1167 "ROOT_Foundation_Stage1_NoRTTI",
1174 static constexpr std::array<const char *, 3> ExcludeModules = {
1175 {
"Rtools",
"RSQLite",
"RInterface"}};
1179 std::vector<std::string> CommonModules = {
"MathCore"};
1183 std::vector<std::string> FIXMEModules = {
"Hist",
"Gpad",
"Graf",
1184 "GenVector",
"Smatrix",
"Tree",
1185 "TreePlayer",
"Physics",
1189 clang::CompilerInstance &CI = *clingInterp.getCI();
1190 GlobalModuleIndex *GlobalIndex =
nullptr;
1191 const char *experimentalGMI =
gSystem->
Getenv(
"ROOT_EXPERIMENTAL_GMI");
1192 if (experimentalGMI && strcmp(experimentalGMI,
"false") != 0) {
1194 GlobalIndex = CI.getModuleManager()->getGlobalIndex();
1196 llvm::StringSet<> KnownModuleFileNames;
1198 GlobalIndex->getKnownModuleFileNames(KnownModuleFileNames);
1200 clang::Preprocessor &PP = CI.getPreprocessor();
1201 std::vector<std::string> PendingModules;
1202 PendingModules.reserve(256);
1203 ModuleMap &MMap = PP.getHeaderSearchInfo().getModuleMap();
1204 for (
auto I = MMap.module_begin(),
E = MMap.module_end();
I !=
E; ++
I) {
1205 clang::Module *M =
I->second;
1209 std::string FullASTFilePath;
1213 if (GlobalIndex && KnownModuleFileNames.count(FullASTFilePath))
1216 if (M->IsMissingRequirement)
1224 if (std::find(CoreModules.begin(), CoreModules.end(), M->Name) != CoreModules.end())
1227 if (std::find(ExcludeModules.begin(), ExcludeModules.end(), M->Name) != ExcludeModules.end())
1235 PendingModules.push_back(M->Name);
1242 assert(clingInterp.getMacro(
"gROOT") &&
"Couldn't load gROOT macro?");
1250 clingInterp.declare(
"#ifdef I\n #undef I\n #endif\n");
1254 clingInterp.declare(
"#ifdef complex\n #undef complex\n #endif\n");
1258 clingInterp.declare(
"#ifdef PI\n #undef PI\n #endif\n");
1259 clingInterp.declare(
"#ifdef ERROR\n #undef ERROR\n #endif\n");
1264 std::string PreIncludes;
1265 bool hasCxxModules = clingInterp.getCI()->getLangOpts().Modules;
1271 PreIncludes +=
"#include \"RtypesCore.h\"\n";
1274 PreIncludes +=
"#include \"Rtypes.h\"\n";
1276 PreIncludes += gClassDefInterpMacro +
"\n"
1277 + gInterpreterClassDef +
"\n"
1279 "#define ClassImp(X);\n";
1282 PreIncludes +=
"#include <string>\n";
1287 PreIncludes +=
"#include <cassert>\n";
1289 PreIncludes +=
"using namespace std;\n";
1290 clingInterp.declare(PreIncludes);
1308#ifdef R__USE_CXXMODULES
1312 llvm::install_fatal_error_handler(&exceptionErrorHandler);
1316 std::vector<std::string> clingArgsStorage;
1317 clingArgsStorage.push_back(
"cling4root");
1318 for (
const char*
const* arg = argv; *arg; ++arg)
1319 clingArgsStorage.push_back(*arg);
1322 if (!fromRootCling) {
1327 clingArgsStorage.push_back(
"-I" + interpInclude);
1330 clingArgsStorage.push_back(
"-I" + interpInclude +
"/cling");
1341 std::string pchFilename = interpInclude +
"/allDict.cxx.pch";
1346 clingArgsStorage.push_back(
"-include-pch");
1347 clingArgsStorage.push_back(pchFilename);
1350 clingArgsStorage.push_back(
"-Wno-undefined-inline");
1351 clingArgsStorage.push_back(
"-fsigned-char");
1355 llvm::Optional<std::string> EnvOpt = llvm::sys::Process::GetEnv(
"EXTRA_CLING_ARGS");
1356 if (EnvOpt.hasValue()) {
1357 StringRef Env(*EnvOpt);
1358 while (!Env.empty()) {
1360 std::tie(Arg, Env) = Env.split(
' ');
1361 clingArgsStorage.push_back(Arg.str());
1365 auto GetEnvVarPath = [](
const std::string &EnvVar,
1366 std::vector<std::string> &Paths) {
1367 llvm::Optional<std::string> EnvOpt = llvm::sys::Process::GetEnv(EnvVar);
1368 if (EnvOpt.hasValue()) {
1369 StringRef Env(*EnvOpt);
1370 while (!Env.empty()) {
1373 if (std::find(Paths.begin(), Paths.end(), Arg.str()) == Paths.end())
1374 Paths.push_back(Arg.str());
1380 std::vector<std::string> Paths;
1385 GetEnvVarPath(
"CLING_PREBUILT_MODULE_PATH", Paths);
1387 std::string EnvVarPath;
1388 for (
const std::string&
P : Paths)
1391 gSystem->
Setenv(
"CLING_PREBUILT_MODULE_PATH", EnvVarPath.c_str());
1395 EnvOpt = llvm::sys::Process::GetEnv(
"ROOT_CLING_TIMING");
1396 if (EnvOpt.hasValue())
1397 clingArgsStorage.push_back(
"-ftime-report");
1404 std::vector<std::string> Paths;
1406 GetEnvVarPath(
"CLING_MODULEMAP_PATH", Paths);
1411 for (
const std::string&
P : Paths) {
1413 +
"module.modulemap";
1414 if (!llvm::sys::fs::exists(ModuleMapLoc)) {
1416 ::Info(
"TCling::TCling",
"Modulemap %s does not exist \n",
1417 ModuleMapLoc.c_str());
1422 clingArgsStorage.push_back(
"-fmodule-map-file=" + ModuleMapLoc);
1424 std::string ModulesCachePath;
1425 EnvOpt = llvm::sys::Process::GetEnv(
"CLING_MODULES_CACHE_PATH");
1426 if (EnvOpt.hasValue()){
1427 StringRef Env(*EnvOpt);
1428 assert(llvm::sys::fs::exists(Env) &&
"Path does not exist!");
1429 ModulesCachePath = Env.str();
1434 clingArgsStorage.push_back(
"-fmodules-cache-path=" + ModulesCachePath);
1437 std::vector<const char*> interpArgs;
1438 for (std::vector<std::string>::const_iterator iArg = clingArgsStorage.begin(),
1439 eArg = clingArgsStorage.end(); iArg != eArg; ++iArg)
1440 interpArgs.push_back(iArg->c_str());
1447 if (!fromRootCling) {
1449 interpArgs.push_back(
"-fmodules");
1450 interpArgs.push_back(
"-fno-implicit-module-maps");
1454 interpArgs.push_back(
"-Rmodule-build");
1460 interpArgs.push_back(
"-fno-autolink");
1465 interpArgs.push_back(
"-ffast-math");
1471 extraArgs && *extraArgs; ++extraArgs) {
1472 if (!strcmp(*extraArgs,
"-resource-dir")) {
1474 llvmResourceDir = *(++extraArgs);
1476 interpArgs.push_back(*extraArgs);
1481 interpArgs.push_back(arg.c_str());
1485 cling::Interpreter::ModuleFileExtensions extensions;
1486 EnvOpt = llvm::sys::Process::GetEnv(
"ROOTDEBUG_RDICT");
1487 if (!EnvOpt.hasValue())
1488 extensions.push_back(std::make_shared<TClingRdictModuleFileExtension>());
1490 fInterpreter = llvm::make_unique<cling::Interpreter>(interpArgs.size(),
1492 llvmResourceDir, extensions);
1494 if (!fromRootCling) {
1499 fInterpreter->getCI()->getPreprocessorOpts().DisablePCHValidation =
true;
1503 fInterpreter->getCI()->getLangOpts().SpellChecking =
false;
1508 static llvm::raw_fd_ostream fMPOuts (STDOUT_FILENO,
false);
1528 if (!fromRootCling) {
1538 std::unique_ptr<TClingCallbacks>
1544 if (!fromRootCling) {
1545 cling::DynamicLibraryManager& DLM = *
fInterpreter->getDynamicLibraryManager();
1549 auto ShouldPermanentlyIgnore = [](llvm::StringRef FileName) ->
bool{
1550 llvm::StringRef stem = llvm::sys::path::stem(FileName);
1551 return stem.startswith(
"libNew") || stem.startswith(
"libcppyy_backend");
1554 DLM.initializeDyld(ShouldPermanentlyIgnore);
1592 assert(
GetRootMapFiles() == 0 &&
"Must be called before LoadLibraryMap!");
1611 auto setFactory = []() {
1615 static bool doneFactory = setFactory();
1627 if (llvm::sys::fs::exists(pcmFileNameFullPath)) {
1628 ::Error(
"TCling::RegisterRdictForLoadPCM",
"Rdict '%s' is both in Module extension and in File system.", pcmFileNameFullPath.c_str());
1645 if (listOfKeys && ((listOfKeys->GetSize() == 0) ||
1646 ((listOfKeys->GetSize() == 1) &&
1647 !strcmp(((
TKey *)listOfKeys->At(0))->GetName(),
"EMPTY")
1654 ::Info(
"TCling::LoadPCMImpl",
"reading protoclasses for %s \n", pcmFile.
GetName());
1656 pcmFile.
GetObject(
"__ProtoClasses", protoClasses);
1659 for (
auto obj : *protoClasses) {
1669 for (
auto proto : *protoClasses) {
1677 ::Error(
"TCling::LoadPCM",
"Inconsistent TClassTable for %s",
proto->GetName());
1688 protoClasses->Clear();
1689 delete protoClasses;
1693 pcmFile.
GetObject(
"__Typedefs", dataTypes);
1695 for (
auto typedf : *dataTypes)
1696 gROOT->GetListOfTypes()->Add(typedf);
1705 auto listOfGlobals =
gROOT->GetListOfGlobals();
1706 auto listOfEnums =
dynamic_cast<THashList *
>(
gROOT->GetListOfEnums());
1708 for (
auto selEnum : *enums) {
1709 const char *enumScope = selEnum->
GetTitle();
1710 const char *enumName = selEnum->GetName();
1711 if (strcmp(enumScope,
"") == 0) {
1714 if (!listOfEnums->THashList::FindObject(enumName)) {
1715 ((
TEnum *)selEnum)->SetClass(
nullptr);
1716 listOfEnums->Add(selEnum);
1719 if (!listOfGlobals->FindObject(enumConstant)) {
1720 listOfGlobals->Add(enumConstant);
1727 if (!nsTClassEntry) {
1730 auto listOfEnums = nsTClassEntry->
fEnums.load();
1741 if (listOfEnums && !listOfEnums->THashList::FindObject(enumName)) {
1742 ((
TEnum *)selEnum)->SetClass(nsTClassEntry);
1743 listOfEnums->Add(selEnum);
1759 assert(!pcmFileNameFullPath.empty());
1760 assert(llvm::sys::path::is_absolute(pcmFileNameFullPath));
1763 TString pcmFileName = pcmFileNameFullPath;
1771 llvm::SaveAndRestore<Int_t> SaveGDebug(
gDebug);
1774 ::Info(
"TCling::LoadPCM",
"Loading ROOT PCM %s", pcmFileName.
Data());
1779 if (llvm::sys::fs::is_symlink_file(pcmFileNameFullPath))
1784 llvm::StringRef pcmContent = pendingRdict->second;
1786 std::string RDictFileOpts = pcmFileNameFullPath +
"?filetype=pcm";
1787 TMemFile pcmMemFile(RDictFileOpts.c_str(), range);
1795 if (!llvm::sys::fs::exists(pcmFileNameFullPath)) {
1796 ::Error(
"TCling::LoadPCM",
"ROOT PCM %s file does not exist",
1797 pcmFileNameFullPath.data());
1800 ::Info(
"TCling::LoadPCM",
"In-memory ROOT PCM candidate %s\n",
1801 rdict.first.c_str());
1805 if (!
gROOT->IsRootFile(pcmFileName)) {
1806 Fatal(
"LoadPCM",
"The file %s is not a ROOT as was expected\n", pcmFileName.
Data());
1809 TFile pcmFile(pcmFileName +
"?filetype=pcm",
"READ");
1816 using namespace clang;
1818 class ExtLexicalStorageAdder:
public RecursiveASTVisitor<ExtLexicalStorageAdder>{
1823 bool VisitRecordDecl(clang::RecordDecl* rcd){
1825 Info(
"ExtLexicalStorageAdder",
1826 "Adding external lexical storage to class %s",
1827 rcd->getNameAsString().c_str());
1828 auto reDeclPtr = rcd->getMostRecentDecl();
1830 reDeclPtr->setHasExternalLexicalStorage();
1831 }
while ((reDeclPtr = reDeclPtr->getPreviousDecl()));
1844 const std::string &ModuleMapName )
const
1846 assert(llvm::sys::path::is_absolute(FullPath));
1847 Preprocessor &PP =
fInterpreter->getCI()->getPreprocessor();
1848 FileManager &FM = PP.getFileManager();
1851 const DirectoryEntry *DE = FM.getDirectory(FullPath);
1853 HeaderSearch &HS = PP.getHeaderSearchInfo();
1854 HeaderSearchOptions &HSOpts = HS.getHeaderSearchOpts();
1855 const auto &ModPaths = HSOpts.PrebuiltModulePaths;
1856 bool pathExists = std::find(ModPaths.begin(), ModPaths.end(), FullPath) != ModPaths.end();
1858 HSOpts.AddPrebuiltModulePath(FullPath);
1863 llvm::SmallString<256> ModuleMapFileName(DE->getName());
1864 llvm::sys::path::append(ModuleMapFileName, ModuleMapName);
1865 const FileEntry *FE = FM.getFile(ModuleMapFileName,
false,
1870 if (FE && !this->
IsLoaded(FE->getName().data())) {
1871 if (!HS.loadModuleMapFile(FE,
false))
1873 Error(
"RegisterPrebuiltModulePath",
"Could not load modulemap in %s", ModuleMapFileName.c_str());
1889 "libforward_listDict",
1897 "libunordered_setDict",
1898 "libunordered_multisetDict",
1899 "libunordered_mapDict",
1900 "libunordered_multimapDict",
1908 char dyLibError[1000];
1909 FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
1910 dyLibError,
sizeof(dyLibError), NULL);
1912 const char *dyLibError = dlerror();
1914 ::Error(
"TCling::RegisterModule",
"Cannot open shared library %s for dictionary %s:\n %s", dyLibName, modulename,
1915 (dyLibError) ? dyLibError :
"");
1952 const char** headers,
1953 const char** includePaths,
1954 const char* payloadCode,
1955 const char* fwdDeclsCode,
1956 void (*triggerFunc)(),
1958 const char** classesHeaders,
1959 Bool_t lateRegistration ,
1966 if (fromRootCling)
return;
1975 bool isACLiC = strstr(modulename,
"_ACLiC_dict") !=
nullptr;
1976 if (hasHeaderParsingOnDemand && isACLiC) {
1978 Info(
"TCling::RegisterModule",
1979 "Header parsing on demand is active but this is an Aclic library. Disabling it for this library.");
1980 hasHeaderParsingOnDemand =
false;
1994 for (
const char** inclPath = includePaths; *inclPath; ++inclPath) {
1997 cling::Transaction*
T = 0;
1999 for (
auto& fwdDeclArgToSkipPair : fwdDeclsArgToSkip){
2000 const std::string& fwdDecl = fwdDeclArgToSkipPair.first;
2001 const int nArgsToSkip = fwdDeclArgToSkipPair.second;
2003 assert(cling::Interpreter::kSuccess == compRes &&
2004 "A fwd declaration could not be compiled");
2005 if (compRes!=cling::Interpreter::kSuccess){
2006 Warning(
"TCling::RegisterModule",
2007 "Problems in declaring string '%s' were encountered.",
2022 TString code = gNonInterpreterClassDef;
2024 code += payloadCode;
2026 std::string dyLibName = cling::DynamicLibraryManager::getSymbolLocation(triggerFunc);
2027 assert(!llvm::sys::fs::is_symlink_file(dyLibName));
2029 if (dyLibName.empty()) {
2030 ::Error(
"TCling::RegisterModule",
"Dictionary trigger function for %s not found", modulename);
2035 bool isSharedLib = cling::DynamicLibraryManager::isSharedLibrary(dyLibName);
2037 bool wasDlopened =
false;
2042 if (!lateRegistration) {
2049 void* dyLibHandle = dlopen(dyLibName.c_str(), RTLD_LAZY | RTLD_GLOBAL);
2059 if (hasHeaderParsingOnDemand && fwdDeclsCode){
2062 std::string fwdDeclsCodeLessEnums;
2066 std::string fwdDeclsLine;
2067 std::istringstream fwdDeclsCodeStr(fwdDeclsCode);
2068 std::vector<std::string> scopes;
2069 while (std::getline(fwdDeclsCodeStr, fwdDeclsLine)) {
2070 const auto enumPos = fwdDeclsLine.find(
"enum __attribute__((annotate(\"");
2072 if (enumPos != std::string::npos) {
2079 auto nsPos = fwdDeclsLine.find(
"namespace");
2080 R__ASSERT(nsPos < enumPos &&
"Inconsistent enum and enclosing scope parsing!");
2081 while (nsPos < enumPos && nsPos != std::string::npos) {
2083 const auto nsNameStart = nsPos + 10;
2084 const auto nsNameEnd = fwdDeclsLine.find(
'{', nsNameStart);
2085 const auto nsName = fwdDeclsLine.substr(nsNameStart, nsNameEnd - nsNameStart);
2086 scopes.push_back(nsName);
2087 nsPos = fwdDeclsLine.find(
"namespace", nsNameEnd);
2090 clang::DeclContext* DC = 0;
2091 for (
auto &&aScope: scopes) {
2092 DC = cling::utils::Lookup::Namespace(&
fInterpreter->getSema(), aScope.c_str(), DC);
2098 if (scopes.empty() || DC) {
2100 size_t posEnumName = fwdDeclsLine.find(
"\"))) ", 32);
2101 R__ASSERT(posEnumName != std::string::npos &&
"Inconsistent enum fwd decl!");
2103 while (isspace(fwdDeclsLine[posEnumName]))
2105 size_t posEnumNameEnd = fwdDeclsLine.find(
" : ", posEnumName);
2106 R__ASSERT(posEnumNameEnd != std::string::npos &&
"Inconsistent enum fwd decl (end)!");
2107 while (isspace(fwdDeclsLine[posEnumNameEnd]))
2111 std::string enumName = fwdDeclsLine.substr(posEnumName,
2112 posEnumNameEnd - posEnumName + 1);
2114 if (clang::NamedDecl* enumDecl
2115 = cling::utils::Lookup::Named(&
fInterpreter->getSema(),
2116 enumName.c_str(), DC)) {
2119 R__ASSERT(llvm::dyn_cast<clang::EnumDecl>(enumDecl) &&
"not an enum decl!");
2126 fwdDeclsCodeLessEnums += fwdDeclsLine +
"\n";
2130 if (fwdDeclsCodeLessEnums.size() != 0){
2131 auto compRes =
fInterpreter->declare(fwdDeclsCodeLessEnums, &
T);
2132 assert(cling::Interpreter::kSuccess == compRes &&
2133 "The forward declarations could not be compiled");
2134 if (compRes!=cling::Interpreter::kSuccess){
2135 Warning(
"TCling::RegisterModule",
2136 "Problems in compiling forward declarations for module %s: '%s'",
2137 modulename, fwdDeclsCodeLessEnums.c_str()) ;
2145 ExtLexicalStorageAdder elsa;
2146 for (
auto dciIt =
T->decls_begin();dciIt!=
T->decls_end();dciIt++){
2147 cling::Transaction::DelayCallInfo& dci = *dciIt;
2148 for(
auto dit = dci.m_DGR.begin(); dit != dci.m_DGR.end(); ++dit) {
2149 clang::Decl* declPtr = *dit;
2150 elsa.TraverseDecl(declPtr);
2164 for (
const char** classesHeader = classesHeaders; *classesHeader; ++classesHeader) {
2165 temp=*classesHeader;
2167 size_t theTemplateHash = 0;
2168 bool addTemplate =
false;
2169 size_t posTemplate = temp.find(
'<');
2170 if (posTemplate != std::string::npos) {
2172 std::string templateName = temp.substr(0, posTemplate);
2178 for (
const char** classesHeader_inner = classesHeader; 0!=strcmp(*classesHeader_inner,
"@"); ++classesHeader_inner,++classesHeader){
2180 if (payloadCode == *classesHeader_inner ){
2182 if (addTemplate)
fPayloads.insert(theTemplateHash);
2185 Info(
"TCling::RegisterModule",
2186 "Adding a header for %s", temp.c_str());
2192 addTemplate =
false;
2200 bool ModuleWasSuccessfullyLoaded =
false;
2202 std::string ModuleName = modulename;
2203 if (llvm::StringRef(modulename).startswith(
"lib"))
2204 ModuleName = llvm::StringRef(modulename).substr(3).str();
2209 clang::Preprocessor &PP = TheSema.getPreprocessor();
2210 std::string ModuleMapName;
2212 ModuleMapName = ModuleName +
".modulemap";
2214 ModuleMapName =
"module.modulemap";
2221 if (!ModuleWasSuccessfullyLoaded) {
2223 clang::HeaderSearch &headerSearch = PP.getHeaderSearchInfo();
2224 clang::ModuleMap &moduleMap = headerSearch.getModuleMap();
2225 if (moduleMap.findModule(ModuleName))
2226 Info(
"TCling::RegisterModule",
"Module %s in modulemap failed to load.", ModuleName.c_str());
2231 llvm::SmallString<256> pcmFileNameFullPath(dyLibName);
2234 llvm::sys::fs::make_absolute(pcmFileNameFullPath);
2235 llvm::sys::path::remove_filename(pcmFileNameFullPath);
2236 llvm::sys::path::append(pcmFileNameFullPath,
2238 LoadPCM(pcmFileNameFullPath.str().str());
2245 clangDiagSuppr diagSuppr(TheSema.getDiagnostics());
2247#if defined(R__MUST_REVISIT)
2248#if R__MUST_REVISIT(6,2)
2249 Warning(
"TCling::RegisterModule",
"Diagnostics suppression should be gone by now.");
2253 if (!ModuleWasSuccessfullyLoaded && !hasHeaderParsingOnDemand){
2256 const cling::Transaction* watermark =
fInterpreter->getLastTransaction();
2257 cling::Interpreter::CompilationResult compRes =
fInterpreter->parseForModule(code.
Data());
2263 assert(cling::Interpreter::kSuccess == compRes &&
2264 "Payload code of a dictionary could not be parsed correctly.");
2265 if (compRes!=cling::Interpreter::kSuccess) {
2266 Warning(
"TCling::RegisterModule",
2267 "Problems declaring payload for module %s.", modulename) ;
2280 if (!ModuleWasSuccessfullyLoaded && !hasHeaderParsingOnDemand) {
2283 "#undef __ROOTCLING__\n"
2284 + gInterpreterClassDef +
2289 assert(isSharedLib);
2292 dlclose(dyLibHandle);
2312 typedef std::vector<std::pair<TClass*,DictFuncPtr_t> >::iterator iterator;
2318 if ( i->first == oldcl ) {
2341 const char* input_line,
2342 cling::Interpreter::CompilationResult& compRes,
2346 return metaProcessor->process(input_line, compRes, result);
2348 catch (cling::InterpreterException&
ex)
2350 Error(
"HandleInterpreterException",
"%s.\n%s",
ex.what(),
"Execution of your code was aborted.");
2352 compRes = cling::Interpreter::kFailure;
2361 if (
auto ie =
dynamic_cast<const cling::InterpreterException*
>(&
e)) {
2387 gROOT->SetLineIsProcessing();
2391 gROOT->SetLineHasBeenProcessed();
2404 gROOT->SetLineIsProcessing();
2406 struct InterpreterFlagsRAII {
2408 bool fWasDynamicLookupEnabled;
2410 InterpreterFlagsRAII(cling::Interpreter* interp):
2412 fWasDynamicLookupEnabled(interp->isDynamicLookupEnabled())
2416 ~InterpreterFlagsRAII() {
2417 fInterpreter->enableDynamicLookup(fWasDynamicLookupEnabled);
2418 gROOT->SetLineHasBeenProcessed();
2427 cling::Interpreter::CompilationResult compRes = cling::Interpreter::kSuccess;
2428 if (!strncmp(sLine.
Data(),
".L", 2) || !strncmp(sLine.
Data(),
".x", 2) ||
2429 !strncmp(sLine.
Data(),
".X", 2)) {
2437 aclicMode, arguments, io);
2438 if (aclicMode.
Length()) {
2440 R__ASSERT(aclicMode[0]==
'+' &&
"ACLiC mode must start with a +");
2442 if (aclicMode[1]==
'+') {
2448 compRes = cling::Interpreter::kFailure;
2450 if (strncmp(sLine.
Data(),
".L", 2) != 0) {
2453 if (arguments.
Length()==0) {
2462 mod_line =
function + arguments + io;
2468 size_t unnamedMacroOpenCurly;
2471 std::string codeline;
2472 std::ifstream in(fname);
2474 std::getline(in, codeline);
2475 code += codeline +
"\n";
2477 unnamedMacroOpenCurly
2478 = cling::utils::isUnnamedMacro(code,
fInterpreter->getCI()->getLangOpts());
2482 if (unnamedMacroOpenCurly != std::string::npos) {
2484 unnamedMacroOpenCurly);
2494 if (0!=strncmp(sLine.
Data(),
".autodict ",10) && sLine !=
".autodict") {
2499 bool isInclusionDirective = sLine.
Contains(
"\n#include") || sLine.
BeginsWith(
"#include");
2500 if (isInclusionDirective) {
2508 if (result.isValid())
2517 case cling::Interpreter::kSuccess: *error =
kNoError;
break;
2518 case cling::Interpreter::kFailure: *error =
kRecoverable;
break;
2519 case cling::Interpreter::kMoreInputExpected: *error =
kProcessing;
break;
2522 if (compRes == cling::Interpreter::kSuccess
2524 && !result.isVoid())
2526 return result.simplisticCastAs<
long>();
2548 if (path[0] ==
'-' && path[1] ==
'I')
2572 static const TClassRef clRefString(
"std::string");
2573 if (clRefString == cl) {
2583 const char* cobj = (
const char*) obj;
2590 auto inspInspect = [&] (ptrdiff_t offset){
2596 switch(complexType) {
2603 inspInspect(
sizeof(
float));
2608 inspInspect(
sizeof(
double));
2613 inspInspect(
sizeof(
int));
2618 inspInspect(
sizeof(
long));
2623 static clang::PrintingPolicy
2625 if (printPol.Indentation) {
2627 printPol.Indentation = 0;
2628 printPol.SuppressInitializers =
true;
2631 const char* clname = cl->
GetName();
2634 const clang::ASTContext& astContext =
fInterpreter->getCI()->getASTContext();
2635 const clang::Decl *scopeDecl = 0;
2640 scopeDecl = clingCI->
GetDecl();
2641 recordType = clingCI->
GetType();
2643 const cling::LookupHelper& lh =
fInterpreter->getLookupHelper();
2645 scopeDecl = lh.findScope(clname, cling::LookupHelper::NoDiagnostics,
2649 Error(
"InspectMembers",
"Cannot find Decl for class %s", clname);
2652 const clang::CXXRecordDecl* recordDecl
2653 = llvm::dyn_cast<const clang::CXXRecordDecl>(scopeDecl);
2655 Error(
"InspectMembers",
"Cannot find Decl for class %s is not a CXXRecordDecl.", clname);
2664 astContext.getASTRecordLayout(recordDecl);
2666 for (clang::RecordDecl::field_iterator iField = recordDecl->field_begin(),
2667 eField = recordDecl->field_end(); iField != eField; ++iField) {}
2670 const clang::ASTRecordLayout& recLayout
2671 = astContext.getASTRecordLayout(recordDecl);
2678 if (cl->
Size() != recLayout.getSize().getQuantity()) {
2679 Error(
"InspectMembers",
"TClass and cling disagree on the size of the class %s, respectively %d %lld\n",
2683 unsigned iNField = 0;
2686 for (clang::RecordDecl::field_iterator iField = recordDecl->field_begin(),
2687 eField = recordDecl->field_end(); iField != eField;
2688 ++iField, ++iNField) {
2691 clang::QualType memberQT = iField->getType();
2696 memberQT = cling::utils::Transform::GetPartiallyDesugaredType(astContext, memberQT,
fNormalizedCtxt->
GetConfig(),
false );
2697 if (memberQT.isNull()) {
2698 std::string memberName;
2699 llvm::raw_string_ostream stream(memberName);
2701 printPol.AnonymousTagLocations =
false;
2702 iField->getNameForDiagnostic(stream, printPol,
true );
2704 Error(
"InspectMembers",
2705 "Cannot retrieve QualType for member %s while inspecting class %s",
2706 memberName.c_str(), clname);
2709 const clang::Type* memType = memberQT.getTypePtr();
2711 std::string memberName;
2712 llvm::raw_string_ostream stream(memberName);
2714 printPol.AnonymousTagLocations =
false;
2715 iField->getNameForDiagnostic(stream, printPol,
true );
2717 Error(
"InspectMembers",
2718 "Cannot retrieve Type for member %s while inspecting class %s",
2719 memberName.c_str(), clname);
2724 Bool_t ispointer =
false;
2725 if (memNonPtrType->isPointerType()) {
2727 clang::QualType ptrQT
2728 = memNonPtrType->getAs<clang::PointerType>()->getPointeeType();
2733 ptrQT = cling::utils::Transform::GetPartiallyDesugaredType(astContext, ptrQT,
fNormalizedCtxt->
GetConfig(),
false );
2734 if (ptrQT.isNull()) {
2735 std::string memberName;
2736 llvm::raw_string_ostream stream(memberName);
2738 printPol.AnonymousTagLocations =
false;
2739 iField->getNameForDiagnostic(stream, printPol,
true );
2741 Error(
"InspectMembers",
2742 "Cannot retrieve pointee Type for member %s while inspecting class %s",
2743 memberName.c_str(), clname);
2746 memNonPtrType = ptrQT.getTypePtr();
2750 llvm::SmallString<8> arraySize;
2751 const clang::ArrayType* arrType = memNonPtrType->getAsArrayTypeUnsafe();
2752 unsigned arrLevel = 0;
2753 bool haveErrorDueToArray =
false;
2757 const clang::ConstantArrayType* constArrType =
2758 clang::dyn_cast<clang::ConstantArrayType>(arrType);
2760 constArrType->getSize().toStringUnsigned(arraySize);
2763 clang::QualType subArrQT = arrType->getElementType();
2764 if (subArrQT.isNull()) {
2765 std::string memberName;
2766 llvm::raw_string_ostream stream(memberName);
2768 printPol.AnonymousTagLocations =
false;
2769 iField->getNameForDiagnostic(stream, printPol,
true );
2771 Error(
"InspectMembers",
2772 "Cannot retrieve QualType for array level %d (i.e. element type of %s) for member %s while inspecting class %s",
2773 arrLevel, subArrQT.getAsString(printPol).c_str(),
2774 memberName.c_str(), clname);
2775 haveErrorDueToArray =
true;
2778 arrType = subArrQT.getTypePtr()->getAsArrayTypeUnsafe();
2780 if (haveErrorDueToArray) {
2785 std::string fieldName;
2786 if (memType->isPointerType()) {
2791 std::string
ioname(iField->getName());
2794 fieldName += arraySize;
2799 clang::CharUnits offset(astContext.toCharUnitsFromBits(recLayout.getFieldOffset(iNField)));
2800 ptrdiff_t fieldOffset = offset.getQuantity();
2810 auto iFiledQtype = iField->getType();
2811 if (
auto tagDecl = iFiledQtype->getAsTagDecl()){
2812 auto declAccess = tagDecl->getAccess();
2813 if (declAccess == AS_private || declAccess == AS_protected) {
2819 insp.
Inspect(
const_cast<TClass*
>(cl), insp.
GetParent(), fieldName.c_str(), cobj + fieldOffset, isTransient);
2822 const clang::CXXRecordDecl* fieldRecDecl = memNonPtrType->getAsCXXRecordDecl();
2823 if (fieldRecDecl && !fieldRecDecl->isAnonymousStructOrUnion()) {
2826 std::string sFieldRecName;
2829 clang::QualType(memNonPtrType,0),
2839 insp.
InspectMember(sFieldRecName.c_str(), cobj + fieldOffset,
2848 unsigned iNBase = 0;
2849 for (clang::CXXRecordDecl::base_class_const_iterator iBase
2850 = recordDecl->bases_begin(), eBase = recordDecl->bases_end();
2851 iBase != eBase; ++iBase, ++iNBase) {
2852 clang::QualType baseQT = iBase->getType();
2853 if (baseQT.isNull()) {
2854 Error(
"InspectMembers",
2855 "Cannot find QualType for base number %d while inspecting class %s",
2859 const clang::CXXRecordDecl* baseDecl
2860 = baseQT->getAsCXXRecordDecl();
2862 Error(
"InspectMembers",
2863 "Cannot find CXXRecordDecl for base number %d while inspecting class %s",
2868 std::string sBaseName;
2870 std::vector<TClass*> foundClasses;
2872 if (foundClasses.size()==1){
2873 baseCl=foundClasses[0];
2886 std::string qualNameForDiag;
2888 Error(
"InspectMembers",
2889 "Cannot find TClass for base class %s", qualNameForDiag.c_str() );
2894 if (iBase->isVirtual()) {
2897 Error(
"InspectMembers",
2898 "Base %s of class %s is virtual but no object provided",
2899 sBaseName.c_str(), clname);
2907 baseOffset = ci->
GetBaseOffset(baseCi,
const_cast<void*
>(obj),
2909 if (baseOffset == -1) {
2910 Error(
"InspectMembers",
2911 "Error calculating offset of virtual base %s of class %s",
2912 sBaseName.c_str(), clname);
2915 Error(
"InspectMembers",
2916 "Cannot calculate offset of virtual base %s of class %s",
2917 sBaseName.c_str(), clname);
2922 baseOffset = recLayout.getBaseClassOffset(baseDecl).getQuantity();
2969 bool oldDynLookup =
fInterpreter->isDynamicLookupEnabled();
2998 return fInterpreter->getDynamicLibraryManager()->isLibraryLoaded(tLibName.
Data());
3013 llvm::StringRef ModuleName(libname);
3014 ModuleName = llvm::sys::path::stem(ModuleName);
3015 ModuleName.consume_front(
"lib");
3023 clang::ModuleMap &moduleMap =
fInterpreter->getCI()->getPreprocessor().getHeaderSearchInfo().getModuleMap();
3024 clang::Module *M = moduleMap.findModule(ModuleName);
3025 return M && !M->IsMissingRequirement && M->getASTFile();
3043 std::string file_name = filename;
3044 size_t at = std::string::npos;
3045 while ((at = file_name.find(
"/./")) != std::string::npos)
3046 file_name.replace(at, 3,
"/");
3048 std::string filesStr =
"";
3049 llvm::raw_string_ostream filesOS(filesStr);
3050 clang::SourceManager &SM =
fInterpreter->getCI()->getSourceManager();
3051 cling::ClangInternalState::printIncludedFiles(filesOS, SM);
3054 llvm::SmallVector<llvm::StringRef, 100> files;
3055 llvm::StringRef(filesStr).split(files,
"\n");
3057 std::set<std::string> fileMap;
3059 for (llvm::SmallVector<llvm::StringRef, 100>::const_iterator
3060 iF = files.begin(), iE = files.end(); iF != iE; ++iF) {
3061 if ((*iF) == file_name.c_str())
return kTRUE;
3062 fileMap.insert(*iF);
3065 if (fileMap.empty())
return kFALSE;
3068 TString sFilename(file_name.c_str());
3070 && fileMap.count(sFilename.
Data())) {
3078 while (incPath.
Index(
" :") != -1) {
3082 sFilename = file_name.c_str();
3084 && fileMap.count(sFilename.
Data())) {
3093 const clang::DirectoryLookup *CurDir = 0;
3094 clang::Preprocessor &PP =
fInterpreter->getCI()->getPreprocessor();
3095 clang::HeaderSearch &HS = PP.getHeaderSearchInfo();
3096 const clang::FileEntry *FE = HS.LookupFile(file_name.c_str(),
3097 clang::SourceLocation(),
3100 clang::ArrayRef<std::pair<
const clang::FileEntry *,
3101 const clang::DirectoryEntry *>>(),
3111 if (FE && FE->isValid()) {
3113 clang::SourceManager &SM =
fInterpreter->getCI()->getSourceManager();
3115 clang::FileID FID = SM.translateFile(FE);
3116 if (!FID.isInvalid() && FID.getHashValue() == 0)
3119 clang::SrcMgr::SLocEntry SLocE = SM.getSLocEntry(FID);
3120 if (SLocE.isFile() && SLocE.getFile().getContentCache()->getRawBuffer() == 0)
3122 if (!FID.isInvalid())
3126 sFilename = FE->getName();
3128 && fileMap.count(sFilename.
Data())) {
3136#if defined(R__MACOSX)
3144static bool R__UpdateLibFileForLinking(
TString &lib)
3146 const char *mapfile =
nullptr;
3148 mapfile =
"/System/Library/dyld/dyld_shared_cache_x86_64.map";
3150 mapfile =
"/System/Library/dyld/dyld_shared_cache_arm64e.map";
3152 #error unsupported architecture
3154 if (std::ifstream cacheMap{mapfile}) {
3156 while (getline(cacheMap,
line)) {
3157 if (
line.find(lib) != std::string::npos) {
3175static int callback_for_dl_iterate_phdr(
struct dl_phdr_info *info,
size_t size,
void *data)
3178 static std::unordered_set<
decltype(info->dlpi_addr)> sKnownLoadedLibBaseAddrs;
3180 auto newLibs =
static_cast<std::vector<std::string>*
>(data);
3181 if (!sKnownLoadedLibBaseAddrs.count(info->dlpi_addr)) {
3183 if (info->dlpi_name && info->dlpi_name[0]
3184 && strncmp(info->dlpi_name,
"linux-vdso.so", 13)
3185 && strncmp(info->dlpi_name,
"linux-gate.so", 13))
3186 newLibs->emplace_back(info->dlpi_name);
3187 sKnownLoadedLibBaseAddrs.insert(info->dlpi_addr);
3200#if defined(R__WIN32) || defined(__CYGWIN__)
3201 HMODULE hModules[1024];
3203 unsigned long cbModules;
3205 hProcess = (
void *)::GetCurrentProcess();
3206 ::EnumProcessModules(hProcess, hModules,
sizeof(hModules), &cbModules);
3208 for (i = 1; i < (cbModules /
sizeof(
void *)); i++) {
3209 static const int bufsize = 260;
3210 wchar_t winname[bufsize];
3211 char posixname[bufsize];
3212 ::GetModuleFileNameExW(hProcess, hModules[i], winname, bufsize);
3213#if defined(__CYGWIN__)
3214 cygwin_conv_path(CCP_WIN_W_TO_POSIX, winname, posixname, bufsize);
3216 std::wstring wpath = winname;
3217 std::replace(wpath.begin(), wpath.end(),
'\\',
'/');
3218 string path(wpath.begin(), wpath.end());
3219 strncpy(posixname, path.c_str(), bufsize);
3225#elif defined(R__MACOSX)
3229 while (
const mach_header* mh = _dyld_get_image_header(imageIndex)) {
3231 if (mh->filetype == MH_DYLIB) {
3232 if (
const char* imageName = _dyld_get_image_name(imageIndex)) {
3240#elif defined(R__LINUX)
3244 std::vector<std::string> newLibs;
3245 dl_iterate_phdr(callback_for_dl_iterate_phdr, &newLibs);
3246 for (
auto &&lib: newLibs)
3249 Error(
"TCling::UpdateListOfLoadedSharedLibraries",
3250 "Platform not supported!");
3261 if (!filename)
return;
3265 cling::DynamicLibraryManager* DLM =
fInterpreter->getDynamicLibraryManager();
3266 if (!DLM->isLibraryLoaded(filename)) {
3267 DLM->loadLibrary(filename,
true );
3270#if defined(R__MACOSX)
3272 auto lenFilename = strlen(filename);
3273 if (!strncmp(filename,
"/usr/lib/system/", 16)
3274 || !strncmp(filename,
"/usr/lib/libc++", 15)
3275 || !strncmp(filename,
"/System/Library/Frameworks/", 27)
3276 || !strncmp(filename,
"/System/Library/PrivateFrameworks/", 34)
3277 || !strncmp(filename,
"/System/Library/CoreServices/", 29)
3278 || !strcmp(filename,
"cl_kernels")
3279 || strstr(filename,
"/usr/lib/libSystem")
3280 || strstr(filename,
"/usr/lib/libstdc++")
3281 || strstr(filename,
"/usr/lib/libicucore")
3282 || strstr(filename,
"/usr/lib/libbsm")
3283 || strstr(filename,
"/usr/lib/libobjc")
3284 || strstr(filename,
"/usr/lib/libresolv")
3285 || strstr(filename,
"/usr/lib/libauto")
3286 || strstr(filename,
"/usr/lib/libcups")
3287 || strstr(filename,
"/usr/lib/libDiagnosticMessagesClient")
3288 || strstr(filename,
"/usr/lib/liblangid")
3289 || strstr(filename,
"/usr/lib/libCRFSuite")
3290 || strstr(filename,
"/usr/lib/libpam")
3291 || strstr(filename,
"/usr/lib/libOpenScriptingUtil")
3292 || strstr(filename,
"/usr/lib/libextension")
3293 || strstr(filename,
"/usr/lib/libAudioToolboxUtility")
3294 || strstr(filename,
"/usr/lib/liboah")
3295 || strstr(filename,
"/usr/lib/libRosetta")
3299 || (lenFilename > 4 && !strcmp(filename + lenFilename - 4,
".tbd")))
3302 R__UpdateLibFileForLinking(sFileName);
3303 filename = sFileName.
Data();
3304#elif defined(__CYGWIN__)
3306 static const int bufsize = 260;
3307 char posixwindir[bufsize];
3308 char *windir = getenv(
"WINDIR");
3310 cygwin_conv_path(CCP_WIN_A_TO_POSIX, windir, posixwindir, bufsize);
3312 snprintf(posixwindir,
sizeof(posixwindir),
"/Windows/");
3313 if (strstr(filename, posixwindir) ||
3314 strstr(filename,
"/usr/bin/cyg"))
3316#elif defined(R__WIN32)
3317 if (strstr(filename,
"/Windows/"))
3319#elif defined (R__LINUX)
3320 if (strstr(filename,
"/ld-linux")
3321 || strstr(filename,
"linux-gnu/")
3322 || strstr(filename,
"/libstdc++.")
3323 || strstr(filename,
"/libgcc")
3324 || strstr(filename,
"/libc.")
3325 || strstr(filename,
"/libdl.")
3326 || strstr(filename,
"/libm."))
3343 assert(!
IsFromRootCling() &&
"Trying to load library from rootcling!");
3347 cling::DynamicLibraryManager* DLM =
fInterpreter->getDynamicLibraryManager();
3348 std::string canonLib = DLM->lookupLibrary(filename);
3349 cling::DynamicLibraryManager::LoadLibResult res
3350 = cling::DynamicLibraryManager::kLoadLibNotFound;
3351 if (!canonLib.empty()) {
3353 res = DLM->loadLibrary(filename, system);
3357 cling::Interpreter::CompilationResult compRes;
3359 if (compRes == cling::Interpreter::kSuccess)
3360 res = cling::DynamicLibraryManager::kLoadLibSuccess;
3364 if (res == cling::DynamicLibraryManager::kLoadLibSuccess) {
3368 case cling::DynamicLibraryManager::kLoadLibSuccess:
return 0;
3369 case cling::DynamicLibraryManager::kLoadLibAlreadyLoaded:
return 1;
3419 Warning(
"Calc",
"waiting for cling thread to free");
3422 gROOT->SetLineIsProcessing();
3430 cling::Interpreter::CompilationResult cr =
fInterpreter->evaluate(
line, valRef);
3431 if (cr != cling::Interpreter::kSuccess) {
3439 if (!valRef.isValid()) {
3448 if (valRef.isVoid()) {
3455 gROOT->SetLineHasBeenProcessed();
3458 return valRef.simplisticCastAs<
long>();
3465 void (*histaddFunc)(
const char*
line))
3470#if defined(R__MUST_REVISIT)
3471#if R__MUST_REVISIT(6,2)
3472 Warning(
"SetGetline",
"Cling should support the equivalent of SetGetlineFunc(getlineFunc, histaddFunc)");
3485 if ((std::distance(
T.decls_begin(),
T.decls_end()) != 1)
3486 ||
T.deserialized_decls_begin() !=
T.deserialized_decls_end()
3487 ||
T.macros_begin() !=
T.macros_end()
3488 || ((!
T.getFirstDecl().isNull()) && ((*
T.getFirstDecl().begin()) !=
T.getWrapperFD()))) {
3511 std::set<TObject*>::iterator iSpecial = ((std::set<TObject*>*)
fgSetOfSpecials)->find(obj);
3529#if defined(R__MUST_REVISIT)
3530#if R__MUST_REVISIT(6,2)
3532 Warning(
"Reset",
"Cling should support the equivalent of scratch_upto(&fDictPos)");
3542#if defined(R__MUST_REVISIT)
3543#if R__MUST_REVISIT(6,2)
3545 Warning(
"ResetAll",
"Cling should support the equivalent of complete reset (unload everything but the startup decls.");
3572#if defined(R__MUST_REVISIT)
3573#if R__MUST_REVISIT(6,2)
3575 Warning(
"ResetGlobalVar",
"Cling should support the equivalent of resetglobalvar(obj)");
3587#if defined(R__MUST_REVISIT)
3588#if R__MUST_REVISIT(6,2)
3590 Warning(
"RewindDictionary",
"Cling should provide a way to revert transaction similar to rewinddictionary()");
3601#if defined(R__MUST_REVISIT)
3602#if R__MUST_REVISIT(6,2)
3604 Warning(
"DeleteGlobal",
"Cling should provide the equivalent of deleteglobal(obj), see also DeleteVariable.");
3616#if defined(R__MUST_REVISIT)
3617#if R__MUST_REVISIT(6,2)
3618 Warning(
"DeleteVariable",
"should do more that just reseting the value to zero");
3623 llvm::StringRef srName(
name);
3624 const char* unscopedName =
name;
3625 llvm::StringRef::size_type posScope = srName.rfind(
"::");
3626 const clang::DeclContext* declCtx = 0;
3627 if (posScope != llvm::StringRef::npos) {
3628 const cling::LookupHelper& lh =
fInterpreter->getLookupHelper();
3629 const clang::Decl* scopeDecl
3630 = lh.findScope(srName.substr(0, posScope),
3631 cling::LookupHelper::WithDiagnostics);
3633 Error(
"DeleteVariable",
"Cannot find enclosing scope for variable %s",
3637 declCtx = llvm::dyn_cast<clang::DeclContext>(scopeDecl);
3639 Error(
"DeleteVariable",
3640 "Enclosing scope for variable %s is not a declaration context",
3644 unscopedName += posScope + 2;
3648 clang::NamedDecl* nVarDecl
3649 = cling::utils::Lookup::Named(&
fInterpreter->getSema(), unscopedName, declCtx);
3651 Error(
"DeleteVariable",
"Unknown variable %s",
name);
3654 clang::VarDecl* varDecl = llvm::dyn_cast<clang::VarDecl>(nVarDecl);
3656 Error(
"DeleteVariable",
"Entity %s is not a variable",
name);
3660 clang::QualType qType = varDecl->getType();
3664 if (
type->isPointerType()) {
3665 int** ppInt = (
int**)
fInterpreter->getAddressOfGlobal(GlobalDecl(varDecl));
3667 if (ppInt) *ppInt = 0;
3677#if defined(R__MUST_REVISIT)
3678#if R__MUST_REVISIT(6,2)
3680 Warning(
"SaveContext",
"Cling should provide a way to record a state watermark similar to store_dictposition(&fDictPos)");
3690#if defined(R__MUST_REVISIT)
3691#if R__MUST_REVISIT(6,2)
3693 Warning(
"SaveGlobalsContext",
"Cling should provide a way to record a watermark for the list of global variable similar to store_dictposition(&fDictPosGlobals)");
3727struct AlternateTupleIntDoubleAsc
3733struct AlternateTupleIntDoubleDes
3741 std::tuple<int,double> value;
3742 AlternateTupleIntDoubleAsc asc;
3743 AlternateTupleIntDoubleDes des;
3745 size_t offset0 = ((
char*)&(std::get<0>(value))) - ((
char*)&value);
3746 size_t offset1 = ((
char*)&(std::get<1>(value))) - ((
char*)&value);
3748 size_t ascOffset0 = ((
char*)&(asc._0)) - ((
char*)&asc);
3749 size_t ascOffset1 = ((
char*)&(asc._1)) - ((
char*)&asc);
3751 size_t desOffset0 = ((
char*)&(des._0)) - ((
char*)&des);
3752 size_t desOffset1 = ((
char*)&(des._1)) - ((
char*)&des);
3754 if (offset0 == ascOffset0 && offset1 == ascOffset1) {
3756 }
else if (offset0 == desOffset0 && offset1 == desOffset1) {
3763static std::string
AlternateTuple(
const char *classname,
const cling::LookupHelper& lh)
3766 std::string alternateName =
"TEmulatedTuple";
3767 alternateName.append( classname + 5 );
3769 std::string fullname =
"ROOT::Internal::" + alternateName;
3770 if (lh.findScope(fullname, cling::LookupHelper::NoDiagnostics,
3774 std::string guard_name;
3776 std::ostringstream guard;
3777 guard <<
"ROOT_INTERNAL_TEmulated_";
3778 guard << guard_name;
3780 std::ostringstream alternateTuple;
3781 alternateTuple <<
"#ifndef " << guard.str() <<
"\n";
3782 alternateTuple <<
"#define " << guard.str() <<
"\n";
3783 alternateTuple <<
"namespace ROOT { namespace Internal {\n";
3784 alternateTuple <<
"template <class... Types> struct TEmulatedTuple;\n";
3785 alternateTuple <<
"template <> struct " << alternateName <<
" {\n";
3790 unsigned int nMember = 0;
3791 auto iter = tupleContent.
fElements.begin() + 1;
3792 auto theEnd = tupleContent.
fElements.end() - 1;
3793 while (iter != theEnd) {
3794 alternateTuple <<
" " << *iter <<
" _" << nMember <<
";\n";
3801 unsigned int nMember = tupleContent.
fElements.size() - 3;
3802 auto iter = tupleContent.
fElements.rbegin() + 1;
3803 auto theEnd = tupleContent.
fElements.rend() - 1;
3804 while (iter != theEnd) {
3805 alternateTuple <<
" " << *iter <<
" _" << nMember <<
";\n";
3812 Fatal(
"TCling::SetClassInfo::AlternateTuple",
3813 "Layout of std::tuple on this platform is unexpected.");
3818 alternateTuple <<
"};\n";
3819 alternateTuple <<
"}}\n";
3820 alternateTuple <<
"#endif\n";
3822 Error(
"Load",
"Could not declare %s",alternateName.c_str());
3825 alternateName =
"ROOT::Internal::" + alternateName;
3826 return alternateName;
3869 if (strncmp(cl->
GetName(),
"tuple<",strlen(
"tuple<"))==0) {
3905 zombieCandidate =
kTRUE;
3912 zombieCandidate =
kTRUE;
3966 static const char *anonEnum =
"anonymous enum ";
3967 static const int cmplen = strlen(anonEnum);
3994 const char *classname =
name;
3997 class MaybeSuspendAutoLoadParse {
3998 int fStoreAutoLoad = 0;
3999 int fStoreAutoParse = 0;
4000 bool fSuspendedAutoParse =
false;
4002 MaybeSuspendAutoLoadParse(
int autoload) {
4003 fStoreAutoLoad = ((
TCling*)
gCling)->SetClassAutoLoading(autoload);
4007 fSuspendedAutoParse =
true;
4008 fStoreAutoParse = ((
TCling*)
gCling)->SetSuspendAutoParsing(
true);
4011 ~MaybeSuspendAutoLoadParse() {
4012 if (fSuspendedAutoParse)
4013 ((
TCling*)
gCling)->SetSuspendAutoParsing(fStoreAutoParse);
4014 ((
TCling*)
gCling)->SetClassAutoLoading(fStoreAutoLoad);
4018 MaybeSuspendAutoLoadParse autoLoadParseRAII( autoload );
4020 autoLoadParseRAII.SuspendAutoParsing();
4029 const cling::LookupHelper& lh =
fInterpreter->getLookupHelper();
4031 const clang::Decl *decl
4032 = lh.findScope(classname,
4033 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4034 : cling::LookupHelper::NoDiagnostics,
4038 decl = lh.findScope(buf,
4039 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4040 : cling::LookupHelper::NoDiagnostics,
4057 clang::ClassTemplateSpecializationDecl *tmpltDecl =
4058 llvm::dyn_cast_or_null<clang::ClassTemplateSpecializationDecl>
4059 (
type->getAsCXXRecordDecl());
4060 if (tmpltDecl && !tmpltDecl->getPointOfInstantiation().isValid()) {
4077 if (tci.
Property() & propertiesMask) {
4078 bool hasClassDefInline =
false;
4079 if (isClassOrNamespaceOnly) {
4085 if (hasDictionary.IsValid() && implLineFunc.IsValid()) {
4087 bool success =
false;
4088 std::tie(success, lineNumber) =
4090 hasClassDefInline = success && (lineNumber == -1);
4098 if (hasClassDefInline)
4137 const cling::LookupHelper& lh =
fInterpreter->getLookupHelper();
4138 const clang::Decl *decl
4139 = lh.findClassTemplate(
name,
4140 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4141 : cling::LookupHelper::NoDiagnostics);
4143 std::string strname =
"std::";
4145 decl = lh.findClassTemplate(strname,
4146 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4147 : cling::LookupHelper::NoDiagnostics);
4173 cl->
fBase = listOfBase;
4189 D =
fInterpreter->getCI()->getASTContext().getTranslationUnitDecl();
4192 if (
const clang::DeclContext* DC = dyn_cast<clang::DeclContext>(D)) {
4195 llvm::SmallVector< DeclContext *, 4> allDeclContexts;
4196 const_cast< clang::DeclContext *
>(DC)->collectAllContexts(allDeclContexts);
4197 for (llvm::SmallVector<DeclContext*, 4>::iterator declIter = allDeclContexts.begin(), declEnd = allDeclContexts.end();
4198 declIter != declEnd; ++declIter) {
4200 for (clang::DeclContext::decl_iterator DI = (*declIter)->decls_begin(),
4201 DE = (*declIter)->decls_end(); DI != DE; ++DI) {
4202 if (
const clang::EnumDecl* ED = dyn_cast<clang::EnumDecl>(*DI)) {
4205 PrintingPolicy Policy(ED->getASTContext().getPrintingPolicy());
4206 llvm::raw_string_ostream stream(buf);
4208 Policy.AnonymousTagLocations =
false;
4209 ED->getNameForDiagnostic(stream, Policy,
false);
4213 const char*
name = buf.c_str();
4237 D =
fInterpreter->getCI()->getASTContext().getTranslationUnitDecl();
4241 if (
const clang::DeclContext* DC = dyn_cast<clang::DeclContext>(D)) {
4244 llvm::SmallVector< DeclContext *, 4> allDeclContexts;
4245 const_cast< clang::DeclContext *
>(DC)->collectAllContexts(allDeclContexts);
4246 for (llvm::SmallVector<DeclContext*, 4>::iterator declIter = allDeclContexts.begin(),
4247 declEnd = allDeclContexts.end(); declIter != declEnd; ++declIter) {
4249 for (clang::DeclContext::decl_iterator DI = (*declIter)->decls_begin(),
4250 DE = (*declIter)->decls_end(); DI != DE; ++DI) {
4251 if (
const clang::FunctionTemplateDecl* FTD = dyn_cast<clang::FunctionTemplateDecl>(*DI)) {
4252 funcTempList->
Get(FTD);
4310 if (
m->fMethodArgs) {
4321 m->fMethodArgs = arglist;
4361 if (llvm::isa<clang::NamespaceDecl>(cli->
GetDecl())) {
4370 Error(
"GenerateTClass",
4371 "Cannot find %s::Class_Version()! Class version might be wrong.",
4378 if (newvers == -1) {
4386 newvers = callfunc.
ExecInt(0);
4388 Error(
"GenerateTClass",
4389 "Cannot invoke %s::Class_Version()! Class version might be wrong.",
4393 if (newvers != oldvers) {
4410static void GenerateTClass_GatherInnerIncludes(cling::Interpreter *interp,
TString &includes,
TClingClassInfo *info)
4414 const clang::ClassTemplateSpecializationDecl *templateCl
4415 = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(info->
GetDecl());
4417 for(
unsigned int i=0; i < templateCl->getTemplateArgs().size(); ++i) {
4418 const clang::TemplateArgument &arg( templateCl->getTemplateArgs().get(i) );
4422 if (!uType->isFundamentalType() && !uType->isEnumeralType()) {
4424 const clang::CXXRecordDecl *argdecl = uType->getAsCXXRecordDecl();
4427 TClingClassInfo subinfo(interp,*(argdecl->getASTContext().getRecordType(argdecl).getTypePtr()));
4428 GenerateTClass_GatherInnerIncludes(interp, includes, &subinfo);
4431 llvm::raw_string_ostream OS(Result);
4432 arg.print(argdecl->getASTContext().getPrintingPolicy(),OS);
4433 Warning(
"TCling::GenerateTClass",
"Missing header file for %s",OS.str().c_str());
4448 if (!info || !info->
IsValid()) {
4449 Fatal(
"GenerateTClass",
"Requires a valid ClassInfo object");
4454 std::string classname;
4458 Info(
"GenerateTClass",
"Will (try to) generate the compiled TClass for %s.",classname.c_str());
4462 GenerateTClass_GatherInnerIncludes(
fInterpreter,includes,info);
4468 Error(
"GenerateTClass",
"Even though the dictionary generation for %s seemed successful we can't find the TClass bootstrap!",classname.c_str());
4474 cl =
new TClass(classinfo, version, 0, 0, -1, -1, silent);
4480 cl =
new TClass(classinfo, 1, 0, 0, -1, -1, silent);
4505 if (classes == 0 || classes[0] == 0) {
4506 Error(
"TCling::GenerateDictionary",
"Cannot generate dictionary without passing classes.");
4510 std::vector<std::string> listClasses;
4512 const char* current = classes, *prev = classes;
4516 if (*current ==
';') {
4517 listClasses.push_back(std::string(prev, current - prev));
4520 else if (*(current + 1) == 0) {
4521 listClasses.push_back(std::string(prev, current + 1 - prev));
4525 std::vector<std::string> listIncludes;
4529 const char* current = includes, *prev = includes;
4533 if (*current ==
';') {
4534 listIncludes.push_back(std::string(prev, current - prev));
4537 else if (*(current + 1) == 0) {
4538 listIncludes.push_back(std::string(prev, current + 1 - prev));
4544 std::vector<std::string>(), std::vector<std::string>());
4565 if (
const ValueDecl* decl = (
const ValueDecl*)
d){
4568 if (hasIoName && ioName !=
name)
return 0;
4580 using namespace clang;
4582 DeclarationName DName = &SemaR.Context.Idents.get(
name);
4584 LookupResult
R(SemaR, DName, SourceLocation(), Sema::LookupOrdinaryName,
4585 Sema::ForRedeclaration);
4589 cling::utils::Lookup::Named(&SemaR,
R);
4593 while (
F.hasNext()) {
4594 NamedDecl *D =
F.next();
4595 if (isa<VarDecl>(D) || isa<FieldDecl>(D) || isa<EnumConstantDecl>(D) ||
4596 isa<IndirectFieldDecl>(D))
4602 if (
R.isSingleResult())
4603 return R.getFoundDecl();
4615 const clang::Decl* possibleEnum = 0;
4620 const clang::DeclContext* dc = 0;
4621 if (
const clang::Decl* D = cci->
GetDecl()) {
4622 if (!(dc = dyn_cast<clang::NamespaceDecl>(D))) {
4623 dc = dyn_cast<clang::RecordDecl>(D);
4630 possibleEnum = cling::utils::Lookup::Tag(&
fInterpreter->getSema(),
name, dc);
4632 Error(
"TCling::GetEnum",
"DeclContext not found for %s .\n",
name);
4641 if (possibleEnum && (possibleEnum != (clang::Decl*)-1)
4642 && isa<clang::EnumDecl>(possibleEnum)) {
4643 return possibleEnum;
4655 llvm::StringRef mangled_name = gv->getName();
4670 std::string scopename(demangled_name_c);
4671 free(demangled_name_c);
4677 std::string dataname;
4679 if (!strncmp(scopename.c_str(),
"typeinfo for ",
sizeof(
"typeinfo for ")-1)) {
4680 scopename.erase(0,
sizeof(
"typeinfo for ")-1);
4681 }
else if (!strncmp(scopename.c_str(),
"vtable for ",
sizeof(
"vtable for ")-1)) {
4682 scopename.erase(0,
sizeof(
"vtable for ")-1);
4685 std::string::size_type pos = scopename.rfind(
'(');
4686 if (pos != std::string::npos) {
4690 pos = scopename.rfind(
':');
4691 if (pos != std::string::npos) {
4692 if ((pos != 0) && (scopename[pos-1] ==
':')) {
4693 dataname = scopename.substr(pos+1);
4694 scopename.erase(pos-1);
4698 dataname = scopename;
4706 if (scopename.size()) {
4722 Error(
"GetDataMemberWithValue()",
"not implemented");
4732 Error(
"GetDataMemberAtAddr()",
"not implemented");
4742 const char* params,
Bool_t objectIsConst )
4754 func.
SetFunc(&gcl, method, params, &offset);
4760 return mangled_name;
4775 GetMethod(method,
proto, objectIsConst, 0 , mode).GetMangledName();
4787 const char* params,
Bool_t objectIsConst )
4799 func.
SetFunc(&gcl, method, params, &offset);
4828 std::vector<DeclId_t>& res)
const
4831 clang::ASTContext& Ctx =
S.Context;
4832 const clang::Decl* CtxDecl
4834 Ctx.getTranslationUnitDecl();
4835 auto RecDecl = llvm::dyn_cast<const clang::RecordDecl>(CtxDecl);
4836 const clang::DeclContext* DeclCtx = RecDecl;
4839 DeclCtx = dyn_cast<clang::NamespaceDecl>(CtxDecl);
4840 if (!DeclCtx)
return;
4842 clang::DeclarationName DName;
4847 if (RecDecl->getNameAsString() == funcname) {
4848 clang::QualType QT = Ctx.getTypeDeclType(RecDecl);
4849 DName = Ctx.DeclarationNames.getCXXConstructorName(Ctx.getCanonicalType(QT));
4850 }
else if (funcname[0] ==
'~' && RecDecl->getNameAsString() == funcname + 1) {
4851 clang::QualType QT = Ctx.getTypeDeclType(RecDecl);
4852 DName = Ctx.DeclarationNames.getCXXDestructorName(Ctx.getCanonicalType(QT));
4854 DName = &Ctx.Idents.get(funcname);
4857 DName = &Ctx.Idents.get(funcname);
4861 clang::LookupResult
R(
S, DName, clang::SourceLocation(),
4862 Sema::LookupOrdinaryName, clang::Sema::NotForRedeclaration);
4863 R.suppressDiagnostics();
4864 S.LookupQualifiedName(
R,
const_cast<DeclContext*
>(DeclCtx));
4865 if (
R.empty())
return;
4867 res.reserve(res.size() + (
R.end() -
R.begin()));
4868 for (clang::LookupResult::iterator IR =
R.begin(), ER =
R.end();
4870 if (
const clang::FunctionDecl* FD
4871 = llvm::dyn_cast<const clang::FunctionDecl>(*IR)) {
4872 if (!FD->getDescribedFunctionTemplate()) {
4875 }
else if (
const auto *USD = llvm::dyn_cast<const clang::UsingShadowDecl>(*IR)) {
4877 if (llvm::isa<clang::FunctionDecl>(USD->getTargetDecl())) {
5037 const char* params,
Bool_t objectIsConst,
int* error)
5050 void* address = (
void*)((
Long_t)addr + offset);
5057 const char* params,
int* error)
5059 Execute(obj,cl,method,params,
false,error);
5074 Error(
"Execute",
"No method was defined");
5083 if (argc > nparms) {
5084 Error(
"Execute",
"Too many parameters to call %s, got %d but expected at most %d.",method->
GetName(),argc,nparms);
5087 if (nparms != argc) {
5097 Int_t firstDefault = -1;
5098 for (
Int_t i = 0; i < nparms; i ++) {
5105 if (firstDefault >= 0) {
5106 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);
5108 Error(
"Execute",
"Too few arguments to call %s, got only %d but expected %d.",method->
GetName(),argc,nparms);
5114 const char* listpar =
"";
5119 for (
Int_t i = 0; i < argc; i ++) {
5135 complete += nxtpar->
String();
5138 listpar = complete.
Data();
5158 void* address = (
void*)((
Long_t)addr + offset);
5165 const void* args[] ,
5170 Error(
"ExecuteWithArgsAndReturn",
"No method was defined");
5197 Warning(
"GetTopLevelMacroName",
"Must change return type!");
5244#if defined(R__MUST_REVISIT)
5245#if R__MUST_REVISIT(6,0)
5246 Warning(
"GetCurrentMacroName",
"Must change return type!");
5259 TTHREAD_TLS(
char*) t = 0;
5260 TTHREAD_TLS(
unsigned int) tlen = 0;
5262 unsigned int dlen = strlen(typeDesc);
5265 t =
new char[dlen + 1];
5268 const char*
s, *template_start;
5269 if (!strstr(typeDesc,
"(*)(")) {
5270 s = strchr(typeDesc,
' ');
5271 template_start = strchr(typeDesc,
'<');
5272 if (!strcmp(typeDesc,
"long long")) {
5273 strlcpy(t, typeDesc, dlen + 1);
5275 else if (!strncmp(typeDesc,
"unsigned ",
s + 1 - typeDesc)) {
5276 strlcpy(t, typeDesc, dlen + 1);
5282 else if (
s && (template_start == 0 || (
s < template_start))) {
5283 strlcpy(t,
s + 1, dlen + 1);
5286 strlcpy(t, typeDesc, dlen + 1);
5290 strlcpy(t, typeDesc, dlen + 1);
5293 while (
l > 0 && (t[
l - 1] ==
'*' || t[
l - 1] ==
'&')) {
5301 assert(rootmapfile && *rootmapfile);
5303 llvm::StringRef libName = llvm::sys::path::filename(rootmapfile);
5304 libName.consume_back(
".rootmap");
5306 return !
gInterpreter->HasPCMForLibrary(libName.str().c_str());
5317 if (!(rootmapfile && *rootmapfile))
5324 const std::map<char, unsigned int> keyLenMap = {{
'c',6},{
'n',10},{
't',8},{
'h',7},{
'e',5},{
'v',4}};
5326 std::string rootmapfileNoBackslash(rootmapfile);
5328 std::replace(rootmapfileNoBackslash.begin(), rootmapfileNoBackslash.end(),
'\\',
'/');
5335 uniqueString->
Append(std::string(
"\n#line 1 \"Forward declarations from ") + rootmapfileNoBackslash +
"\"\n");
5337 std::ifstream
file(rootmapfileNoBackslash);
5340 std::string lib_name;
5342 bool newFormat =
false;
5343 while (getline(
file,
line,
'\n')) {
5344 if (!newFormat && (
line.compare(0, 8,
"Library.") == 0 ||
line.compare(0, 8,
"Declare.") == 0)) {
5350 if (
line.compare(0, 9,
"{ decls }") == 0) {
5353 while (getline(
file,
line,
'\n')) {
5356 if (!uniqueString) {
5357 Error(
"ReadRootmapFile",
"Cannot handle \"{ decls }\" sections in custom rootmap file %s",
5358 rootmapfileNoBackslash.c_str());
5364 const char firstChar =
line[0];
5365 if (firstChar ==
'[') {
5367 auto brpos =
line.find(
']');
5368 if (brpos == string::npos)
5370 lib_name =
line.substr(1, brpos - 1);
5372 while (lib_name[nspaces] ==
' ')
5375 lib_name.replace(0, nspaces,
"");
5377 TString lib_nameTstr(lib_name.c_str());
5382 Info(
"ReadRootmapFile",
"new section for %s", lib_nameTstr.
Data());
5384 Info(
"ReadRootmapFile",
"section for %s (library does not exist)", lib_nameTstr.
Data());
5390 auto keyLenIt = keyLenMap.find(firstChar);
5391 if (keyLenIt == keyLenMap.end())
5393 unsigned int keyLen = keyLenIt->second;
5395 const char *keyname =
line.c_str() + keyLen;
5397 Info(
"ReadRootmapFile",
"class %s in %s", keyname, lib_name.c_str());
5400 if (lib_name != isThere->
GetValue()) {
5401 if (firstChar ==
'n') {
5403 Info(
"ReadRootmapFile",
"namespace %s found in %s is already in %s", keyname, lib_name.c_str(),
5405 }
else if (firstChar ==
'h') {
5410 Warning(
"ReadRootmapFile",
"%s %s found in %s is already in %s",
line.substr(0, keyLen).c_str(),
5411 keyname, lib_name.c_str(), isThere->
GetValue());
5415 Info(
"ReadRootmapFile",
"Key %s was already defined for %s", keyname, lib_name.c_str());
5476 using namespace clang;
5478 class ExtVisibleStorageAdder:
public RecursiveASTVisitor<ExtVisibleStorageAdder>{
5484 ExtVisibleStorageAdder(std::unordered_set<const NamespaceDecl*>& nsSet): fNSSet(nsSet) {};
5485 bool VisitNamespaceDecl(NamespaceDecl* nsDecl) {
5490 nsDecl->setHasExternalVisibleStorage();
5491 fNSSet.insert(nsDecl);
5495 std::unordered_set<const NamespaceDecl*>& fNSSet;