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)
1441#ifdef CLING_WITH_ADAPTIVECPP
1452 std::optional<std::string>
EnvOpt = llvm::sys::Process::GetEnv(
"EXTRA_CLING_ARGS");
1453 if (
EnvOpt.has_value()) {
1455 while (!
Env.empty()) {
1457 std::tie(Arg,
Env) =
Env.split(
' ');
1463 std::optional<std::string>
EnvOpt = llvm::sys::Process::GetEnv(
EnvVar);
1464 if (
EnvOpt.has_value()) {
1466 while (!
Env.empty()) {
1470 Paths.push_back(Arg.str());
1476 std::vector<std::string>
Paths;
1483 for (
const std::string& P :
Paths)
1490 EnvOpt = llvm::sys::Process::GetEnv(
"ROOT_CLING_TIMING");
1513 EnvOpt = llvm::sys::Process::GetEnv(
"CLING_MODULES_CACHE_PATH");
1516 assert(llvm::sys::fs::exists(
Env) &&
"Path does not exist!");
1538 interpArgs.push_back(
"-fno-implicit-module-maps");
1568 std::vector<std::string>
_empty;
1570 for (
const auto &arg: args)
1574 cling::Interpreter::ModuleFileExtensions
extensions;
1575 EnvOpt = llvm::sys::Process::GetEnv(
"ROOTDEBUG_RDICT");
1577 extensions.push_back(std::make_shared<TClingRdictModuleFileExtension>());
1590 Cpp::UseExternalInterpreter((Cpp::TInterp_t*)
fInterpreter.get());
1593 fInterpreter->getCI()->getPreprocessorOpts().DisablePCHOrModuleValidation =
1594 DisableValidationForModuleKind::All;
1598 fInterpreter->getCI()->getLangOpts().SpellChecking =
false;
1632 fInterpreter->getRuntimeOptions().AllowRedefinition = 1;
1633 auto &Policy =
const_cast<clang::PrintingPolicy &
>(
fInterpreter->getCI()->getASTContext().getPrintingPolicy());
1637 Policy.SplitTemplateClosers =
true;
1639 Policy.SuppressDefaultTemplateArgs =
false;
1645 std::unique_ptr<TClingCallbacks>
1652 cling::DynamicLibraryManager&
DLM = *
fInterpreter->getDynamicLibraryManager();
1658 llvm::StringRef
stem = llvm::sys::path::stem(FileName);
1659 return stem.starts_with(
"libNew") ||
stem.starts_with(
"libcppyy_backend");
1738 ::Error(
"TCling::RegisterRdictForLoadPCM",
"Rdict '%s' is both in Module extension and in File system.",
pcmFileNameFullPath.c_str());
1765 ::Info(
"TCling::LoadPCMImpl",
"reading protoclasses for %s \n",
pcmFile.GetName());
1838 ::Error(
"TCling::LoadPCM",
"Inconsistent TClassTable for %s",
proto->GetName());
1843 ncl->PostLoadCheck();
1915 ::Error(
"TCling::LoadPCM",
"ROOT PCM %s file does not exist",
1919 ::Info(
"TCling::LoadPCM",
"In-memory ROOT PCM candidate %s\n",
1920 rdict.first.c_str());
1925 Fatal(
"LoadPCM",
"The file %s is not a ROOT as was expected\n",
pcmFileName.Data());
1935 using namespace clang;
1937 class ExtLexicalStorageAdder:
public RecursiveASTVisitor<ExtLexicalStorageAdder>{
1942 bool VisitRecordDecl(clang::RecordDecl*
rcd){
1944 Info(
"ExtLexicalStorageAdder",
1945 "Adding external lexical storage to class %s",
1946 rcd->getNameAsString().c_str());
1949 reDeclPtr->setHasExternalLexicalStorage();
1985 if (!
HS.loadModuleMapFile(*
FE,
false))
2004 "libforward_listDict",
2012 "libunordered_setDict",
2013 "libunordered_multisetDict",
2014 "libunordered_mapDict",
2015 "libunordered_multimapDict",
2050 if (
ncl)
ncl->PostLoadCheck();
2094 Info(
"TCling::RegisterModule",
2095 "Header parsing on demand is active but this is an Aclic library. Disabling it for this library.");
2113 cling::Transaction* T =
nullptr;
2120 "A fwd declaration could not be compiled");
2121 if (
compRes!=cling::Interpreter::kSuccess){
2122 Warning(
"TCling::RegisterModule",
2123 "Problems in declaring string '%s' were encountered.",
2146 ::Error(
"TCling::RegisterModule",
"Dictionary trigger function for %s not found",
modulename);
2184 std::vector<std::string>
scopes;
2188 if (
enumPos != std::string::npos) {
2206 clang::DeclContext*
DC =
nullptr;
2233 = cling::utils::Lookup::Named(&
fInterpreter->getSema(),
2251 "The forward declarations could not be compiled");
2252 if (
compRes!=cling::Interpreter::kSuccess){
2253 Warning(
"TCling::RegisterModule",
2254 "Problems in compiling forward declarations for module %s: '%s'",
2263 ExtLexicalStorageAdder
elsa;
2265 cling::Transaction::DelayCallInfo&
dci = *
dciIt;
2303 Info(
"TCling::RegisterModule",
2304 "Adding a header for %s", temp.c_str());
2327 clang::Preprocessor &
PP =
TheSema.getPreprocessor();
2345 Info(
"TCling::RegisterModule",
"Module %s in modulemap failed to load.",
ModuleName.c_str());
2366#if defined(R__MUST_REVISIT)
2367#if R__MUST_REVISIT(6,2)
2368 Warning(
"TCling::RegisterModule",
"Diagnostics suppression should be gone by now.");
2383 "Payload code of a dictionary could not be parsed correctly.");
2384 if (
compRes!=cling::Interpreter::kSuccess) {
2385 Warning(
"TCling::RegisterModule",
2386 "Problems declaring payload for module %s.",
modulename) ;
2402 "#undef __ROOTCLING__\n"
2426 std::unique_ptr<IdentifierIterator> Iter(External->getIdentifiers());
2427 for (llvm::StringRef
Ident = Iter->Next(); !
Ident.empty();
Ident = Iter->Next()) {
2428 std::string
I =
Ident.str();
2429 if (!
Idents.Contains(
I.data()))
2452 typedef std::vector<std::pair<TClass*,DictFuncPtr_t> >::iterator iterator;
2458 if ( i->first ==
oldcl ) {
2482 cling::Interpreter::CompilationResult&
compRes,
2488 catch (cling::InterpreterException&
ex)
2490 Error(
"HandleInterpreterException",
"%s\n%s",
ex.what(),
"Execution of your code was aborted.");
2492 compRes = cling::Interpreter::kFailure;
2501 if (
auto ie =
dynamic_cast<const cling::InterpreterException*
>(&
e)) {
2527 gROOT->SetLineIsProcessing();
2531 gROOT->SetLineHasBeenProcessed();
2544 gROOT->SetLineIsProcessing();
2547 cling::Interpreter* fInterpreter;
2554 fInterpreter->enableDynamicLookup(
true);
2558 gROOT->SetLineHasBeenProcessed();
2567 cling::Interpreter::CompilationResult
compRes = cling::Interpreter::kSuccess;
2588 compRes = cling::Interpreter::kFailure;
2593 if (arguments.
Length() == 0) {
2606 }
else if (cling::DynamicLibraryManager::isSharedLibrary(
fname.Data()) &&
2610 compRes = cling::Interpreter::kFailure;
2612 if (arguments.
Length() == 0) {
2643 std::ifstream
in(
fname, std::ifstream::binary);
2649 = cling::utils::isUnnamedMacro(code,
fInterpreter->getCI()->getLangOpts());
2688 case cling::Interpreter::kSuccess: *error =
kNoError;
break;
2689 case cling::Interpreter::kFailure: *error =
kRecoverable;
break;
2690 case cling::Interpreter::kMoreInputExpected: *error =
kProcessing;
break;
2693 if (
compRes == cling::Interpreter::kSuccess
2724 if (path[0] ==
'-' && path[1] ==
'I')
2729 if (
sPath.BeginsWith(
"/")) {
2776 const char*
cobj = (
const char*) obj;
2816 static clang::PrintingPolicy
2821 printPol.SuppressInitializers =
true;
2842 Error(
"InspectMembers",
"Cannot find Decl for class %s",
clname);
2846 = llvm::dyn_cast<const clang::CXXRecordDecl>(
scopeDecl);
2848 Error(
"InspectMembers",
"Cannot find Decl for class %s is not a CXXRecordDecl.",
clname);
2872 Error(
"InspectMembers",
"TClass and cling disagree on the size of the class %s, respectively %d %lld\n",
2894 printPol.AnonymousTagLocations =
false;
2897 Error(
"InspectMembers",
2898 "Cannot retrieve QualType for member %s while inspecting class %s",
2907 printPol.AnonymousTagLocations =
false;
2910 Error(
"InspectMembers",
2911 "Cannot retrieve Type for member %s while inspecting class %s",
2920 clang::QualType
ptrQT
2927 if (
ptrQT.isNull()) {
2931 printPol.AnonymousTagLocations =
false;
2934 Error(
"InspectMembers",
2935 "Cannot retrieve pointee Type for member %s while inspecting class %s",
2943 llvm::SmallString<8> arraySize;
2951 clang::dyn_cast<clang::ConstantArrayType>(
arrType);
2961 printPol.AnonymousTagLocations =
false;
2964 Error(
"InspectMembers",
2965 "Cannot retrieve QualType for array level %d (i.e. element type of %s) for member %s while inspecting class %s",
2979 if (
memType->isPointerType()) {
2984 std::string ioname(
iField->getName());
3002 if (!
insp.IsTreatingNonAccessibleTypes()){
3031 if (!
mbr || !
mbr->IsPersistent())
3032 insp.IncrementNestedTransient();
3035 if (!
mbr || !
mbr->IsPersistent())
3036 insp.DecrementNestedTransient();
3045 for (clang::CXXRecordDecl::base_class_const_iterator
iBase
3050 Error(
"InspectMembers",
3051 "Cannot find QualType for base number %d while inspecting class %s",
3055 const clang::CXXRecordDecl*
baseDecl
3056 =
baseQT->getAsCXXRecordDecl();
3058 Error(
"InspectMembers",
3059 "Cannot find CXXRecordDecl for base number %d while inspecting class %s",
3084 Error(
"InspectMembers",
3090 if (
iBase->isVirtual()) {
3093 Error(
"InspectMembers",
3094 "Base %s of class %s is virtual but no object provided",
3106 Error(
"InspectMembers",
3107 "Error calculating offset of virtual base %s of class %s",
3111 Error(
"InspectMembers",
3112 "Cannot calculate offset of virtual base %s of class %s",
3121 if (
baseCl->IsLoaded()) {
3202 return fInterpreter->getDynamicLibraryManager()->isLibraryLoaded(
tLibName.Data());
3227 clang::ModuleMap &
moduleMap =
fInterpreter->getCI()->getPreprocessor().getHeaderSearchInfo().getModuleMap();
3229 return M && !M->IsUnimportable && M->getASTFile();
3248 size_t at = std::string::npos;
3249 while ((at = file_name.find(
"/./")) != std::string::npos)
3250 file_name.replace(at, 3,
"/");
3254 clang::SourceManager &
SM =
fInterpreter->getCI()->getSourceManager();
3255 cling::ClangInternalState::printIncludedFiles(
filesOS,
SM);
3258 llvm::SmallVector<llvm::StringRef, 100>
files;
3261 std::set<std::string>
fileMap;
3281 incPath.Append(
":").Prepend(
" ");
3282 incPath.ReplaceAll(
" -I",
":");
3283 while (
incPath.Index(
" :") != -1) {
3284 incPath.ReplaceAll(
" :",
":");
3298 clang::ConstSearchDirIterator *
CurDir =
nullptr;
3299 clang::Preprocessor &
PP =
fInterpreter->getCI()->getPreprocessor();
3300 clang::HeaderSearch &
HS =
PP.getHeaderSearchInfo();
3301 auto FE =
HS.LookupFile(file_name.c_str(),
3302 clang::SourceLocation(),
3305 clang::ArrayRef<std::pair<clang::OptionalFileEntryRef,
3306 clang::DirectoryEntryRef>>(),
3319 clang::SourceManager &
SM =
fInterpreter->getCI()->getSourceManager();
3321 clang::FileID
FID =
SM.translateFile(*
FE);
3322 if (!
FID.isInvalid() &&
FID.getHashValue() == 0)
3325 clang::SrcMgr::SLocEntry
SLocE =
SM.getSLocEntry(
FID);
3326 if (
SLocE.isFile() && !
SLocE.getFile().getContentCache().getBufferIfLoaded())
3328 if (!
FID.isInvalid())
3342#if defined(R__MACOSX)
3352 const char *
mapfile =
nullptr;
3354 mapfile =
"/System/Library/dyld/dyld_shared_cache_x86_64.map";
3356 mapfile =
"/System/Library/dyld/dyld_shared_cache_arm64e.map";
3358 #error unsupported architecture
3363 if (
line.find(lib) != std::string::npos) {
3375#if defined (R__LINUX) || defined (R__FBSD)
3386 auto newLibs =
static_cast<std::vector<std::string>*
>(
data);
3389 if (
info->dlpi_name &&
info->dlpi_name[0]
3398 &&
strncmp(
info->dlpi_name,
"/libexec/ld-elf.so.1", 20)
3401 &&
strncmp(
info->dlpi_name,
"linux-vdso32.so", 15)
3402 &&
strncmp(
info->dlpi_name,
"linux-vdso64.so", 15)
3418#if defined(R__WIN32) || defined(__CYGWIN__)
3426 for (i = 1; i < (
cbModules /
sizeof(
void *)); i++) {
3427 static const int bufsize = 260;
3431#if defined(__CYGWIN__)
3443#elif defined(R__MACOSX)
3458#elif defined(R__LINUX) || defined(R__FBSD)
3462 std::vector<std::string>
newLibs;
3467 Error(
"TCling::UpdateListOfLoadedSharedLibraries",
3468 "Platform not supported!");
3490 cling::DynamicLibraryManager*
DLM =
fInterpreter->getDynamicLibraryManager();
3495#if defined(R__MACOSX)
3546#elif defined(__CYGWIN__)
3548 static const int bufsize = 260;
3550 char *
windir = std::getenv(
"WINDIR");
3558#elif defined(R__WIN32)
3561#elif defined (R__LINUX)
3589 cling::DynamicLibraryManager*
DLM =
fInterpreter->getDynamicLibraryManager();
3591 cling::DynamicLibraryManager::LoadLibResult res
3592 = cling::DynamicLibraryManager::kLoadLibNotFound;
3599 cling::Interpreter::CompilationResult
compRes;
3601 if (
compRes == cling::Interpreter::kSuccess)
3602 res = cling::DynamicLibraryManager::kLoadLibSuccess;
3606 if (res == cling::DynamicLibraryManager::kLoadLibSuccess) {
3610 case cling::DynamicLibraryManager::kLoadLibSuccess:
return 0;
3611 case cling::DynamicLibraryManager::kLoadLibAlreadyLoaded:
return 1;
3661 Warning(
"Calc",
"waiting for cling thread to free");
3664 gROOT->SetLineIsProcessing();
3672 cling::Interpreter::CompilationResult
cr = cling::Interpreter::kFailure;
3676 catch (cling::InterpreterException&
ex)
3678 Error(
"Calc",
"%s.\n%s",
ex.what(),
"Evaluation of your expression was aborted.");
3680 cr = cling::Interpreter::kFailure;
3683 if (
cr != cling::Interpreter::kSuccess) {
3707 gROOT->SetLineHasBeenProcessed();
3722#if defined(R__MUST_REVISIT)
3723#if R__MUST_REVISIT(6,2)
3724 Warning(
"SetGetline",
"Cling should support the equivalent of SetGetlineFunc(getlineFunc, histaddFunc)");
3737 if ((std::distance(T.decls_begin(), T.decls_end()) != 1)
3738 || T.deserialized_decls_begin() != T.deserialized_decls_end()
3739 || T.macros_begin() != T.macros_end()
3740 || ((!T.getFirstDecl().isNull()) && ((*T.getFirstDecl().begin()) != T.getWrapperFD()))) {
3781#if defined(R__MUST_REVISIT)
3782#if R__MUST_REVISIT(6,2)
3784 Warning(
"Reset",
"Cling should support the equivalent of scratch_upto(&fDictPos)");
3794#if defined(R__MUST_REVISIT)
3795#if R__MUST_REVISIT(6,2)
3797 Warning(
"ResetAll",
"Cling should support the equivalent of complete reset (unload everything but the startup decls.");
3824#if defined(R__MUST_REVISIT)
3825#if R__MUST_REVISIT(6,2)
3827 Warning(
"ResetGlobalVar",
"Cling should support the equivalent of resetglobalvar(obj)");
3839#if defined(R__MUST_REVISIT)
3840#if R__MUST_REVISIT(6,2)
3842 Warning(
"RewindDictionary",
"Cling should provide a way to revert transaction similar to rewinddictionary()");
3853#if defined(R__MUST_REVISIT)
3854#if R__MUST_REVISIT(6,2)
3856 Warning(
"DeleteGlobal",
"Cling should provide the equivalent of deleteglobal(obj), see also DeleteVariable.");
3868#if defined(R__MUST_REVISIT)
3869#if R__MUST_REVISIT(6,2)
3870 Warning(
"DeleteVariable",
"should do more that just reseting the value to zero");
3878 const clang::DeclContext*
declCtx =
nullptr;
3879 if (
posScope != llvm::StringRef::npos) {
3883 cling::LookupHelper::WithDiagnostics);
3885 Error(
"DeleteVariable",
"Cannot find enclosing scope for variable %s",
3891 Error(
"DeleteVariable",
3892 "Enclosing scope for variable %s is not a declaration context",
3903 Error(
"DeleteVariable",
"Unknown variable %s",
name);
3908 Error(
"DeleteVariable",
"Entity %s is not a variable",
name);
3913 const clang::Type*
type =
qType->getUnqualifiedDesugaredType();
3916 if (
type->isPointerType()) {
3929#if defined(R__MUST_REVISIT)
3930#if R__MUST_REVISIT(6,2)
3932 Warning(
"SaveContext",
"Cling should provide a way to record a state watermark similar to store_dictposition(&fDictPos)");
3942#if defined(R__MUST_REVISIT)
3943#if R__MUST_REVISIT(6,2)
3945 Warning(
"SaveGlobalsContext",
"Cling should provide a way to record a watermark for the list of global variable similar to store_dictposition(&fDictPosGlobals)");
3993 std::tuple<int,double>
value;
4022 if (
lh.findScope(fullname, cling::LookupHelper::NoDiagnostics,
4038 Error(
"Load",
"Could not declare alternate type for %s since %s (or one of its context) is private or protected",
4039 classname, iter->c_str());
4048 std::ostringstream guard;
4049 guard <<
"ROOT_INTERNAL_TEmulated_";
4056 alternateTuple <<
"template <class... Types> struct TEmulatedTuple;\n";
4084 Fatal(
"TCling::SetClassInfo::AlternateTuple",
4085 "Layout of std::tuple on this platform is unexpected.");
4154 if (
strncmp(cl->
GetName(),
"tuple<",std::char_traits<char>::length(
"tuple<"))==0) {
4157 if (reload ||
name.empty()) {
4170 if (!
info->IsValid()) {
4190 if (!
info->IsLoaded()) {
4248 static const char *
anonEnum =
"anonymous enum ";
4276 const char *classname =
name;
4312 const clang::Type *
type =
nullptr;
4313 const clang::Decl *
decl
4314 =
lh.findScope(classname,
4315 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4316 : cling::LookupHelper::NoDiagnostics,
4321 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4322 : cling::LookupHelper::NoDiagnostics,
4339 clang::ClassTemplateSpecializationDecl *
tmpltDecl =
4340 llvm::dyn_cast_or_null<clang::ClassTemplateSpecializationDecl>
4341 (
type->getAsCXXRecordDecl());
4353 if (!
tci.IsValid()) {
4422 const clang::Decl *
decl
4423 =
lh.findClassTemplate(
name,
4424 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4425 : cling::LookupHelper::NoDiagnostics);
4427 std::string
strname =
"std::";
4430 gDebug > 5 ? cling::LookupHelper::WithDiagnostics
4431 : cling::LookupHelper::NoDiagnostics);
4433 return nullptr !=
decl;
4473 D =
fInterpreter->getCI()->getASTContext().getTranslationUnitDecl();
4484 for (clang::DeclContext::decl_iterator
DI = (*declIter)->decls_begin(),
4485 DE = (*declIter)->decls_end();
DI !=
DE; ++
DI) {
4490 llvm::raw_string_ostream stream(buf);
4492 Policy.AnonymousTagLocations =
false;
4493 ED->getNameForDiagnostic(stream, Policy,
false);
4497 const char*
name = buf.c_str();
4521 D =
fInterpreter->getCI()->getASTContext().getTranslationUnitDecl();
4533 for (clang::DeclContext::decl_iterator
DI = (*declIter)->decls_begin(),
4534 DE = (*declIter)->decls_end();
DI !=
DE; ++
DI) {
4549 return ci->GetUsingNamespaces();
4594 if (
m->fMethodArgs) {
4650 if (llvm::isa<clang::NamespaceDecl>(
cli->GetDecl())) {
4657 if (!
mi.IsValid()) {
4659 Error(
"GenerateTClass",
4660 "Cannot find %s::Class_Version()! Class version might be wrong.",
4677 Error(
"GenerateTClass",
4678 "Cannot invoke %s::Class_Version()! Class version might be wrong.",
4703 const clang::ClassTemplateSpecializationDecl *
templateCl
4704 = llvm::dyn_cast<clang::ClassTemplateSpecializationDecl>(
info->GetDecl());
4706 for(
unsigned int i=0; i <
templateCl->getTemplateArgs().
size(); ++i) {
4707 const clang::TemplateArgument &arg(
templateCl->getTemplateArgs().get(i) );
4708 if (arg.getKind() == clang::TemplateArgument::Type) {
4711 if (!
uType->isFundamentalType() && !
uType->isEnumeralType()) {
4713 const clang::CXXRecordDecl *
argdecl =
uType->getAsCXXRecordDecl();
4720 llvm::raw_string_ostream
OS(Result);
4721 arg.print(
argdecl->getASTContext().getPrintingPolicy(),
OS);
4722 Warning(
"TCling::GenerateTClass",
"Missing header file for %s",
OS.str().c_str());
4738 Fatal(
"GenerateTClass",
"Requires a valid ClassInfo object");
4743 std::string classname;
4747 Info(
"GenerateTClass",
"Will (try to) generate the compiled TClass for %s.",classname.c_str());
4757 Error(
"GenerateTClass",
"Even though the dictionary generation for %s seemed successful we can't find the TClass bootstrap!",classname.c_str());
4761 if (cl ==
nullptr) {
4793 if (classes ==
nullptr || classes[0] == 0) {
4794 Error(
"TCling::GenerateDictionary",
"Cannot generate dictionary without passing classes.");
4800 const char* current = classes, *prev = classes;
4804 if (*current ==
';') {
4805 listClasses.push_back(std::string(prev, current - prev));
4808 else if (*(current + 1) == 0) {
4809 listClasses.push_back(std::string(prev, current + 1 - prev));
4821 if (*current ==
';') {
4822 listIncludes.push_back(std::string(prev, current - prev));
4825 else if (*(current + 1) == 0) {
4826 listIncludes.push_back(std::string(prev, current + 1 - prev));
4832 std::vector<std::string>(), std::vector<std::string>());
4871 using namespace clang;
4876 Sema::ForExternalRedeclaration);
4878 cling::utils::Lookup::Named(&
SemaR,
R);
4880 LookupResult::Filter F =
R.makeFilter();
4882 while (F.hasNext()) {
4891 if (
R.isSingleResult())
4892 return R.getFoundDecl();
4909 const clang::DeclContext*
dc =
nullptr;
4910 if (
const clang::Decl* D =
cci->GetDecl()) {
4921 Error(
"TCling::GetEnum",
"DeclContext not found for %s .\n",
name);
4942 if (!
gv)
return nullptr;
4968 if (!
strncmp(
scopename.c_str(),
"typeinfo for ",
sizeof(
"typeinfo for ")-1)) {
4969 scopename.erase(0,
sizeof(
"typeinfo for ")-1);
4970 }
else if (!
strncmp(
scopename.c_str(),
"vtable for ",
sizeof(
"vtable for ")-1)) {
4971 scopename.erase(0,
sizeof(
"vtable for ")-1);
4974 std::string::size_type pos =
scopename.rfind(
'(');
4975 if (pos != std::string::npos) {
4980 if (pos != std::string::npos) {
4981 if ((pos != 0) && (
scopename[pos-1] ==
':')) {
5011 Error(
"GetDataMemberWithValue()",
"not implemented");
5021 Error(
"GetDataMemberAtAddr()",
"not implemented");
5117 std::vector<DeclId_t>& res)
const
5120 clang::ASTContext&
Ctx = S.Context;
5123 Ctx.getTranslationUnitDecl();
5131 clang::DeclarationName
DName;
5138 DName =
Ctx.DeclarationNames.getCXXConstructorName(
Ctx.getCanonicalType(
QT));
5141 DName =
Ctx.DeclarationNames.getCXXDestructorName(
Ctx.getCanonicalType(
QT));
5150 clang::LookupResult
R(S,
DName, clang::SourceLocation(),
5151 Sema::LookupOrdinaryName, clang::Sema::NotForRedeclaration);
5152 R.suppressDiagnostics();
5154 if (
R.empty())
return;
5156 res.reserve(res.size() + (
R.end() -
R.begin()));
5159 if (
const clang::FunctionDecl*
FD
5160 = llvm::dyn_cast<const clang::FunctionDecl>(*
IR)) {
5161 if (!
FD->getDescribedFunctionTemplate()) {
5164 }
else if (
const auto *
USD = llvm::dyn_cast<const clang::UsingShadowDecl>(*
IR)) {
5166 if (llvm::isa<clang::FunctionDecl>(
USD->getTargetDecl())) {
5346 const char* params,
int* error)
5363 Error(
"Execute",
"No method was defined");
5373 Error(
"Execute",
"Too many parameters to call %s, got %d but expected at most %d.",
method->GetName(),
argc,
nparms);
5397 Error(
"Execute",
"Too few arguments to call %s, got only %d but expected %d.",
method->GetName(),
argc,
nparms);
5417 chpar += (
nxtpar->String()).ReplaceAll(
"\"",
"\\\"");
5454 const void* args[] ,
5459 Error(
"ExecuteWithArgsAndReturn",
"No method was defined");
5486 Warning(
"GetTopLevelMacroName",
"Must change return type!");
5533#if defined(R__MUST_REVISIT)
5534#if R__MUST_REVISIT(6,0)
5535 Warning(
"GetCurrentMacroName",
"Must change return type!");
5573 auto l = t.length();
5574 while (
l > 0 && (t[
l - 1] ==
'*' || t[
l - 1] ==
'&'))
5585 libName.consume_back(
".rootmap");
5605 const std::map<char, unsigned int>
keyLenMap = {{
'c',6},{
'n',10},{
't',8},{
'h',7},{
'e',5},{
'v',4}};
5625 if (!
newFormat && (
line.compare(0, 8,
"Library.") == 0 ||
line.compare(0, 8,
"Declare.") == 0)) {
5631 if (
line.compare(0, 9,
"{ decls }") == 0) {
5638 Error(
"ReadRootmapFile",
"Cannot handle \"{ decls }\" sections in custom rootmap file %s",
5651 if (
brpos == string::npos)
5684 Info(
"ReadRootmapFile",
5685 "While processing %s, namespace %s was found to be associated to %s although it is already "
5694 "While processing %s, %s %s was found to be associated to %s although it is already "
5701 Info(
"ReadRootmapFile",
"While processing %s, key %s was found to be already defined for %s",
5763 using namespace clang;
5765 class ExtVisibleStorageAdder:
public RecursiveASTVisitor<ExtVisibleStorageAdder>{
5771 ExtVisibleStorageAdder(std::unordered_set<const NamespaceDecl*>&
nsSet): fNSSet(
nsSet) {};
5777 nsDecl->setHasExternalVisibleStorage();
5786 specDecl->setHasExternalLexicalStorage();
5798 std::unordered_set<const NamespaceDecl*>& fNSSet;
5841 for (
Int_t i = 0; i <
paths->GetEntriesFast(); i++) {
5856 Info(
"LoadLibraryMap",
"%s",
d.Data());
5861 if (
f.EndsWith(
".rootmap")) {
5867 Info(
"LoadLibraryMap",
" rootmap file: %s",
p.Data());
5885 if (
f.BeginsWith(
"rootmap")) {
5890 Warning(
"LoadLibraryMap",
"please rename %s to end with \".rootmap\"",
p.Data());
5910 else if (res == -3) {
5920 while ((rec = (
TEnvRec*) next())) {
5922 if (!
strncmp(
cls.Data(),
"Library.", 8) &&
cls.Length() > 8) {
5934 cls.ReplaceAll(
"@@",
"::");
5937 cls.ReplaceAll(
"-",
" ");
5941 Info(
"LoadLibraryMap",
"class %s in %s",
cls.Data(),
wlib);
5944 Info(
"LoadLibraryMap",
"class %s in %s (library does not exist)",
cls.Data(), lib);
5950 else if (!
strncmp(
cls.Data(),
"Declare.", 8) &&
cls.Length() > 8) {
5954 cls.ReplaceAll(
"-",
" ");
5960 cling::Transaction* T =
nullptr;
5962 assert(cling::Interpreter::kSuccess ==
compRes &&
"A declaration in a rootmap could not be compiled");
5964 if (
compRes!=cling::Interpreter::kSuccess){
5972 if (
declIt->m_DGR.isSingleDecl()) {
5973 if (
Decl* D =
declIt->m_DGR.getSingleDecl()) {
5974 if (clang::isa<TagDecl>(D) || clang::isa<NamespaceDecl>(D)) {
6044 Error(
"ReloadAllSharedLibraryMaps",
"Could not find rootmap %s in path",
rootMapBaseStr.Data());
6051 Error(
"ReloadAllSharedLibraryMaps",
"Error loading map %s",
rootMap);
6099 while ((rec = (
TEnvRec *) next())) {
6101 if (
cls.Length() > 2) {
6110 if (!
strncmp(
cls.Data(),
"Library.", 8) &&
cls.Length() > 8) {
6114 cls.ReplaceAll(
"@@",
"::");
6117 cls.ReplaceAll(
"-",
" ");
6121 Error(
"UnloadLibraryMap",
"entry for <%s, %s> not found in library map table",
cls.Data(), lib);
6182 if (err)
return nullptr;
6233 for (
Int_t i = (
tokens->GetEntriesFast() - 1); i > 0; --i) {
6238 "loaded dependent library %s for %s",
deplib,
cls);
6243 "failure loading dependent library %s for %s",
6248 if (lib && lib[0]) {
6249 if (
gROOT->LoadClass(
cls, lib) == 0) {
6252 "loaded library %s for %s", lib,
cls);
6258 "failure loading library %s for %s", lib,
cls);
6279 if (!
visited.insert(std::string(
cls)).second)
6345 Info(
"TCling::AutoLoad",
"Explicitly disabled (the class name is %s)",
cls);
6365 Info(
"TCling::AutoLoad",
6366 "Trying to autoload for %s",
cls);
6371 Info(
"TCling::AutoLoad",
6372 "Disabled due to gROOT or gInterpreter being invalid/not ready (the class name is %s)",
cls);
6393 std::unordered_set<std::string>
visited;
6411 code += (
"#include \"");
6415 code += (
"#ifdef __ROOTCLING__\n"
6416 "#undef __ROOTCLING__\n"
6420 cling::Interpreter::CompilationResult
cr;
6430 #if defined(R__MUST_REVISIT)
6431 #if R__MUST_REVISIT(6,2)
6432 Warning(
"TCling::RegisterModule",
"Diagnostics suppression should be gone by now.");
6455 unsigned long offset = 0;
6514 Info(
"TCling::AutoParse",
6515 "Starting autoparse for %s\n",
apKey);
6520 const cling::Transaction *T =
fInterpreter->getCurrentTransaction();
6524 Info(
"TCling::AutoParse",
6525 "We can proceed for %s. We have %s headers.",
apKey, std::to_string(
hNamesPtrs.size()).c_str());
6535 "Parsing full payload for %s",
apKey);
6542 if (
cRes != cling::Interpreter::kSuccess) {
6543 if (
hName[0] ==
'\n')
6544 Error(
"AutoParse",
"Error parsing payload code for class %s with content:\n%s",
apKey,
hName);
6560 "Parsing single header %s",
hName);
6563 if (
cRes != cling::Interpreter::kSuccess) {
6564 Error(
"AutoParse",
"Error parsing headerfile %s for class %s.",
hName,
apKey);
6593 if (llvm::StringRef(
cls).contains(
"(lambda)"))
6607 Info(
"TCling::AutoParse",
6608 "Trying to autoparse for %s",
cls);
6639 if (
errMsg.contains(
"undefined symbol: ")) {
6643 cling::DynamicLibraryManager*
DLM =
fInterpreter->getDynamicLibraryManager();
6671 ::Error(
"TCling__LazyFunctionCreatorAutoloadForModule",
6672 "Failed to load library %s",
LibName.c_str());
6714 if (
cci->GetType()) {
6716 cci->Init(*
cci->GetType());
6719 Error(
"RefreshClassInfo",
"Should not need to update the classInfo a non type decl: %s",
oldDef->getNameAsString().c_str());
6773 if (!
tdDef->isCompleteDefinition() || llvm::isa<clang::FunctionDecl>(
tdDef->getDeclContext())) {
6790 clang::QualType
type(
tdDef->getTypeForDecl(), 0);
6793 canon = ns->getCanonicalDecl();
6794 name =
ND->getQualifiedNameAsString();
6796 name =
ND->getQualifiedNameAsString();
6851 if (!T.empty() && T.decls_begin() + 1 == T.decls_end() && !T.hasNestedTransactions()) {
6852 clang::Decl*
FirstDecl = *(T.decls_begin()->m_DGR.begin());
6853 if (llvm::isa<clang::TranslationUnitDecl>(
FirstDecl)) {
6862 const clang::Decl*
WrapperFD = T.getWrapperFD();
6865 if (
I->m_Call != cling::Transaction::kCCIHandleTopLevelDecl
6866 &&
I->m_Call != cling::Transaction::kCCIHandleTagDeclDefinition)
6882 E = T.deserialized_decls_end();
I != E; ++
I) {
6902 std::vector<TClass*>::iterator it;
6915 if (!
gROOT->GetListOfClasses()->FindObject(*
I)) {
6937 cling::Transaction::const_nested_iterator
iNested = T.nested_begin();
6940 if (
I->m_Call == cling::Transaction::kCCIHandleVTable)
6942 if (
I->m_Call == cling::Transaction::kCCINone) {
6948 for (
auto &D :
I->m_DGR)
6974 if (D->isFromASTFile())
6984 if (
LODM.GetClass())
7007 std::vector<TClass *> Classes;
7010 for (
auto &C : Classes) {
7019 if (D->getKind() != Decl::Namespace
7021 C->ResetClassInfo();
7042 Info(
"TransactionRollback",
7043 "Restoring ability to autoaparse: %s",
hName);
7080 using namespace clang;
7081 if (
const Decl *D =
LH.findScope(
cls, cling::LookupHelper::NoDiagnostics,
7083 if (!D->isFromASTFile()) {
7085 Warning(
"GetClassSharedLibsForModule",
"Decl found for %s is not part of a module",
cls);
7093 void Collect(
const Decl *D) { Visit(D); }
7105 if (!D->hasOwningModule())
7107 if (Module *M = D->getOwningModule()->getTopLevelModule())
7113 switch (
TA.getKind()) {
7114 case TemplateArgument::Null:
7115 case TemplateArgument::Integral:
7116 case TemplateArgument::Pack:
7117 case TemplateArgument::NullPtr:
7118 case TemplateArgument::StructuralValue:
7119 case TemplateArgument::Expression:
7120 case TemplateArgument::Template:
7121 case TemplateArgument::TemplateExpansion:
return;
7122 case TemplateArgument::Type:
7124 return Visit(
TagTy->getDecl());
7126 case TemplateArgument::Declaration:
return Visit(
TA.getAsDecl());
7133 if (
CTSD->getOwningModule())
7151 if (!M->LinkLibraries.size())
7156 assert(M->LinkLibraries.size() == 1);
7159 result += M->LinkLibraries[0].Library;
7182 llvm::StringRef className =
cls;
7188 if (className.contains(
"(lambda)"))
7194 if (!
libs.empty()) {
7241 cling::Interpreter *
interp,
7245 if (!llvm::sys::path::is_absolute(lib)) {
7247 Error(
"TCling__GetSharedLibImmediateDepsSlow",
"Cannot find library '%s'", lib.c_str());
7251 assert(llvm::sys::fs::exists(lib) &&
"Must exist!");
7252 lib = llvm::sys::path::filename(lib).str();
7255 auto ObjF = llvm::object::ObjectFile::createObjectFile(
LibFullPath.Data());
7257 Warning(
"TCling__GetSharedLibImmediateDepsSlow",
"Failed to read object file %s", lib.c_str());
7264 std::string Result = lib +
' ';
7265 for (
const auto &S :
BinObjFile->symbols()) {
7266 uint32_t
Flags = llvm::cantFail(S.getFlags());
7268 if (!(
Flags & llvm::object::SymbolRef::SF_Undefined))
7272 if (
Flags & llvm::object::SymbolRef::SF_Weak)
7274 llvm::Expected<StringRef>
SymNameErr = S.getName();
7276 Warning(
"GetSharedLibDepsForModule",
"Failed to read symbol");
7287 if (
SymName.contains(
"@GLIBCXX") ||
SymName.contains(
"@CXXABI") ||
7296 static constexpr llvm::StringRef
RegisterClasses(
"_Jv_RegisterClasses");
7308 if (llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(
SymNameForDlsym))
7313 std::string found =
interp->getDynamicLibraryManager()->searchLibrariesForSymbol(
SymName,
false);
7319 if (!found.empty()) {
7320 std::string
cand = llvm::sys::path::filename(found).str();
7324 Result +=
cand +
' ';
7335 if (!lib.starts_with(
"lib"))
7338 rootmapName.append(llvm::sys::path::filename(lib));
7339 llvm::sys::path::replace_extension(
rootmapName,
"rootmap");
7370 if (llvm::sys::path::is_absolute(lib) && !llvm::sys::fs::exists(lib))
7375 llvm::sys::path::replace_extension(
rootmapName,
"rootmap");
7385 Warning(
"TCling::GetSharedLibDeps",
"Precomputed dependencies available but scanning '%s'", lib);
7390 if (!
libs.empty()) {
7396 if (!
fMapfile || !lib || !lib[0]) {
7407 while ((rec = (
TEnvRec*) next())) {
7408 const char*
libs = rec->GetValue();
7423#if defined(R__MUST_REVISIT)
7424#if R__MUST_REVISIT(6,2)
7425 Warning(
"IsErrorMessagesEnabled",
"Interface not available yet.");
7437#if defined(R__MUST_REVISIT)
7438#if R__MUST_REVISIT(6,2)
7439 Warning(
"SetErrorMessages",
"Interface not available yet.");
7459 assert(!(
nPaths & 1) &&
"GetIncludePath, number of paths and options is not equal");
7461 for (
size_t i = 0; i <
nPaths; i += 2) {
7500 assert(
fout !=
nullptr &&
"DisplayIncludePath, 'fout' parameter is null");
7506 assert(!(
nPaths & 1) &&
"DisplayIncludePath, number of paths and options is not equal");
7509 for (
size_t i = 0; i <
nPaths; i += 2) {
7538#if defined(R__MUST_REVISIT)
7539#if R__MUST_REVISIT(6,2)
7540 Warning(
"GenericError",
"Interface not available yet.");
7568#if defined(R__MUST_REVISIT)
7569#if R__MUST_REVISIT(6,2)
7570 Warning(
"GetSecurityError",
"Interface not available yet.");
7583 cling::Interpreter::CompilationResult
compRes;
7585 return compRes == cling::Interpreter::kFailure;
7606 return buffer.c_str();
7687#if defined(R__MUST_REVISIT)
7688#if R__MUST_REVISIT(6,2)
7689 Warning(
"SetErrmsgcallback",
"Interface not available yet.");
7698 &
fInterpreter->getDiagnostics().getDiagnosticOptions(),
7700 [] (clang::DiagnosticsEngine::Level Level,
const std::string &
Info) {
7701 if (Level == clang::DiagnosticsEngine::Warning) {
7702 ::Warning(
"cling",
"%s", Info.c_str());
7703 }
else if (Level == clang::DiagnosticsEngine::Error
7704 || Level == clang::DiagnosticsEngine::Fatal) {
7712 fInterpreter->replaceDiagnosticConsumer(
nullptr);
7731 cling::DynamicLibraryManager*
DLM =
fInterpreter->getDynamicLibraryManager();
7737 cling::Interpreter::CompilationResult
compRes;
7739 return compRes == cling::Interpreter::kFailure;
7743 return std::unique_ptr<TInterpreterValue>(
new TClingValue);
7761 auto V =
reinterpret_cast<cling::Value*
>(
value.GetValAddr());
7763 return compRes!=cling::Interpreter::kSuccess ? 0 : 1 ;
7770 using namespace cling;
7784 if (
value.isValid() &&
value.needsManagedAllocation()) {
7817 Parser& P =
const_cast<Parser&
>(
fInterpreter->getParser());
7823 Tok.setKind(tok::semi);
7835 Error(
"GetObjectAddress",
"Got a special object without LookupCtx!");
7849 clang::CXXRecordDecl*
klass)
const
7851 using namespace clang;
7871 if (func)
return ((
TClingCallFunc*)func)->GetDecl()->getCanonicalDecl();
7942 f->Exec(address, &val);
7950 f->ExecWithReturn(address,
ret);
7956 const void* args[] ,
7961 f->ExecWithArgsAndReturn(address, args,
nargs,
ret);
7969 return f->ExecInt(address);
7977 return f->ExecInt64(address);
7985 return f->ExecDouble(address);
8008 return (MethodInfo_t*)
f->FactoryMethod();
8033 return f->IsValid();
8042 return f->IFacePtr();
8170 llvm::SmallVector<clang::QualType, 4>
funcProto;
8171 for (std::vector<TypeInfo_t*>::const_iterator iter =
proto.
begin(), end =
proto.
end();
8172 iter != end; ++iter) {
8185 llvm::SmallVector<clang::QualType, 4>
funcProto;
8186 for (std::vector<TypeInfo_t*>::const_iterator iter =
proto.
begin(), end =
proto.
end();
8187 iter != end; ++iter) {
8217 const clang::DeclContext *
ctxt =
nullptr;
8226 const clang::Decl *
decl =
reinterpret_cast<const clang::Decl*
>(
declid);
8230 const clang::DeclContext *
declDC =
decl->getDeclContext();
8233 if (
declDC->isTransparentContext()) {
8237 if (
const auto *
declRD = llvm::dyn_cast<clang::RecordDecl>(
declDC)) {
8238 if (
declRD->isAnonymousStructOrUnion()) {
8243 if (
const auto *
declNS = llvm::dyn_cast<clang::NamespaceDecl>(
declDC)) {
8244 if (
declNS->isAnonymousNamespace() ||
declNS->isInlineNamespace()) {
8692 const clang::Decl*
decl =
reinterpret_cast<const clang::Decl*
>(
declid);
8693 const clang::ValueDecl*
vd = llvm::dyn_cast_or_null<clang::ValueDecl>(
decl);
8810 decl->addAttr(AnnotateAttr::CreateImplicit(C,
attribute,
nullptr, 0));
8821 cling::Interpreter &
interp,
8824 const clang::TypeDecl*
td = llvm::dyn_cast<clang::TypeDecl>(
decl->getDeclContext());
8827 clang::QualType
qualType(
td->getTypeForDecl(),0);
8829 unsigned int level = 0;
8832 else if (
name[
cursor] ==
'<' && level) --level;
8833 else if (level == 0 &&
name[
cursor] ==
':') {
8846 const auto *
FD = llvm::dyn_cast<clang::FunctionDecl>(
decl);
8847 if (
const auto *
USD = llvm::dyn_cast<clang::UsingShadowDecl>(
decl)) {
8848 FD = llvm::dyn_cast<clang::FunctionDecl>(
USD->getTargetDecl());
8851 Error(
"GetFunctionName",
"NULL Decl!");
8858 if (llvm::isa<clang::CXXConstructorDecl>(
FD))
8862 }
else if (llvm::isa<clang::CXXDestructorDecl>(
decl))
8867 llvm::raw_string_ostream stream(
output);
8923 return t_info !=
nullptr;
8933 const clang::FunctionTemplateDecl *
ft = (
const clang::FunctionTemplateDecl*)
ft_info;
8934 return ft->getTemplateParameters()->size();
8944 const clang::FunctionTemplateDecl *
ft = (clang::FunctionTemplateDecl*)
ft_info;
8945 return ft->getTemplateParameters()->getMinRequiredArguments();
8958 const clang::FunctionTemplateDecl *
ft = (clang::FunctionTemplateDecl*)
ft_info;
8960 switch (
ft->getAccess()) {
8961 case clang::AS_public:
8964 case clang::AS_protected:
8967 case clang::AS_private:
8970 case clang::AS_none:
8971 if (
ft->getDeclContext()->isNamespace())
8976 assert(
false &&
"Unexpected value for the access property value in Clang");
8980 const clang::FunctionDecl *fd =
ft->getTemplatedDecl();
8982 if (fd && fd->getStorageClass() == clang::SC_Static)
8985 if (
const clang::CXXMethodDecl *
md =
8986 llvm::dyn_cast<clang::CXXMethodDecl>(fd)) {
8987 if (
md->getMethodQualifiers().hasConst()) {
8990 if (
md->isVirtual()) {
8993 if (
md->isPureVirtual()) {
8996 if (
const clang::CXXConstructorDecl *cd =
8997 llvm::dyn_cast<clang::CXXConstructorDecl>(
md)) {
8998 if (cd->isExplicit()) {
9002 else if (
const clang::CXXConversionDecl *cd =
9003 llvm::dyn_cast<clang::CXXConversionDecl>(
md)) {
9004 if (cd->isExplicit()) {
9023 const clang::FunctionTemplateDecl *
ft = (clang::FunctionTemplateDecl*)
ft_info;
9024 const clang::FunctionDecl *fd =
ft->getTemplatedDecl();
9026 if (fd->isOverloadedOperator())
9028 if (llvm::isa<clang::CXXConversionDecl>(fd))
9030 if (llvm::isa<clang::CXXConstructorDecl>(fd))
9032 if (llvm::isa<clang::CXXDestructorDecl>(fd))
9034 if (fd->isInlined())
9046 const clang::FunctionTemplateDecl *
ft = (clang::FunctionTemplateDecl*)
ft_info;
9059 const clang::FunctionTemplateDecl *
ft = (
const clang::FunctionTemplateDecl*)
ft_info;
9066 output = A->getAnnotation().str();
9070 if (!
ft->isFromASTFile()) {
9121 const clang::Decl*
decl =
reinterpret_cast<const clang::Decl*
>(
declid);
9139 return info->InterfaceMethod();
9147 return info->IsValid();
9155 return info->NArg();
9163 return info->NDefaultArg();
9171 return info->Next();
9180 return info->Property();
9189 return info->ExtraProperty();
9218 return info->GetPrototype();
9227 return info->Name();
9236 return info->TypeName();
9257 return info->Title();
9265 return MethodInfo_MethodCallReturnType(func->fInfo);
9267 return EReturnType::kOther;
9278 clang::QualType
QT(
typeinfo->GetQualType().getCanonicalType() );
9279 if (
QT->isEnumeralType()) {
9280 return EReturnType::kLong;
9281 }
else if (
QT->isPointerType()) {
9283 QT = llvm::cast<clang::PointerType>(
QT)->getPointeeType();
9284 if (
QT->isCharType() ) {
9285 return EReturnType::kString;
9287 return EReturnType::kOther;
9289 }
else if (
QT->isFloatingType() ) {
9291 if (
sz == 4 ||
sz == 8) {
9293 return EReturnType::kDouble;
9295 return EReturnType::kOther;
9297 }
else if (
QT->isIntegerType() ) {
9307 return EReturnType::kLong;
9309 return EReturnType::kOther;
9312 return EReturnType::kOther;
9315 return EReturnType::kOther;
9360 return info->IsValid();
9368 return info->Next();
9376 return info->Property();
9384 return info->DefaultValue();
9392 return info->Name();
9400 return info->TypeName();
9558 const char*
name)
const
9625 clang::QualType
QT1 = clang::QualType::getFromOpaquePtr(
QualTypePtr1);
9626 clang::QualType
QT2 = clang::QualType::getFromOpaquePtr(
QualTypePtr2);
9634 clang::QualType
QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9635 return QT->hasIntegerRepresentation();
9642 clang::QualType
QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9643 return QT->hasSignedIntegerRepresentation();
9650 clang::QualType
QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9651 return QT->hasUnsignedIntegerRepresentation();
9658 clang::QualType
QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9659 return QT->hasFloatingRepresentation();
9666 clang::QualType
QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9667 return QT->hasPointerRepresentation();
9674 clang::QualType
QT = clang::QualType::getFromOpaquePtr(QualTypePtr);
9675 return QT->isVoidPointerType();
9684 Error(
"SnapshotMutexState",
"fRecurseCount != 0 even though initial mutex state is unset!");
9700 Error(
"ForgetMutexState",
"mutex state's recurse count already 0!");
9730 Error(
"ApplyToInterpreterMutex",
9731 "After returning from user code that turned on thread safety support, we notice that fInitialMutex is already used ... "
9732 "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()
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.