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 <CppInterOp/CppInterOp.h>
120#include "llvm/IR/GlobalValue.h"
121#include "llvm/IR/Module.h"
123#include "llvm/Support/DynamicLibrary.h"
124#include "llvm/Support/raw_ostream.h"
125#include "llvm/Support/Path.h"
126#include "llvm/Support/Process.h"
127#include "llvm/Object/ELFObjectFile.h"
128#include "llvm/Object/ObjectFile.h"
129#include "llvm/Object/SymbolicFile.h"
130#include "llvm/Support/FileSystem.h"
144#include <unordered_map>
145#include <unordered_set>
153#define R__DLLEXPORT __attribute__ ((visibility ("default")))
161#include <mach-o/dyld.h>
162#include <mach-o/loader.h>
169#if defined(R__LINUX) || defined(R__FBSD)
176#if defined(__CYGWIN__)
177#include <sys/cygwin.h>
178#define HMODULE void *
189# define STDIN_FILENO 0
192# define STDOUT_FILENO 1
195# define STDERR_FILENO 2
205#undef GetModuleFileName
206#define RTLD_DEFAULT ((void *)::GetModuleHandle(NULL))
207#define dlsym(library, function_name) ::GetProcAddress((HMODULE)library, function_name)
208#define dlopen(library_name, flags) ::LoadLibraryA(library_name)
209#define dlclose(library) ::FreeLibrary((HMODULE)library)
210#define R__DLLEXPORT __declspec(dllexport)
218 return D->getDeclContext();
221 return llvm::dyn_cast<clang::NamespaceDecl>(
DC);
224 return llvm::dyn_cast<clang::RecordDecl>(
DC);
227 return DC->dumpDeclContext();
236 return ((clang::Decl*)D)->dump();
239 if (clang::NamedDecl*
ND = llvm::dyn_cast<clang::NamedDecl>(D)) {
242 llvm::raw_string_ostream
OS(
name);
243 ND->getNameForDiagnostic(
OS, D->getASTContext().getPrintingPolicy(),
254 return D->isInvalidDecl();
259 return info->GetDecl()->isInvalidDecl();
262using std::string, std::vector;
263using namespace clang;
269#define ClassDef(name, id) \
270_ClassDefInterp_(name,id,virtual,) \
271static int DeclFileLine() { return __LINE__; }
273#define ClassDefNV(name, id) \
274_ClassDefInterp_(name,id,,) \
275static int DeclFileLine() { return __LINE__; }
276#undef ClassDefOverride
277#define ClassDefOverride(name, id) \
278_ClassDefInterp_(name,id,,override) \
279static int DeclFileLine() { return __LINE__; }
283#define __ROOTCLING__ 1
285#define ClassDef(name,id) \
286_ClassDefOutline_(name,id,virtual,) \
287static int DeclFileLine() { return __LINE__; }
289#define ClassDefNV(name, id)\
290_ClassDefOutline_(name,id,,)\
291static int DeclFileLine() { return __LINE__; }
292#undef ClassDefOverride
293#define ClassDefOverride(name, id)\
294_ClassDefOutline_(name,id,,override)\
295static int DeclFileLine() { return __LINE__; }
302#define _ClassDefInterp_(name,id,virtual_keyword, overrd) \
305 static TClass *Class() { static TClass* sIsA = 0; if (!sIsA) sIsA = TClass::GetClass(#name); return sIsA; } \
306 static const char *Class_Name() { return #name; } \
307 virtual_keyword Bool_t CheckTObjectHashConsistency() const overrd { \
308 static std::atomic<UChar_t> recurseBlocker(0); \
309 if (R__likely(recurseBlocker >= 2)) { \
310 return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; \
311 } else if (recurseBlocker == 1) { \
313 } else if (recurseBlocker++ == 0) { \
314 ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency = \
315 ::ROOT::Internal::HasConsistentHashMember(_QUOTE_(name)) || \
316 ::ROOT::Internal::HasConsistentHashMember(*IsA()); \
318 return ::ROOT::Internal::THashConsistencyHolder<decltype(*this)>::fgHashConsistency; \
320 return false; /* unreachable */ \
322 static Version_t Class_Version() { return id; } \
323 static TClass *Dictionary() { return 0; } \
324 virtual_keyword TClass *IsA() const overrd { return name::Class(); } \
325 virtual_keyword void ShowMembers(TMemberInspector&insp) const overrd { ::ROOT::Class_ShowMembers(name::Class(), this, insp); } \
326 virtual_keyword void Streamer(TBuffer&) overrd { ::Error("Streamer", "Cannot stream interpreted class."); } \
327 void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { name::Streamer(ClassDef_StreamerNVirtual_b); } \
328 static const char *DeclFileName() { return __FILE__; } \
329 static int ImplFileLine() { return 0; } \
330 static const char *ImplFileName() { return __FILE__; }
438 const clang::Decl* D =
static_cast<const clang::Decl*
>(
enumObj->GetDeclId());
441 for (EnumDecl::enumerator_iterator
EDI =
ED->enumerator_begin(),
445 if (
const NamedDecl* END = llvm::dyn_cast<NamedDecl>(*
EDI)) {
446 PrintingPolicy Policy((*EDI)->getASTContext().getPrintingPolicy());
447 llvm::raw_string_ostream stream(
constbuf);
449 Policy.AnonymousTagLocations =
false;
456 const llvm::APSInt
valAPSInt = (*EDI)->getInitVal();
491 const clang::Decl* D =
static_cast<const clang::Decl*
>(
VD);
493 if (
const EnumDecl*
ED = llvm::dyn_cast<EnumDecl>(D)) {
496 llvm::raw_string_ostream stream(buf);
498 Policy.AnonymousTagLocations =
false;
499 ED->getNameForDiagnostic(stream, Policy,
false);
505 const char*
name = buf.c_str();
516 const clang::Decl* D =
static_cast<const clang::Decl*
>(
DV);
527 if (
RD->getDescribedClassTemplate())
530 if (
FD->getDescribedFunctionTemplate())
535 if (
TD->isCanonicalDecl() ||
TD->isThisDeclarationADefinition())
562 if (
gROOT->GetListOfGlobals()->FindObject(
ND->getNameAsString().c_str()))
662 string file(fileName);
668 string &args,
string &
io,
string &
fname)
670 string file(fileName);
685 void * (*
pAlloc )(
size_t),
void (*
pFree )(
void *),
686 unsigned short int flags);
698 using namespace clang;
716 const std::vector<std::string> &
headers,
717 const std::vector<std::string> &
fwdDecls,
718 const std::vector<std::string> &
unknown)
724 if (classes.empty()) {
728 const std::string& className = classes[0];
730 TString fileName =
"AutoDict_";
731 std::string::const_iterator
sIt;
732 for (
sIt = className.begin();
sIt != className.end(); ++
sIt) {
733 if (*
sIt ==
'<' || *
sIt ==
'>' ||
734 *
sIt ==
' ' || *
sIt ==
'*' ||
735 *
sIt ==
',' || *
sIt ==
'&' ||
743 if (classes.size() > 1) {
745 std::vector<std::string>::const_iterator it = classes.begin();
746 while ((++it) != classes.end()) {
761 static const std::set<std::string>
sSTLTypes {
762 "vector",
"list",
"forward_list",
"deque",
"map",
"unordered_map",
"multimap",
763 "unordered_multimap",
"set",
"unordered_set",
"multiset",
"unordered_multiset",
764 "queue",
"priority_queue",
"stack",
"iterator"};
765 std::vector<std::string>::const_iterator it;
789 fileContent +=
"#pragma link C++ nestedclasses;\n";
790 fileContent +=
"#pragma link C++ nestedtypedefs;\n";
791 for (it = classes.begin(); it != classes.end(); ++it) {
797 if (
n.compare(0, 5,
"std::") == 0) {
807 fileContent +=
"#pragma link C++ class " + *it +
"::*+;\n" ;
837 const std::vector<std::string> &
headers,
838 const std::vector<std::string> &
fwdDecls,
839 const std::vector<std::string> &
unknown)
845 std::vector<std::string> classes;
846 classes.push_back(className);
877 throw std::runtime_error(std::string(
">>> Interpreter compilation error:\n") +
reason);
891 class clangDiagSuppr {
893 clangDiagSuppr(clang::DiagnosticsEngine&
diag): fDiagEngine(
diag){
894 fOldDiagValue = fDiagEngine.getIgnoreAllWarnings();
895 fDiagEngine.setIgnoreAllWarnings(
true);
899 fDiagEngine.setIgnoreAllWarnings(fOldDiagValue);
902 clang::DiagnosticsEngine& fDiagEngine;
928 unsigned long end =
tname.length();
929 while( end && (
tname[end-1]==
'&' ||
tname[end-1]==
'*' ||
tname[end-1]==
']') ) {
930 if (
tname[end-1]==
']' ) {
932 while ( end &&
tname[end-1]!=
'[' ) --end;
938 if (end !=
tname.length()) {
946 if (
gROOT->GetListOfClasses()->FindObject(
inner)
967 if ( end !=
tname.length() ) {
1042 return fContent.c_str();
1050 bool notPresent = fLinesHashSet.emplace(fHashFunc(str)).second;
1077 ::Info(
"TCling::__LoadModule",
"Preloading module %s. \n",
1104 if (!
HSOpts.PrebuiltModulePaths.empty())
1106 ModuleFileName =
PP.getHeaderSearchInfo().getPrebuiltModuleFileName(M->Name);
1136 for (ModuleMap::module_iterator
I =
MMap.module_begin(), E =
MMap.module_end();
I != E; ++
I) {
1146 clang::GlobalModuleIndex::UserDefinedInterestingIDs
IDs;
1154 if (!
ND->isFromASTFile())
1156 if (!
ND->getIdentifier())
1163 if (
TD->isCompleteDefinition())
1166 Register(
NSD,
false);
1174 clang::GlobalModuleIndex::UserDefinedInterestingIDs &
DefinitionIDs;
1179 if (!
ND->hasOwningModule()) {
1185 assert(
FE->getName().contains(
"input_line_"));
1190 Module *
OwningModule =
ND->getOwningModule()->getTopLevelModule();
1192 assert(!
ND->getName().empty() &&
"Empty name");
1204 llvm::cantFail(GlobalModuleIndex::writeIndex(
CI.getFileManager(),
1205 CI.getPCHContainerReader(),
1245 std::vector<std::string>
CoreModules = {
"ROOT_Foundation_C",
1248 "ROOT_Foundation_Stage1_NoRTTI",
1265 clang::Preprocessor &
PP =
CI.getPreprocessor();
1267 if (
MMap.findModule(
"RInterface"))
1284 for (
auto I =
MMap.module_begin(), E =
MMap.module_end();
I != E; ++
I) {
1285 clang::Module *M =
I->second;
1296 if (M->IsUnimportable)
1350 "#define ClassImp(X);\n";
1382#ifdef R__USE_CXXMODULES
1392 for (
const char*
const* arg =
argv; *arg; ++arg)
1443 std::optional<std::string>
EnvOpt = llvm::sys::Process::GetEnv(
"EXTRA_CLING_ARGS");
1444 if (
EnvOpt.has_value()) {
1446 while (!
Env.empty()) {
1448 std::tie(Arg,
Env) =
Env.split(
' ');
1454 std::optional<std::string>
EnvOpt = llvm::sys::Process::GetEnv(
EnvVar);
1455 if (
EnvOpt.has_value()) {
1457 while (!
Env.empty()) {
1461 Paths.push_back(Arg.str());
1467 std::vector<std::string>
Paths;
1474 for (
const std::string& P :
Paths)
1481 EnvOpt = llvm::sys::Process::GetEnv(
"ROOT_CLING_TIMING");
1504 EnvOpt = llvm::sys::Process::GetEnv(
"CLING_MODULES_CACHE_PATH");
1507 assert(llvm::sys::fs::exists(
Env) &&
"Path does not exist!");
1529 interpArgs.push_back(
"-fno-implicit-module-maps");
1559 std::vector<std::string>
_empty;
1561 for (
const auto &arg: args)
1565 cling::Interpreter::ModuleFileExtensions
extensions;
1566 EnvOpt = llvm::sys::Process::GetEnv(
"ROOTDEBUG_RDICT");
1568 extensions.push_back(std::make_shared<TClingRdictModuleFileExtension>());
1581 Cpp::UseExternalInterpreter((Cpp::TInterp_t*)
fInterpreter.get());
1584 fInterpreter->getCI()->getPreprocessorOpts().DisablePCHOrModuleValidation =
1585 DisableValidationForModuleKind::All;
1589 fInterpreter->getCI()->getLangOpts().SpellChecking =
false;
1623 fInterpreter->getRuntimeOptions().AllowRedefinition = 1;
1624 auto &Policy =
const_cast<clang::PrintingPolicy &
>(
fInterpreter->getCI()->getASTContext().getPrintingPolicy());
1628 Policy.SplitTemplateClosers =
true;
1630 Policy.SuppressDefaultTemplateArgs =
false;
1636 std::unique_ptr<TClingCallbacks>
1643 cling::DynamicLibraryManager&
DLM = *
fInterpreter->getDynamicLibraryManager();
1649 llvm::StringRef
stem = llvm::sys::path::stem(FileName);
1650 return stem.starts_with(
"libNew") ||
stem.starts_with(
"libcppyy_backend");
1729 ::Error(
"TCling::RegisterRdictForLoadPCM",
"Rdict '%s' is both in Module extension and in File system.",
pcmFileNameFullPath.c_str());
1756 ::Info(
"TCling::LoadPCMImpl",
"reading protoclasses for %s \n",
pcmFile.GetName());
1829 ::Error(
"TCling::LoadPCM",
"Inconsistent TClassTable for %s",
proto->GetName());
1834 ncl->PostLoadCheck();
1906 ::Error(
"TCling::LoadPCM",
"ROOT PCM %s file does not exist",
1910 ::Info(
"TCling::LoadPCM",
"In-memory ROOT PCM candidate %s\n",
1911 rdict.first.c_str());
1916 Fatal(
"LoadPCM",
"The file %s is not a ROOT as was expected\n",
pcmFileName.Data());
1926 using namespace clang;
1928 class ExtLexicalStorageAdder:
public RecursiveASTVisitor<ExtLexicalStorageAdder>{
1933 bool VisitRecordDecl(clang::RecordDecl*
rcd){
1935 Info(
"ExtLexicalStorageAdder",
1936 "Adding external lexical storage to class %s",
1937 rcd->getNameAsString().c_str());
1940 reDeclPtr->setHasExternalLexicalStorage();
1976 if (!
HS.loadModuleMapFile(*
FE,
false))
1995 "libforward_listDict",
2003 "libunordered_setDict",
2004 "libunordered_multisetDict",
2005 "libunordered_mapDict",
2006 "libunordered_multimapDict",
2041 if (
ncl)
ncl->PostLoadCheck();
2085 Info(
"TCling::RegisterModule",
2086 "Header parsing on demand is active but this is an Aclic library. Disabling it for this library.");
2104 cling::Transaction* T =
nullptr;
2111 "A fwd declaration could not be compiled");
2112 if (
compRes!=cling::Interpreter::kSuccess){
2113 Warning(
"TCling::RegisterModule",
2114 "Problems in declaring string '%s' were encountered.",
2137 ::Error(
"TCling::RegisterModule",
"Dictionary trigger function for %s not found",
modulename);
2175 std::vector<std::string>
scopes;
2179 if (
enumPos != std::string::npos) {
2197 clang::DeclContext*
DC =
nullptr;
2224 = cling::utils::Lookup::Named(&
fInterpreter->getSema(),
2242 "The forward declarations could not be compiled");
2243 if (
compRes!=cling::Interpreter::kSuccess){
2244 Warning(
"TCling::RegisterModule",
2245 "Problems in compiling forward declarations for module %s: '%s'",
2254 ExtLexicalStorageAdder
elsa;
2256 cling::Transaction::DelayCallInfo&
dci = *
dciIt;
2294 Info(
"TCling::RegisterModule",
2295 "Adding a header for %s", temp.c_str());
2318 clang::Preprocessor &
PP =
TheSema.getPreprocessor();
2336 Info(
"TCling::RegisterModule",
"Module %s in modulemap failed to load.",
ModuleName.c_str());
2357#if defined(R__MUST_REVISIT)
2358#if R__MUST_REVISIT(6,2)
2359 Warning(
"TCling::RegisterModule",
"Diagnostics suppression should be gone by now.");
2374 "Payload code of a dictionary could not be parsed correctly.");
2375 if (
compRes!=cling::Interpreter::kSuccess) {
2376 Warning(
"TCling::RegisterModule",
2377 "Problems declaring payload for module %s.",
modulename) ;
2393 "#undef __ROOTCLING__\n"
2417 std::unique_ptr<IdentifierIterator> Iter(External->getIdentifiers());
2418 for (llvm::StringRef
Ident = Iter->Next(); !
Ident.empty();
Ident = Iter->Next()) {
2419 std::string
I =
Ident.str();
2420 if (!
Idents.Contains(
I.data()))
2443 typedef std::vector<std::pair<TClass*,DictFuncPtr_t> >::iterator iterator;
2449 if ( i->first ==
oldcl ) {
2473 cling::Interpreter::CompilationResult&
compRes,
2479 catch (cling::InterpreterException&
ex)
2481 Error(
"HandleInterpreterException",
"%s\n%s",
ex.what(),
"Execution of your code was aborted.");
2483 compRes = cling::Interpreter::kFailure;
2492 if (
auto ie =
dynamic_cast<const cling::InterpreterException*
>(&
e)) {
2518 gROOT->SetLineIsProcessing();
2522 gROOT->SetLineHasBeenProcessed();
2535 gROOT->SetLineIsProcessing();
2538 cling::Interpreter* fInterpreter;
2545 fInterpreter->enableDynamicLookup(
true);
2549 gROOT->SetLineHasBeenProcessed();
2558 cling::Interpreter::CompilationResult
compRes = cling::Interpreter::kSuccess;
2579 compRes = cling::Interpreter::kFailure;
2584 if (arguments.
Length() == 0) {
2597 }
else if (cling::DynamicLibraryManager::isSharedLibrary(
fname.Data()) &&
2601 compRes = cling::Interpreter::kFailure;
2603 if (arguments.
Length() == 0) {
2634 std::ifstream in(
fname, std::ifstream::binary);
2640 = cling::utils::isUnnamedMacro(code,
fInterpreter->getCI()->getLangOpts());
2679 case cling::Interpreter::kSuccess: *error =
kNoError;
break;
2680 case cling::Interpreter::kFailure: *error =
kRecoverable;
break;
2681 case cling::Interpreter::kMoreInputExpected: *error =
kProcessing;
break;
2684 if (
compRes == cling::Interpreter::kSuccess
2715 if (path[0] ==
'-' && path[1] ==
'I')
2720 if (
sPath.BeginsWith(
"/")) {
2767 const char*
cobj = (
const char*) obj;
2807 static clang::PrintingPolicy
2812 printPol.SuppressInitializers =
true;
2833 Error(
"InspectMembers",
"Cannot find Decl for class %s",
clname);
2837 = llvm::dyn_cast<const clang::CXXRecordDecl>(
scopeDecl);
2839 Error(
"InspectMembers",
"Cannot find Decl for class %s is not a CXXRecordDecl.",
clname);
2863 Error(
"InspectMembers",
"TClass and cling disagree on the size of the class %s, respectively %d %lld\n",
2885 printPol.AnonymousTagLocations =
false;
2888 Error(
"InspectMembers",
2889 "Cannot retrieve QualType for member %s while inspecting class %s",
2898 printPol.AnonymousTagLocations =
false;
2901 Error(
"InspectMembers",
2902 "Cannot retrieve Type for member %s while inspecting class %s",
2911 clang::QualType
ptrQT
2918 if (
ptrQT.isNull()) {
2922 printPol.AnonymousTagLocations =
false;
2925 Error(
"InspectMembers",
2926 "Cannot retrieve pointee Type for member %s while inspecting class %s",
2934 llvm::SmallString<8> arraySize;
2942 clang::dyn_cast<clang::ConstantArrayType>(
arrType);
2952 printPol.AnonymousTagLocations =
false;
2955 Error(
"InspectMembers",
2956 "Cannot retrieve QualType for array level %d (i.e. element type of %s) for member %s while inspecting class %s",
2970 if (
memType->isPointerType()) {
2975 std::string ioname(
iField->getName());
2993 if (!
insp.IsTreatingNonAccessibleTypes()){
3022 if (!
mbr || !
mbr->IsPersistent())
3023 insp.IncrementNestedTransient();
3026 if (!
mbr || !
mbr->IsPersistent())
3027 insp.DecrementNestedTransient();
3036 for (clang::CXXRecordDecl::base_class_const_iterator
iBase
3041 Error(
"InspectMembers",
3042 "Cannot find QualType for base number %d while inspecting class %s",
3046 const clang::CXXRecordDecl*
baseDecl
3047 =
baseQT->getAsCXXRecordDecl();
3049 Error(
"InspectMembers",
3050 "Cannot find CXXRecordDecl for base number %d while inspecting class %s",
3075 Error(
"InspectMembers",
3081 if (
iBase->isVirtual()) {
3084 Error(
"InspectMembers",
3085 "Base %s of class %s is virtual but no object provided",
3097 Error(
"InspectMembers",
3098 "Error calculating offset of virtual base %s of class %s",
3102 Error(
"InspectMembers",
3103 "Cannot calculate offset of virtual base %s of class %s",
3112 if (
baseCl->IsLoaded()) {
3193 return fInterpreter->getDynamicLibraryManager()->isLibraryLoaded(
tLibName.Data());
3218 clang::ModuleMap &
moduleMap =
fInterpreter->getCI()->getPreprocessor().getHeaderSearchInfo().getModuleMap();
3220 return M && !M->IsUnimportable && M->getASTFile();
3239 size_t at = std::string::npos;
3240 while ((at = file_name.find(
"/./")) != std::string::npos)
3241 file_name.replace(at, 3,
"/");
3245 clang::SourceManager &
SM =
fInterpreter->getCI()->getSourceManager();
3246 cling::ClangInternalState::printIncludedFiles(
filesOS,
SM);
3249 llvm::SmallVector<llvm::StringRef, 100>
files;
3252 std::set<std::string>
fileMap;
3272 incPath.Append(
":").Prepend(
" ");
3273 incPath.ReplaceAll(
" -I",
":");
3274 while (
incPath.Index(
" :") != -1) {
3275 incPath.ReplaceAll(
" :",
":");
3289 clang::ConstSearchDirIterator *
CurDir =
nullptr;
3290 clang::Preprocessor &
PP =
fInterpreter->getCI()->getPreprocessor();
3291 clang::HeaderSearch &
HS =
PP.getHeaderSearchInfo();
3292 auto FE =
HS.LookupFile(file_name.c_str(),
3293 clang::SourceLocation(),
3296 clang::ArrayRef<std::pair<clang::OptionalFileEntryRef,
3297 clang::DirectoryEntryRef>>(),
3310 clang::SourceManager &
SM =
fInterpreter->getCI()->getSourceManager();
3312 clang::FileID
FID =
SM.translateFile(*
FE);
3313 if (!
FID.isInvalid() &&
FID.getHashValue() == 0)
3316 clang::SrcMgr::SLocEntry
SLocE =
SM.getSLocEntry(
FID);
3317 if (
SLocE.isFile() && !
SLocE.getFile().getContentCache().getBufferIfLoaded())
3319 if (!
FID.isInvalid())
3333#if defined(R__MACOSX)
3343 const char *
mapfile =
nullptr;
3345 mapfile =
"/System/Library/dyld/dyld_shared_cache_x86_64.map";
3347 mapfile =
"/System/Library/dyld/dyld_shared_cache_arm64e.map";
3349 #error unsupported architecture
3354 if (
line.find(lib) != std::string::npos) {
3366#if defined (R__LINUX) || defined (R__FBSD)
3377 auto newLibs =
static_cast<std::vector<std::string>*
>(
data);
3380 if (
info->dlpi_name &&
info->dlpi_name[0]
3389 &&
strncmp(
info->dlpi_name,
"/libexec/ld-elf.so.1", 20)
3392 &&
strncmp(
info->dlpi_name,
"linux-vdso32.so", 15)
3393 &&
strncmp(
info->dlpi_name,
"linux-vdso64.so", 15)
3409#if defined(R__WIN32) || defined(__CYGWIN__)
3417 for (i = 1; i < (
cbModules /
sizeof(
void *)); i++) {
3418 static const int bufsize = 260;
3422#if defined(__CYGWIN__)
3434#elif defined(R__MACOSX)
3449#elif defined(R__LINUX) || defined(R__FBSD)
3453 std::vector<std::string>
newLibs;
3458 Error(
"TCling::UpdateListOfLoadedSharedLibraries",
3459 "Platform not supported!");
3481 cling::DynamicLibraryManager*
DLM =
fInterpreter->getDynamicLibraryManager();
3486#if defined(R__MACOSX)
3537#elif defined(__CYGWIN__)
3539 static const int bufsize = 260;
3549#elif defined(R__WIN32)
3552#elif defined (R__LINUX)
3580 cling::DynamicLibraryManager*
DLM =
fInterpreter->getDynamicLibraryManager();
3582 cling::DynamicLibraryManager::LoadLibResult res
3583 = cling::DynamicLibraryManager::kLoadLibNotFound;
3590 cling::Interpreter::CompilationResult
compRes;
3592 if (
compRes == cling::Interpreter::kSuccess)
3593 res = cling::DynamicLibraryManager::kLoadLibSuccess;
3597 if (res == cling::DynamicLibraryManager::kLoadLibSuccess) {
3601 case cling::DynamicLibraryManager::kLoadLibSuccess:
return 0;
3602 case cling::DynamicLibraryManager::kLoadLibAlreadyLoaded:
return 1;
3652 Warning(
"Calc",
"waiting for cling thread to free");
3655 gROOT->SetLineIsProcessing();
3663 cling::Interpreter::CompilationResult
cr = cling::Interpreter::kFailure;
3667 catch (cling::InterpreterException&
ex)
3669 Error(
"Calc",
"%s.\n%s",
ex.what(),
"Evaluation of your expression was aborted.");
3671 cr = cling::Interpreter::kFailure;
3674 if (
cr != cling::Interpreter::kSuccess) {
3698 gROOT->SetLineHasBeenProcessed();
3713#if defined(R__MUST_REVISIT)
3714#if R__MUST_REVISIT(6,2)
3715 Warning(
"SetGetline",
"Cling should support the equivalent of SetGetlineFunc(getlineFunc, histaddFunc)");
3728 if ((std::distance(T.decls_begin(), T.decls_end()) != 1)
3729 || T.deserialized_decls_begin() != T.deserialized_decls_end()
3730 || T.macros_begin() != T.macros_end()
3731 || ((!T.getFirstDecl().isNull()) && ((*T.getFirstDecl().begin()) != T.getWrapperFD()))) {
3772#if defined(R__MUST_REVISIT)
3773#if R__MUST_REVISIT(6,2)
3775 Warning(
"Reset",
"Cling should support the equivalent of scratch_upto(&fDictPos)");
3785#if defined(R__MUST_REVISIT)
3786#if R__MUST_REVISIT(6,2)
3788 Warning(
"ResetAll",
"Cling should support the equivalent of complete reset (unload everything but the startup decls.");
3815#if defined(R__MUST_REVISIT)
3816#if R__MUST_REVISIT(6,2)
3818 Warning(
"ResetGlobalVar",
"Cling should support the equivalent of resetglobalvar(obj)");
3830#if defined(R__MUST_REVISIT)
3831#if R__MUST_REVISIT(6,2)
3833 Warning(
"RewindDictionary",
"Cling should provide a way to revert transaction similar to rewinddictionary()");
3844#if defined(R__MUST_REVISIT)
3845#if R__MUST_REVISIT(6,2)
3847 Warning(
"DeleteGlobal",
"Cling should provide the equivalent of deleteglobal(obj), see also DeleteVariable.");
3859#if defined(R__MUST_REVISIT)
3860#if R__MUST_REVISIT(6,2)
3861 Warning(
"DeleteVariable",
"should do more that just reseting the value to zero");
3869 const clang::DeclContext*
declCtx =
nullptr;
3870 if (
posScope != llvm::StringRef::npos) {
3874 cling::LookupHelper::WithDiagnostics);
3876 Error(
"DeleteVariable",
"Cannot find enclosing scope for variable %s",
3882 Error(
"DeleteVariable",
3883 "Enclosing scope for variable %s is not a declaration context",
3894 Error(
"DeleteVariable",
"Unknown variable %s",
name);
3899 Error(
"DeleteVariable",
"Entity %s is not a variable",
name);
3904 const clang::Type*
type =
qType->getUnqualifiedDesugaredType();
3907 if (
type->isPointerType()) {
3920#if defined(R__MUST_REVISIT)
3921#if R__MUST_REVISIT(6,2)
3923 Warning(
"SaveContext",
"Cling should provide a way to record a state watermark similar to store_dictposition(&fDictPos)");
3933#if defined(R__MUST_REVISIT)
3934#if R__MUST_REVISIT(6,2)
3936 Warning(
"SaveGlobalsContext",
"Cling should provide a way to record a watermark for the list of global variable similar to store_dictposition(&fDictPosGlobals)");
3984 std::tuple<int,double>
value;
4013 if (
lh.findScope(fullname, cling::LookupHelper::NoDiagnostics,
4029 Error(
"Load",
"Could not declare alternate type for %s since %s (or one of its context) is private or protected",
4030 classname, iter->c_str());
4039 std::ostringstream guard;
4040 guard <<
"ROOT_INTERNAL_TEmulated_";
4047 alternateTuple <<
"template <class... Types> struct TEmulatedTuple;\n";
4075 Fatal(
"TCling::SetClassInfo::AlternateTuple",
4076 "Layout of std::tuple on this platform is unexpected.");
4145 if (
strncmp(cl->
GetName(),
"tuple<",std::char_traits<char>::length(
"tuple<"))==0) {
4148 if (reload ||
name.empty()) {
4161 if (!
info->IsValid()) {
4181 if (!
info->IsLoaded()) {
4239 static const char *
anonEnum =
"anonymous enum ";
4267 const char *classname =
name;
4303 const clang::Type *
type =
nullptr;
4304 const clang::Decl *
decl
4305 =
lh.findScope(classname,
4306 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4307 : cling::LookupHelper::NoDiagnostics,
4312 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4313 : cling::LookupHelper::NoDiagnostics,
4330 clang::ClassTemplateSpecializationDecl *
tmpltDecl =
4331 llvm::dyn_cast_or_null<clang::ClassTemplateSpecializationDecl>
4332 (
type->getAsCXXRecordDecl());
4344 if (!
tci.IsValid()) {
4413 const clang::Decl *
decl
4414 =
lh.findClassTemplate(
name,
4415 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4416 : cling::LookupHelper::NoDiagnostics);
4418 std::string
strname =
"std::";
4421 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4422 : cling::LookupHelper::NoDiagnostics);
4424 return nullptr !=
decl;
4464 D =
fInterpreter->getCI()->getASTContext().getTranslationUnitDecl();
4475 for (clang::DeclContext::decl_iterator
DI = (*declIter)->decls_begin(),
4476 DE = (*declIter)->decls_end();
DI !=
DE; ++
DI) {
4481 llvm::raw_string_ostream stream(buf);
4483 Policy.AnonymousTagLocations =
false;
4484 ED->getNameForDiagnostic(stream, Policy,
false);
4488 const char*
name = buf.c_str();
4512 D =
fInterpreter->getCI()->getASTContext().getTranslationUnitDecl();
4524 for (clang::DeclContext::decl_iterator
DI = (*declIter)->decls_begin(),
4525 DE = (*declIter)->decls_end();
DI !=
DE; ++
DI) {
4540 return ci->GetUsingNamespaces();
4585 if (
m->fMethodArgs) {
4641 if (llvm::isa<clang::NamespaceDecl>(
cli->GetDecl())) {
4648 if (!
mi.IsValid()) {
4650 Error(
"GenerateTClass",
4651 "Cannot find %s::Class_Version()! Class version might be wrong.",
4668 Error(
"GenerateTClass",
4669 "Cannot invoke %s::Class_Version()! Class version might be wrong.",
4694 const clang::ClassTemplateSpecializationDecl *
templateCl
4695 = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(
info->GetDecl());
4697 for(
unsigned int i=0; i <
templateCl->getTemplateArgs().
size(); ++i) {
4698 const clang::TemplateArgument &arg(
templateCl->getTemplateArgs().get(i) );
4699 if (arg.getKind() == clang::TemplateArgument::Type) {
4702 if (!
uType->isFundamentalType() && !
uType->isEnumeralType()) {
4704 const clang::CXXRecordDecl *
argdecl =
uType->getAsCXXRecordDecl();
4711 llvm::raw_string_ostream
OS(Result);
4712 arg.print(
argdecl->getASTContext().getPrintingPolicy(),
OS);
4713 Warning(
"TCling::GenerateTClass",
"Missing header file for %s",
OS.str().c_str());
4729 Fatal(
"GenerateTClass",
"Requires a valid ClassInfo object");
4734 std::string classname;
4738 Info(
"GenerateTClass",
"Will (try to) generate the compiled TClass for %s.",classname.c_str());
4748 Error(
"GenerateTClass",
"Even though the dictionary generation for %s seemed successful we can't find the TClass bootstrap!",classname.c_str());
4752 if (cl ==
nullptr) {
4784 if (classes ==
nullptr || classes[0] == 0) {
4785 Error(
"TCling::GenerateDictionary",
"Cannot generate dictionary without passing classes.");
4791 const char* current = classes, *prev = classes;
4795 if (*current ==
';') {
4796 listClasses.push_back(std::string(prev, current - prev));
4799 else if (*(current + 1) == 0) {
4800 listClasses.push_back(std::string(prev, current + 1 - prev));
4812 if (*current ==
';') {
4813 listIncludes.push_back(std::string(prev, current - prev));
4816 else if (*(current + 1) == 0) {
4817 listIncludes.push_back(std::string(prev, current + 1 - prev));
4823 std::vector<std::string>(), std::vector<std::string>());
4862 using namespace clang;
4867 Sema::ForExternalRedeclaration);
4869 cling::utils::Lookup::Named(&
SemaR,
R);
4871 LookupResult::Filter F =
R.makeFilter();
4873 while (F.hasNext()) {
4882 if (
R.isSingleResult())
4883 return R.getFoundDecl();
4900 const clang::DeclContext*
dc =
nullptr;
4901 if (
const clang::Decl* D =
cci->GetDecl()) {
4912 Error(
"TCling::GetEnum",
"DeclContext not found for %s .\n",
name);
4933 if (!
gv)
return nullptr;
4959 if (!
strncmp(
scopename.c_str(),
"typeinfo for ",
sizeof(
"typeinfo for ")-1)) {
4960 scopename.erase(0,
sizeof(
"typeinfo for ")-1);
4961 }
else if (!
strncmp(
scopename.c_str(),
"vtable for ",
sizeof(
"vtable for ")-1)) {
4962 scopename.erase(0,
sizeof(
"vtable for ")-1);
4965 std::string::size_type pos =
scopename.rfind(
'(');
4966 if (pos != std::string::npos) {
4971 if (pos != std::string::npos) {
4972 if ((pos != 0) && (
scopename[pos-1] ==
':')) {
5002 Error(
"GetDataMemberWithValue()",
"not implemented");
5012 Error(
"GetDataMemberAtAddr()",
"not implemented");
5108 std::vector<DeclId_t>& res)
const
5111 clang::ASTContext&
Ctx = S.Context;
5114 Ctx.getTranslationUnitDecl();
5122 clang::DeclarationName
DName;
5129 DName =
Ctx.DeclarationNames.getCXXConstructorName(
Ctx.getCanonicalType(
QT));
5132 DName =
Ctx.DeclarationNames.getCXXDestructorName(
Ctx.getCanonicalType(
QT));
5141 clang::LookupResult
R(S,
DName, clang::SourceLocation(),
5142 Sema::LookupOrdinaryName, clang::Sema::NotForRedeclaration);
5143 R.suppressDiagnostics();
5145 if (
R.empty())
return;
5147 res.reserve(res.size() + (
R.end() -
R.begin()));
5150 if (
const clang::FunctionDecl*
FD
5151 = llvm::dyn_cast<const clang::FunctionDecl>(*
IR)) {
5152 if (!
FD->getDescribedFunctionTemplate()) {
5155 }
else if (
const auto *
USD = llvm::dyn_cast<const clang::UsingShadowDecl>(*
IR)) {
5157 if (llvm::isa<clang::FunctionDecl>(
USD->getTargetDecl())) {
5337 const char* params,
int* error)
5354 Error(
"Execute",
"No method was defined");
5364 Error(
"Execute",
"Too many parameters to call %s, got %d but expected at most %d.",
method->GetName(),
argc,
nparms);
5388 Error(
"Execute",
"Too few arguments to call %s, got only %d but expected %d.",
method->GetName(),
argc,
nparms);
5408 chpar += (
nxtpar->String()).ReplaceAll(
"\"",
"\\\"");
5445 const void* args[] ,
5450 Error(
"ExecuteWithArgsAndReturn",
"No method was defined");
5477 Warning(
"GetTopLevelMacroName",
"Must change return type!");
5524#if defined(R__MUST_REVISIT)
5525#if R__MUST_REVISIT(6,0)
5526 Warning(
"GetCurrentMacroName",
"Must change return type!");
5564 auto l = t.length();
5565 while (
l > 0 && (t[
l - 1] ==
'*' || t[
l - 1] ==
'&'))
5576 libName.consume_back(
".rootmap");
5596 const std::map<char, unsigned int>
keyLenMap = {{
'c',6},{
'n',10},{
't',8},{
'h',7},{
'e',5},{
'v',4}};
5616 if (!
newFormat && (
line.compare(0, 8,
"Library.") == 0 ||
line.compare(0, 8,
"Declare.") == 0)) {
5622 if (
line.compare(0, 9,
"{ decls }") == 0) {
5629 Error(
"ReadRootmapFile",
"Cannot handle \"{ decls }\" sections in custom rootmap file %s",
5642 if (
brpos == string::npos)
5675 Info(
"ReadRootmapFile",
5676 "While processing %s, namespace %s was found to be associated to %s although it is already "
5685 "While processing %s, %s %s was found to be associated to %s although it is already "
5692 Info(
"ReadRootmapFile",
"While processing %s, key %s was found to be already defined for %s",
5754 using namespace clang;
5756 class ExtVisibleStorageAdder:
public RecursiveASTVisitor<ExtVisibleStorageAdder>{
5762 ExtVisibleStorageAdder(std::unordered_set<const NamespaceDecl*>&
nsSet): fNSSet(
nsSet) {};
5768 nsDecl->setHasExternalVisibleStorage();
5777 specDecl->setHasExternalLexicalStorage();
5789 std::unordered_set<const NamespaceDecl*>& fNSSet;
5832 for (
Int_t i = 0; i <
paths->GetEntriesFast(); i++) {
5847 Info(
"LoadLibraryMap",
"%s",
d.Data());
5852 if (
f.EndsWith(
".rootmap")) {
5858 Info(
"LoadLibraryMap",
" rootmap file: %s",
p.Data());
5876 if (
f.BeginsWith(
"rootmap")) {
5881 Warning(
"LoadLibraryMap",
"please rename %s to end with \".rootmap\"",
p.Data());
5901 else if (res == -3) {
5911 while ((rec = (
TEnvRec*) next())) {
5913 if (!
strncmp(
cls.Data(),
"Library.", 8) &&
cls.Length() > 8) {
5925 cls.ReplaceAll(
"@@",
"::");
5928 cls.ReplaceAll(
"-",
" ");
5932 Info(
"LoadLibraryMap",
"class %s in %s",
cls.Data(),
wlib);
5935 Info(
"LoadLibraryMap",
"class %s in %s (library does not exist)",
cls.Data(), lib);
5941 else if (!
strncmp(
cls.Data(),
"Declare.", 8) &&
cls.Length() > 8) {
5945 cls.ReplaceAll(
"-",
" ");
5951 cling::Transaction* T =
nullptr;
5953 assert(cling::Interpreter::kSuccess ==
compRes &&
"A declaration in a rootmap could not be compiled");
5955 if (
compRes!=cling::Interpreter::kSuccess){
5963 if (
declIt->m_DGR.isSingleDecl()) {
5964 if (
Decl* D =
declIt->m_DGR.getSingleDecl()) {
5965 if (clang::isa<TagDecl>(D) || clang::isa<NamespaceDecl>(D)) {
6035 Error(
"ReloadAllSharedLibraryMaps",
"Could not find rootmap %s in path",
rootMapBaseStr.Data());
6042 Error(
"ReloadAllSharedLibraryMaps",
"Error loading map %s",
rootMap);
6090 while ((rec = (
TEnvRec *) next())) {
6092 if (
cls.Length() > 2) {
6101 if (!
strncmp(
cls.Data(),
"Library.", 8) &&
cls.Length() > 8) {
6105 cls.ReplaceAll(
"@@",
"::");
6108 cls.ReplaceAll(
"-",
" ");
6112 Error(
"UnloadLibraryMap",
"entry for <%s, %s> not found in library map table",
cls.Data(), lib);
6173 if (err)
return nullptr;
6224 for (
Int_t i = (
tokens->GetEntriesFast() - 1); i > 0; --i) {
6229 "loaded dependent library %s for %s",
deplib,
cls);
6234 "failure loading dependent library %s for %s",
6239 if (lib && lib[0]) {
6240 if (
gROOT->LoadClass(
cls, lib) == 0) {
6243 "loaded library %s for %s", lib,
cls);
6249 "failure loading library %s for %s", lib,
cls);
6270 if (!
visited.insert(std::string(
cls)).second)
6336 Info(
"TCling::AutoLoad",
"Explicitly disabled (the class name is %s)",
cls);
6356 Info(
"TCling::AutoLoad",
6357 "Trying to autoload for %s",
cls);
6362 Info(
"TCling::AutoLoad",
6363 "Disabled due to gROOT or gInterpreter being invalid/not ready (the class name is %s)",
cls);
6384 std::unordered_set<std::string>
visited;
6402 code += (
"#include \"");
6406 code += (
"#ifdef __ROOTCLING__\n"
6407 "#undef __ROOTCLING__\n"
6411 cling::Interpreter::CompilationResult
cr;
6421 #if defined(R__MUST_REVISIT)
6422 #if R__MUST_REVISIT(6,2)
6423 Warning(
"TCling::RegisterModule",
"Diagnostics suppression should be gone by now.");
6446 unsigned long offset = 0;
6505 Info(
"TCling::AutoParse",
6506 "Starting autoparse for %s\n",
apKey);
6511 const cling::Transaction *T =
fInterpreter->getCurrentTransaction();
6515 Info(
"TCling::AutoParse",
6516 "We can proceed for %s. We have %s headers.",
apKey, std::to_string(
hNamesPtrs.size()).c_str());
6526 "Parsing full payload for %s",
apKey);
6533 if (
cRes != cling::Interpreter::kSuccess) {
6534 if (
hName[0] ==
'\n')
6535 Error(
"AutoParse",
"Error parsing payload code for class %s with content:\n%s",
apKey,
hName);
6551 "Parsing single header %s",
hName);
6554 if (
cRes != cling::Interpreter::kSuccess) {
6555 Error(
"AutoParse",
"Error parsing headerfile %s for class %s.",
hName,
apKey);
6584 if (llvm::StringRef(
cls).contains(
"(lambda)"))
6598 Info(
"TCling::AutoParse",
6599 "Trying to autoparse for %s",
cls);
6630 if (
errMsg.contains(
"undefined symbol: ")) {
6634 cling::DynamicLibraryManager*
DLM =
fInterpreter->getDynamicLibraryManager();
6662 ::Error(
"TCling__LazyFunctionCreatorAutoloadForModule",
6663 "Failed to load library %s",
LibName.c_str());
6705 if (
cci->GetType()) {
6707 cci->Init(*
cci->GetType());
6710 Error(
"RefreshClassInfo",
"Should not need to update the classInfo a non type decl: %s",
oldDef->getNameAsString().c_str());
6764 if (!
tdDef->isCompleteDefinition() || llvm::isa<clang::FunctionDecl>(
tdDef->getDeclContext())) {
6781 clang::QualType
type(
tdDef->getTypeForDecl(), 0);
6784 canon = ns->getCanonicalDecl();
6785 name =
ND->getQualifiedNameAsString();
6787 name =
ND->getQualifiedNameAsString();
6842 if (!T.empty() && T.decls_begin() + 1 == T.decls_end() && !T.hasNestedTransactions()) {
6843 clang::Decl*
FirstDecl = *(T.decls_begin()->m_DGR.begin());
6844 if (llvm::isa<clang::TranslationUnitDecl>(
FirstDecl)) {
6853 const clang::Decl*
WrapperFD = T.getWrapperFD();
6856 if (
I->m_Call != cling::Transaction::kCCIHandleTopLevelDecl
6857 &&
I->m_Call != cling::Transaction::kCCIHandleTagDeclDefinition)
6873 E = T.deserialized_decls_end();
I != E; ++
I) {
6893 std::vector<TClass*>::iterator it;
6906 if (!
gROOT->GetListOfClasses()->FindObject(*
I)) {
6928 cling::Transaction::const_nested_iterator
iNested = T.nested_begin();
6931 if (
I->m_Call == cling::Transaction::kCCIHandleVTable)
6933 if (
I->m_Call == cling::Transaction::kCCINone) {
6939 for (
auto &D :
I->m_DGR)
6965 if (D->isFromASTFile())
6975 if (
LODM.GetClass())
6998 std::vector<TClass *> Classes;
7001 for (
auto &C : Classes) {
7010 if (D->getKind() != Decl::Namespace
7012 C->ResetClassInfo();
7033 Info(
"TransactionRollback",
7034 "Restoring ability to autoaparse: %s",
hName);
7071 using namespace clang;
7072 if (
const Decl *D =
LH.findScope(
cls, cling::LookupHelper::NoDiagnostics,
7074 if (!D->isFromASTFile()) {
7076 Warning(
"GetClassSharedLibsForModule",
"Decl found for %s is not part of a module",
cls);
7084 void Collect(
const Decl *D) { Visit(D); }
7096 if (!D->hasOwningModule())
7098 if (Module *M = D->getOwningModule()->getTopLevelModule())
7104 switch (
TA.getKind()) {
7105 case TemplateArgument::Null:
7106 case TemplateArgument::Integral:
7107 case TemplateArgument::Pack:
7108 case TemplateArgument::NullPtr:
7109 case TemplateArgument::StructuralValue:
7110 case TemplateArgument::Expression:
7111 case TemplateArgument::Template:
7112 case TemplateArgument::TemplateExpansion:
return;
7113 case TemplateArgument::Type:
7115 return Visit(
TagTy->getDecl());
7117 case TemplateArgument::Declaration:
return Visit(
TA.getAsDecl());
7124 if (
CTSD->getOwningModule())
7142 if (!M->LinkLibraries.size())
7147 assert(M->LinkLibraries.size() == 1);
7150 result += M->LinkLibraries[0].Library;
7173 llvm::StringRef className =
cls;
7179 if (className.contains(
"(lambda)"))
7185 if (!
libs.empty()) {
7232 cling::Interpreter *
interp,
7236 if (!llvm::sys::path::is_absolute(lib)) {
7238 Error(
"TCling__GetSharedLibImmediateDepsSlow",
"Cannot find library '%s'", lib.c_str());
7242 assert(llvm::sys::fs::exists(lib) &&
"Must exist!");
7243 lib = llvm::sys::path::filename(lib).str();
7246 auto ObjF = llvm::object::ObjectFile::createObjectFile(
LibFullPath.Data());
7248 Warning(
"TCling__GetSharedLibImmediateDepsSlow",
"Failed to read object file %s", lib.c_str());
7255 std::string Result = lib +
' ';
7256 for (
const auto &S :
BinObjFile->symbols()) {
7257 uint32_t
Flags = llvm::cantFail(S.getFlags());
7259 if (!(
Flags & llvm::object::SymbolRef::SF_Undefined))
7263 if (
Flags & llvm::object::SymbolRef::SF_Weak)
7265 llvm::Expected<StringRef>
SymNameErr = S.getName();
7267 Warning(
"GetSharedLibDepsForModule",
"Failed to read symbol");
7278 if (
SymName.contains(
"@GLIBCXX") ||
SymName.contains(
"@CXXABI") ||
7287 static constexpr llvm::StringRef
RegisterClasses(
"_Jv_RegisterClasses");
7299 if (llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(
SymNameForDlsym))
7304 std::string found =
interp->getDynamicLibraryManager()->searchLibrariesForSymbol(
SymName,
false);
7310 if (!found.empty()) {
7311 std::string
cand = llvm::sys::path::filename(found).str();
7315 Result +=
cand +
' ';
7326 if (!lib.starts_with(
"lib"))
7329 rootmapName.append(llvm::sys::path::filename(lib));
7330 llvm::sys::path::replace_extension(
rootmapName,
"rootmap");
7361 if (llvm::sys::path::is_absolute(lib) && !llvm::sys::fs::exists(lib))
7366 llvm::sys::path::replace_extension(
rootmapName,
"rootmap");
7376 Warning(
"TCling::GetSharedLibDeps",
"Precomputed dependencies available but scanning '%s'", lib);
7381 if (!
libs.empty()) {
7387 if (!
fMapfile || !lib || !lib[0]) {
7398 while ((rec = (
TEnvRec*) next())) {
7399 const char*
libs = rec->GetValue();
7414#if defined(R__MUST_REVISIT)
7415#if R__MUST_REVISIT(6,2)
7416 Warning(
"IsErrorMessagesEnabled",
"Interface not available yet.");
7428#if defined(R__MUST_REVISIT)
7429#if R__MUST_REVISIT(6,2)
7430 Warning(
"SetErrorMessages",
"Interface not available yet.");
7450 assert(!(
nPaths & 1) &&
"GetIncludePath, number of paths and options is not equal");
7452 for (
size_t i = 0; i <
nPaths; i += 2) {
7491 assert(
fout !=
nullptr &&
"DisplayIncludePath, 'fout' parameter is null");
7497 assert(!(
nPaths & 1) &&
"DisplayIncludePath, number of paths and options is not equal");
7500 for (
size_t i = 0; i <
nPaths; i += 2) {
7529#if defined(R__MUST_REVISIT)
7530#if R__MUST_REVISIT(6,2)
7531 Warning(
"GenericError",
"Interface not available yet.");
7559#if defined(R__MUST_REVISIT)
7560#if R__MUST_REVISIT(6,2)
7561 Warning(
"GetSecurityError",
"Interface not available yet.");
7574 cling::Interpreter::CompilationResult
compRes;
7576 return compRes == cling::Interpreter::kFailure;
7597 return buffer.c_str();
7678#if defined(R__MUST_REVISIT)
7679#if R__MUST_REVISIT(6,2)
7680 Warning(
"SetErrmsgcallback",
"Interface not available yet.");
7689 &
fInterpreter->getDiagnostics().getDiagnosticOptions(),
7691 [] (clang::DiagnosticsEngine::Level Level,
const std::string &
Info) {
7692 if (Level == clang::DiagnosticsEngine::Warning) {
7693 ::Warning(
"cling",
"%s", Info.c_str());
7694 }
else if (Level == clang::DiagnosticsEngine::Error
7695 || Level == clang::DiagnosticsEngine::Fatal) {
7703 fInterpreter->replaceDiagnosticConsumer(
nullptr);
7722 cling::DynamicLibraryManager*
DLM =
fInterpreter->getDynamicLibraryManager();
7728 cling::Interpreter::CompilationResult
compRes;
7730 return compRes == cling::Interpreter::kFailure;
7734 return std::unique_ptr<TInterpreterValue>(
new TClingValue);
7752 auto V =
reinterpret_cast<cling::Value*
>(
value.GetValAddr());
7754 return compRes!=cling::Interpreter::kSuccess ? 0 : 1 ;
7761 using namespace cling;
7775 if (
value.isValid() &&
value.needsManagedAllocation()) {
7808 Parser& P =
const_cast<Parser&
>(
fInterpreter->getParser());
7814 Tok.setKind(tok::semi);
7826 Error(
"GetObjectAddress",
"Got a special object without LookupCtx!");
7840 clang::CXXRecordDecl*
klass)
const
7842 using namespace clang;
7862 if (func)
return ((
TClingCallFunc*)func)->GetDecl()->getCanonicalDecl();
7933 f->Exec(address, &val);
7941 f->ExecWithReturn(address,
ret);
7947 const void* args[] ,
7952 f->ExecWithArgsAndReturn(address, args,
nargs,
ret);
7960 return f->ExecInt(address);
7968 return f->ExecInt64(address);
7976 return f->ExecDouble(address);
7999 return (MethodInfo_t*)
f->FactoryMethod();
8024 return f->IsValid();
8033 return f->IFacePtr();
8161 llvm::SmallVector<clang::QualType, 4>
funcProto;
8162 for (std::vector<TypeInfo_t*>::const_iterator iter =
proto.
begin(), end =
proto.
end();
8163 iter != end; ++iter) {
8176 llvm::SmallVector<clang::QualType, 4>
funcProto;
8177 for (std::vector<TypeInfo_t*>::const_iterator iter =
proto.
begin(), end =
proto.
end();
8178 iter != end; ++iter) {
8208 const clang::DeclContext *
ctxt =
nullptr;
8217 const clang::Decl *
decl =
reinterpret_cast<const clang::Decl*
>(
declid);
8221 const clang::DeclContext *
declDC =
decl->getDeclContext();
8224 if (
declDC->isTransparentContext()) {
8228 if (
const auto *
declRD = llvm::dyn_cast<clang::RecordDecl>(
declDC)) {
8229 if (
declRD->isAnonymousStructOrUnion()) {
8234 if (
const auto *
declNS = llvm::dyn_cast<clang::NamespaceDecl>(
declDC)) {
8235 if (
declNS->isAnonymousNamespace() ||
declNS->isInlineNamespace()) {
8683 const clang::Decl*
decl =
reinterpret_cast<const clang::Decl*
>(
declid);
8684 const clang::ValueDecl*
vd = llvm::dyn_cast_or_null<clang::ValueDecl>(
decl);
8801 decl->addAttr(AnnotateAttr::CreateImplicit(C,
attribute,
nullptr, 0));
8812 cling::Interpreter &
interp,
8815 const clang::TypeDecl*
td = llvm::dyn_cast<clang::TypeDecl>(
decl->getDeclContext());
8818 clang::QualType
qualType(
td->getTypeForDecl(),0);
8820 unsigned int level = 0;
8823 else if (
name[
cursor] ==
'<' && level) --level;
8824 else if (level == 0 &&
name[
cursor] ==
':') {
8837 const auto *
FD = llvm::dyn_cast<clang::FunctionDecl>(
decl);
8838 if (
const auto *
USD = llvm::dyn_cast<clang::UsingShadowDecl>(
decl)) {
8839 FD = llvm::dyn_cast<clang::FunctionDecl>(
USD->getTargetDecl());
8842 Error(
"GetFunctionName",
"NULL Decl!");
8849 if (llvm::isa<clang::CXXConstructorDecl>(
FD))
8853 }
else if (llvm::isa<clang::CXXDestructorDecl>(
decl))
8858 llvm::raw_string_ostream stream(
output);
8914 return t_info !=
nullptr;
8924 const clang::FunctionTemplateDecl *
ft = (
const clang::FunctionTemplateDecl*)
ft_info;
8925 return ft->getTemplateParameters()->size();
8935 const clang::FunctionTemplateDecl *
ft = (clang::FunctionTemplateDecl*)
ft_info;
8936 return ft->getTemplateParameters()->getMinRequiredArguments();
8949 const clang::FunctionTemplateDecl *
ft = (clang::FunctionTemplateDecl*)
ft_info;
8951 switch (
ft->getAccess()) {
8952 case clang::AS_public:
8955 case clang::AS_protected:
8958 case clang::AS_private:
8961 case clang::AS_none:
8962 if (
ft->getDeclContext()->isNamespace())
8967 assert(
false &&
"Unexpected value for the access property value in Clang");
8971 const clang::FunctionDecl *fd =
ft->getTemplatedDecl();
8973 if (fd && fd->getStorageClass() == clang::SC_Static)
8976 if (
const clang::CXXMethodDecl *
md =
8977 llvm::dyn_cast<clang::CXXMethodDecl>(fd)) {
8978 if (
md->getMethodQualifiers().hasConst()) {
8981 if (
md->isVirtual()) {
8984 if (
md->isPureVirtual()) {
8987 if (
const clang::CXXConstructorDecl *cd =
8988 llvm::dyn_cast<clang::CXXConstructorDecl>(
md)) {
8989 if (cd->isExplicit()) {
8993 else if (
const clang::CXXConversionDecl *cd =
8994 llvm::dyn_cast<clang::CXXConversionDecl>(
md)) {
8995 if (cd->isExplicit()) {
9014 const clang::FunctionTemplateDecl *
ft = (clang::FunctionTemplateDecl*)
ft_info;
9015 const clang::FunctionDecl *fd =
ft->getTemplatedDecl();
9017 if (fd->isOverloadedOperator())
9019 if (llvm::isa<clang::CXXConversionDecl>(fd))
9021 if (llvm::isa<clang::CXXConstructorDecl>(fd))
9023 if (llvm::isa<clang::CXXDestructorDecl>(fd))
9025 if (fd->isInlined())
9037 const clang::FunctionTemplateDecl *
ft = (clang::FunctionTemplateDecl*)
ft_info;
9050 const clang::FunctionTemplateDecl *
ft = (
const clang::FunctionTemplateDecl*)
ft_info;
9057 output = A->getAnnotation().str();
9061 if (!
ft->isFromASTFile()) {
9112 const clang::Decl*
decl =
reinterpret_cast<const clang::Decl*
>(
declid);
9130 return info->InterfaceMethod();
9138 return info->IsValid();
9146 return info->NArg();
9154 return info->NDefaultArg();
9162 return info->Next();
9171 return info->Property();
9180 return info->ExtraProperty();
9209 return info->GetPrototype();
9218 return info->Name();
9227 return info->TypeName();
9248 return info->Title();
9256 return MethodInfo_MethodCallReturnType(func->fInfo);
9258 return EReturnType::kOther;
9269 clang::QualType
QT(
typeinfo->GetQualType().getCanonicalType() );
9270 if (
QT->isEnumeralType()) {
9271 return EReturnType::kLong;
9272 }
else if (
QT->isPointerType()) {
9274 QT = llvm::cast<clang::PointerType>(
QT)->getPointeeType();
9275 if (
QT->isCharType() ) {
9276 return EReturnType::kString;
9278 return EReturnType::kOther;
9280 }
else if (
QT->isFloatingType() ) {
9282 if (
sz == 4 ||
sz == 8) {
9284 return EReturnType::kDouble;
9286 return EReturnType::kOther;
9288 }
else if (
QT->isIntegerType() ) {
9298 return EReturnType::kLong;
9300 return EReturnType::kOther;
9303 return EReturnType::kOther;
9306 return EReturnType::kOther;
9351 return info->IsValid();
9359 return info->Next();
9367 return info->Property();
9375 return info->DefaultValue();
9383 return info->Name();
9391 return info->TypeName();
9549 const char*
name)
const
9616 clang::QualType
QT1 = clang::QualType::getFromOpaquePtr(
QualTypePtr1);
9617 clang::QualType
QT2 = clang::QualType::getFromOpaquePtr(
QualTypePtr2);
9625 clang::QualType
QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9626 return QT->hasIntegerRepresentation();
9633 clang::QualType
QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9634 return QT->hasSignedIntegerRepresentation();
9641 clang::QualType
QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9642 return QT->hasUnsignedIntegerRepresentation();
9649 clang::QualType
QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9650 return QT->hasFloatingRepresentation();
9657 clang::QualType
QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9658 return QT->hasPointerRepresentation();
9665 clang::QualType
QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9666 return QT->isVoidPointerType();
9675 Error(
"SnapshotMutexState",
"fRecurseCount != 0 even though initial mutex state is unset!");
9691 Error(
"ForgetMutexState",
"mutex state's recurse count already 0!");
9721 Error(
"ApplyToInterpreterMutex",
9722 "After returning from user code that turned on thread safety support, we notice that fInitialMutex is already used ... "
9723 "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.");
The file contains utilities which are foundational and could be used across the core component of ROO...
#define R(a, b, c, d, e, f, g, h, i)
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
bool Bool_t
Boolean (0=false, 1=true) (bool)
int Int_t
Signed integer 4 bytes (int)
long Longptr_t
Integer large enough to hold a pointer (platform-dependent)
short Version_t
Class version identifier (short)
unsigned long ULong_t
Unsigned long integer 4 bytes (unsigned long). Size depends on architecture.
long Long_t
Signed long integer 4 bytes (long). Size depends on architecture.
unsigned int UInt_t
Unsigned integer 4 bytes (unsigned int)
constexpr Ssiz_t kNPOS
The equivalent of std::string::npos for the ROOT class TString.
long long Long64_t
Portable signed long integer 8 bytes.
unsigned long long ULong64_t
Portable unsigned long integer 8 bytes.
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)
bool TClingLookupHelper__CheckInClassTable(const std::string &tname, std::string &result)
Check if the class name is present in TClassTable.
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)
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 std::string AlternateTuple(const char *classname, const cling::LookupHelper &lh, Bool_t silent)
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)
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
#define R__ASSERT(e)
Checks condition e and reports a fatal error if it's false.
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
errors with level below this value will be ignored. Default is kUnset.
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 data
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 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
Int_t gDebug
Global variable setting the debug level. Set to 0 to disable, increase it in steps of 1 to increase t...
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)
const_iterator begin() const
const_iterator end() const
virtual std::unique_ptr< StateDelta > Rewind(const State &earlierState)=0
virtual void Apply(std::unique_ptr< StateDelta > &&delta)=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.
void RemoveStreamerInfo(Int_t slot)
Remove and delete the StreamerInfo in the given slot.
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)
static Bool_t HasNoInfoOrEmuOrFwdDeclaredDecl(const char *)
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
ClassInfo_t * GetClassInfo() const
TVirtualCollectionProxy * GetCollectionProxy() const
Return the proxy describing the collection (if any).
void ResetCaches()
To clean out all caches.
static Int_t ReadRules()
Read the class.rules files from the default location:.
std::atomic< Bool_t > fCanLoadClassInfo
Whether info was loaded from a root pcm.
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 * Name() const
Emulation of the CINT CallFunc class.
void SetArgs(const char *args)
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
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)
void FullName(std::string &output, const ROOT::TMetaUtils::TNormalizedCtxt &normCtxt) 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
TClingMethodInfo GetMethod(const char *fname) const
const clang::ValueDecl * GetDataMember(const char *name) const
Emulation of the CINT DataMemberInfo class.
virtual const char * Name() const
virtual bool IsValid() 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
Emulation of the CINT MethodInfo class.
TDictionary::DeclId_t GetDeclId() const
Emulation of the CINT TypeInfo class.
Emulation of the CINT TypedefInfo class.
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
bool IsIntegerType(const void *QualTypePtr) 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
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.
bool IsSameType(const void *QualTypePtr1, const void *QualTypePtr2) const final
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.
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
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
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
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
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
bool IsSignedIntegerType(const void *QualTypePtr) 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...
bool IsVoidPointerType(const void *QualTypePtr) const final
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
bool IsFloatingType(const void *QualTypePtr) 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
TypeInfo_t * MethodArgInfo_TypeInfo(MethodArgInfo_t *marginfo) const final
Bool_t fHeaderParsingOnDemand
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 SetClassInfo(TClass *cl, Bool_t reload=kFALSE, Bool_t silent=kFALSE) final
Set pointer to the TClingClassInfo in TClass.
void CallFunc_Exec(CallFunc_t *func, void *address) const final
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.
bool IsUnsignedIntegerType(const void *QualTypePtr) const final
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
bool IsValid() const final
Check if constructor exited correctly, ie the instance is in a valid state.
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.
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
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)
void * TypeInfo_QualTypePtr(TypeInfo_t *tinfo) const final
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)
bool IsPointerType(const void *QualTypePtr) const final
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.
All ROOT classes may have RTTI (run time type identification) support added.
Basic data type descriptor (datatype information is obtained from CINT).
EMemberSelection
Kinds of members to include in lists.
TDirectory::TContext keeps track and restore the current directory.
The TEnumConstant class implements the constants of the enum type.
The TEnum class implements the enum type.
static TEnum * GetEnum(const std::type_info &ti, ESearchAction sa=kALoadAndInterpLookup)
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...
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...
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
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.
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.
The TNamed class is the base class for all named ROOT classes.
const char * GetName() const override
Returns name of object.
virtual void Expand(Int_t newSize)
Expand or shrink the array to newSize elements.
virtual void Compress()
Remove empty slots from array.
Int_t GetEntries() const override
Return the number of objects in array (i.e.
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 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.
Describes a persistent version of a class.
const char * Data() const
TString & ReplaceAll(const TString &s1, const TString &s2)
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
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.
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.
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()
Namespace for new ROOT classes and functions.
R__EXTERN TVirtualRWMutex * gCoreMutex
@ kWarning
Warnings about likely unexpected behavior.
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.
bool IsUniquePtr(std::string_view name)
EComplexType GetComplexType(const char *)
RAII used to store Parser, Sema, Preprocessor state for recursive parsing.
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.