Logo ROOT  
Reference Guide
TROOT.cxx
Go to the documentation of this file.
1// @(#)root/base:$Id$
2// Author: Rene Brun 08/12/94
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12/** \class TROOT
13\ingroup Base
14
15ROOT top level object description.
16
17The TROOT object is the entry point to the ROOT system.
18The single instance of TROOT is accessible via the global gROOT.
19Using the gROOT pointer one has access to basically every object
20created in a ROOT based program. The TROOT object is essentially a
21container of several lists pointing to the main ROOT objects.
22
23The following lists are accessible from gROOT object:
24
25~~~ {.cpp}
26 gROOT->GetListOfClasses
27 gROOT->GetListOfColors
28 gROOT->GetListOfTypes
29 gROOT->GetListOfGlobals
30 gROOT->GetListOfGlobalFunctions
31 gROOT->GetListOfFiles
32 gROOT->GetListOfMappedFiles
33 gROOT->GetListOfSockets
34 gROOT->GetListOfSecContexts
35 gROOT->GetListOfCanvases
36 gROOT->GetListOfStyles
37 gROOT->GetListOfFunctions
38 gROOT->GetListOfSpecials (for example graphical cuts)
39 gROOT->GetListOfGeometries
40 gROOT->GetListOfBrowsers
41 gROOT->GetListOfCleanups
42 gROOT->GetListOfMessageHandlers
43~~~
44
45The TROOT class provides also many useful services:
46 - Get pointer to an object in any of the lists above
47 - Time utilities TROOT::Time
48
49The ROOT object must be created as a static object. An example
50of a main program creating an interactive version is shown below:
51
52### Example of a main program
53
54~~~ {.cpp}
55 #include "TRint.h"
56
57 int main(int argc, char **argv)
58 {
59 TRint *theApp = new TRint("ROOT example", &argc, argv);
60
61 // Init Intrinsics, build all windows, and enter event loop
62 theApp->Run();
63
64 return(0);
65 }
66~~~
67*/
68
69#include <ROOT/RConfig.hxx>
71#include "RConfigure.h"
72#include "RConfigOptions.h"
73#include "RVersion.h"
74#include "RGitCommit.h"
75#include <string>
76#include <map>
77#include <cstdlib>
78#ifdef WIN32
79#include <io.h>
80#include "Windows4Root.h"
81#include <Psapi.h>
82#define RTLD_DEFAULT ((void *)::GetModuleHandle(NULL))
83//#define dlsym(library, function_name) ::GetProcAddress((HMODULE)library, function_name)
84#define dlopen(library_name, flags) ::LoadLibrary(library_name)
85#define dlclose(library) ::FreeLibrary((HMODULE)library)
86char *dlerror() {
87 static char Msg[1000];
88 FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
89 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), Msg,
90 sizeof(Msg), NULL);
91 return Msg;
92}
93FARPROC dlsym(void *library, const char *function_name)
94{
95 HMODULE hMods[1024];
96 DWORD cbNeeded;
97 FARPROC address = NULL;
98 unsigned int i;
99 if (library == RTLD_DEFAULT) {
100 if (EnumProcessModules(::GetCurrentProcess(), hMods, sizeof(hMods), &cbNeeded)) {
101 for (i = 0; i < (cbNeeded / sizeof(HMODULE)); i++) {
102 address = ::GetProcAddress((HMODULE)hMods[i], function_name);
103 if (address)
104 return address;
105 }
106 }
107 return address;
108 } else {
109 return ::GetProcAddress((HMODULE)library, function_name);
110 }
111}
112#else
113#include <dlfcn.h>
114#endif
115
116#include <iostream>
118#include "TROOT.h"
119#include "TClass.h"
120#include "TClassEdit.h"
121#include "TClassGenerator.h"
122#include "TDataType.h"
123#include "TStyle.h"
124#include "TObjectTable.h"
125#include "TClassTable.h"
126#include "TSystem.h"
127#include "THashList.h"
128#include "TObjArray.h"
129#include "TEnv.h"
130#include "TError.h"
131#include "TColor.h"
132#include "TGlobal.h"
133#include "TFunction.h"
134#include "TVirtualPad.h"
135#include "TBrowser.h"
136#include "TSystemDirectory.h"
137#include "TApplication.h"
138#include "TInterpreter.h"
139#include "TGuiFactory.h"
140#include "TMessageHandler.h"
141#include "TFolder.h"
142#include "TQObject.h"
143#include "TProcessUUID.h"
144#include "TPluginManager.h"
145#include "TVirtualMutex.h"
146#include "TListOfTypes.h"
147#include "TListOfDataMembers.h"
148#include "TListOfEnumsWithLock.h"
149#include "TListOfFunctions.h"
151#include "TFunctionTemplate.h"
152#include "ThreadLocalStorage.h"
153#include "TVirtualRWMutex.h"
154#include "TVirtualX.h"
155
156#if defined(R__UNIX)
157#if defined(R__HAS_COCOA)
158#include "TMacOSXSystem.h"
159#include "TUrl.h"
160#else
161#include "TUnixSystem.h"
162#endif
163#elif defined(R__WIN32)
164#include "TWinNTSystem.h"
165#endif
166
167extern "C" void R__SetZipMode(int);
168
170static void *gInterpreterLib = nullptr;
171
172// Mutex for protection of concurrent gROOT access
175
176// For accessing TThread::Tsd indirectly.
177void **(*gThreadTsd)(void*,Int_t) = nullptr;
178
179//-------- Names of next three routines are a small homage to CMZ --------------
180////////////////////////////////////////////////////////////////////////////////
181/// Return version id as an integer, i.e. "2.22/04" -> 22204.
182
183static Int_t IVERSQ()
184{
185 Int_t maj, min, cycle;
186 sscanf(ROOT_RELEASE, "%d.%d/%d", &maj, &min, &cycle);
187 return 10000*maj + 100*min + cycle;
188}
189
190////////////////////////////////////////////////////////////////////////////////
191/// Return built date as integer, i.e. "Apr 28 2000" -> 20000428.
192
193static Int_t IDATQQ(const char *date)
194{
195 static const char *months[] = {"Jan","Feb","Mar","Apr","May",
196 "Jun","Jul","Aug","Sep","Oct",
197 "Nov","Dec"};
198
199 char sm[12];
200 Int_t yy, mm=0, dd;
201 sscanf(date, "%s %d %d", sm, &dd, &yy);
202 for (int i = 0; i < 12; i++)
203 if (!strncmp(sm, months[i], 3)) {
204 mm = i+1;
205 break;
206 }
207 return 10000*yy + 100*mm + dd;
208}
209
210////////////////////////////////////////////////////////////////////////////////
211/// Return built time as integer (with min precision), i.e.
212/// "17:32:37" -> 1732.
213
214static Int_t ITIMQQ(const char *time)
215{
216 Int_t hh, mm, ss;
217 sscanf(time, "%d:%d:%d", &hh, &mm, &ss);
218 return 100*hh + mm;
219}
220
221////////////////////////////////////////////////////////////////////////////////
222/// Clean up at program termination before global objects go out of scope.
223
224static void CleanUpROOTAtExit()
225{
226 if (gROOT) {
228
229 if (gROOT->GetListOfFiles())
230 gROOT->GetListOfFiles()->Delete("slow");
231 if (gROOT->GetListOfSockets())
232 gROOT->GetListOfSockets()->Delete();
233 if (gROOT->GetListOfMappedFiles())
234 gROOT->GetListOfMappedFiles()->Delete("slow");
235 if (gROOT->GetListOfClosedObjects())
236 gROOT->GetListOfClosedObjects()->Delete("slow");
237 }
238}
239
240////////////////////////////////////////////////////////////////////////////////
241/// A module and its headers. Intentionally not a copy:
242/// If these strings end up in this struct they are
243/// long lived by definition because they get passed in
244/// before initialization of TCling.
245
246namespace {
247 struct ModuleHeaderInfo_t {
248 ModuleHeaderInfo_t(const char* moduleName,
249 const char** headers,
250 const char** includePaths,
251 const char* payloadCode,
252 const char* fwdDeclCode,
253 void (*triggerFunc)(),
254 const TROOT::FwdDeclArgsToKeepCollection_t& fwdDeclsArgToSkip,
255 const char **classesHeaders,
256 bool hasCxxModule):
257 fModuleName(moduleName),
258 fHeaders(headers),
259 fPayloadCode(payloadCode),
260 fFwdDeclCode(fwdDeclCode),
261 fIncludePaths(includePaths),
262 fTriggerFunc(triggerFunc),
263 fClassesHeaders(classesHeaders),
264 fFwdNargsToKeepColl(fwdDeclsArgToSkip),
265 fHasCxxModule(hasCxxModule) {}
266
267 const char* fModuleName; // module name
268 const char** fHeaders; // 0-terminated array of header files
269 const char* fPayloadCode; // Additional code to be given to cling at library load
270 const char* fFwdDeclCode; // Additional code to let cling know about selected classes and functions
271 const char** fIncludePaths; // 0-terminated array of header files
272 void (*fTriggerFunc)(); // Pointer to the dict initialization used to find the library name
273 const char** fClassesHeaders; // 0-terminated list of classes and related header files
274 const TROOT::FwdDeclArgsToKeepCollection_t fFwdNargsToKeepColl; // Collection of
275 // pairs of template fwd decls and number of
276 bool fHasCxxModule; // Whether this module has a C++ module alongside it.
277 };
278
279 std::vector<ModuleHeaderInfo_t>& GetModuleHeaderInfoBuffer() {
280 static std::vector<ModuleHeaderInfo_t> moduleHeaderInfoBuffer;
281 return moduleHeaderInfoBuffer;
282 }
283}
284
287
288static void at_exit_of_TROOT() {
291}
292
293// This local static object initializes the ROOT system
294namespace ROOT {
295namespace Internal {
297 // Simple wrapper to separate, time-wise, the call to the
298 // TROOT destructor and the actual free-ing of the memory.
299 //
300 // Since the interpreter implementation (currently TCling) is
301 // loaded via dlopen by libCore, the destruction of its global
302 // variable (i.e. in particular clang's) is scheduled before
303 // those in libCore so we need to schedule the call to the TROOT
304 // destructor before that *but* we want to make sure the memory
305 // stay around until libCore itself is unloaded so that code
306 // using gROOT can 'properly' check for validity.
307 //
308 // The order of loading for is:
309 // libCore.so
310 // libRint.so
311 // ... anything other library hard linked to the executable ...
312 // ... for example libEvent
313 // libCling.so
314 // ... other libraries like libTree for example ....
315 // and the destruction order is (of course) the reverse.
316 // By default the unloading of the dictionary, does use
317 // the service of the interpreter ... which of course
318 // fails if libCling is already unloaded by that information
319 // has not been registered per se.
320 //
321 // To solve this problem, we now schedule the destruction
322 // of the TROOT object to happen _just_ before the
323 // unloading/destruction of libCling so that we can
324 // maximize the amount of clean-up we can do correctly
325 // and we can still allocate the TROOT object's memory
326 // statically.
327 //
328 union {
330 char fHolder[sizeof(TROOT)];
331 };
332 public:
333 TROOTAllocator(): fObj("root", "The ROOT of EVERYTHING")
334 {}
335
337 if (gROOTLocal) {
339 }
340 }
341 };
342
343 // The global gROOT is defined to be a function (ROOT::GetROOT())
344 // which itself is dereferencing a function pointer.
345
346 // Initially this function pointer's value is & GetROOT1 whose role is to
347 // create and initialize the TROOT object itself.
348 // At the very end of the TROOT constructor the value of the function pointer
349 // is switch to & GetROOT2 whose role is to initialize the interpreter.
350
351 // This mechanism was primarily intended to fix the issues with order in which
352 // global TROOT and LLVM globals are initialized. TROOT was initializing
353 // Cling, but Cling could not be used yet due to LLVM globals not being
354 // Initialized yet. The solution is to delay initializing the interpreter in
355 // TROOT till after main() when all LLVM globals are initialized.
356
357 // Technically, the mechanism used actually delay the interpreter
358 // initialization until the first use of gROOT *after* the end of the
359 // TROOT constructor.
360
361 // So to delay until after the start of main, we also made sure that none
362 // of the ROOT code (mostly the dictionary code) used during library loading
363 // is using gROOT (directly or indirectly).
364
365 // In practice, the initialization of the interpreter is now delayed until
366 // the first use gROOT (or gInterpreter) after the start of main (but user
367 // could easily break this by using gROOT in their library initialization
368 // code).
369
370 extern TROOT *gROOTLocal;
371
373 if (gROOTLocal)
374 return gROOTLocal;
375 static TROOTAllocator alloc;
376 return gROOTLocal;
377 }
378
380 static Bool_t initInterpreter = kFALSE;
381 if (!initInterpreter) {
382 initInterpreter = kTRUE;
384 // Load and init threads library
386 }
387 return gROOTLocal;
388 }
389 typedef TROOT *(*GetROOTFun_t)();
390
392
393 static Func_t GetSymInLibImt(const char *funcname)
394 {
395 const static bool loadSuccess = dlsym(RTLD_DEFAULT, "usedToIdentifyRootClingByDlSym")? false : 0 <= gSystem->Load("libImt");
396 if (loadSuccess) {
397 if (auto sym = gSystem->DynFindSymbol(nullptr, funcname)) {
398 return sym;
399 } else {
400 Error("GetSymInLibImt", "Cannot get symbol %s.", funcname);
401 }
402 }
403 return nullptr;
404 }
405
406 //////////////////////////////////////////////////////////////////////////////
407 /// Globally enables the parallel branch processing, which is a case of
408 /// implicit multi-threading (IMT) in ROOT, activating the required locks.
409 /// This IMT use case, implemented in TTree::GetEntry, spawns a task for
410 /// each branch of the tree. Therefore, a task takes care of the reading,
411 /// decompression and deserialisation of a given branch.
413 {
414#ifdef R__USE_IMT
415 static void (*sym)() = (void(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_EnableParBranchProcessing");
416 if (sym)
417 sym();
418#else
419 ::Warning("EnableParBranchProcessing", "Cannot enable parallel branch processing, please build ROOT with -Dimt=ON");
420#endif
421 }
422
423 //////////////////////////////////////////////////////////////////////////////
424 /// Globally disables the IMT use case of parallel branch processing,
425 /// deactivating the corresponding locks.
427 {
428#ifdef R__USE_IMT
429 static void (*sym)() = (void(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_DisableParBranchProcessing");
430 if (sym)
431 sym();
432#else
433 ::Warning("DisableParBranchProcessing", "Cannot disable parallel branch processing, please build ROOT with -Dimt=ON");
434#endif
435 }
436
437 //////////////////////////////////////////////////////////////////////////////
438 /// Returns true if parallel branch processing is enabled.
440 {
441#ifdef R__USE_IMT
442 static Bool_t (*sym)() = (Bool_t(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_IsParBranchProcessingEnabled");
443 if (sym)
444 return sym();
445 else
446 return kFALSE;
447#else
448 return kFALSE;
449#endif
450 }
451
452 ////////////////////////////////////////////////////////////////////////////////
453 /// Keeps track of the status of ImplicitMT w/o resorting to the load of
454 /// libImt
456 {
457 static Bool_t isImplicitMTEnabled = kFALSE;
458 return isImplicitMTEnabled;
459 }
460
461} // end of Internal sub namespace
462// back to ROOT namespace
463
465 return (*Internal::gGetROOT)();
466 }
467
469 static TString macroPath;
470 return macroPath;
471 }
472
473 // clang-format off
474 ////////////////////////////////////////////////////////////////////////////////
475 /// Enables the global mutex to make ROOT thread safe/aware.
476 ///
477 /// The following becomes safe:
478 /// - concurrent construction and destruction of TObjects, including the ones registered in ROOT's global lists (e.g. gROOT->GetListOfCleanups(), gROOT->GetListOfFiles())
479 /// - concurrent usage of _different_ ROOT objects from different threads, including ones with global state (e.g. TFile, TTree, TChain) with the exception of graphics classes (e.g. TCanvas)
480 /// - concurrent calls to ROOT's type system classes, e.g. TClass and TEnum
481 /// - concurrent calls to the interpreter through gInterpreter
482 /// - concurrent loading of ROOT plug-ins
483 ///
484 /// In addition, gDirectory, gFile and gPad become a thread-local variable.
485 /// In all threads, gDirectory defaults to gROOT, a singleton which supports thread-safe insertion and deletion of contents.
486 /// gFile and gPad default to nullptr, as it is for single-thread programs.
487 ///
488 /// The ROOT graphics subsystem is not made thread-safe by this method. In particular drawing or printing different
489 /// canvases from different threads (and analogous operations such as invoking `Draw` on a `TObject`) is not thread-safe.
490 ///
491 /// Note that there is no `DisableThreadSafety()`. ROOT's thread-safety features cannot be disabled once activated.
492 // clang-format on
494 {
495 static void (*sym)() = (void(*)())Internal::GetSymInLibImt("ROOT_TThread_Initialize");
496 if (sym)
497 sym();
498 }
499
500 ////////////////////////////////////////////////////////////////////////////////
501 /// @param[in] numthreads Number of threads to use. If not specified or
502 /// set to zero, the number of threads is automatically
503 /// decided by the implementation. Any other value is
504 /// used as a hint.
505 ///
506 /// ROOT must be built with the compilation flag `imt=ON` for this feature to be available.
507 /// The following objects and methods automatically take advantage of
508 /// multi-threading if a call to `EnableImplicitMT` has been made before usage:
509 ///
510 /// - RDataFrame internally runs the event-loop by parallelizing over clusters of entries
511 /// - TTree::GetEntry reads multiple branches in parallel
512 /// - TTree::FlushBaskets writes multiple baskets to disk in parallel
513 /// - TTreeCacheUnzip decompresses the baskets contained in a TTreeCache in parallel
514 /// - THx::Fit performs in parallel the evaluation of the objective function over the data
515 /// - TMVA::DNN trains the deep neural networks in parallel
516 /// - TMVA::BDT trains the classifier in parallel and multiclass BDTs are evaluated in parallel
517 ///
518 /// EnableImplicitMT calls in turn EnableThreadSafety.
519 /// The 'numthreads' parameter allows to control the number of threads to
520 /// be used by the implicit multi-threading. However, this parameter is just
521 /// a hint for ROOT: it will try to satisfy the request if the execution
522 /// scenario allows it. For example, if ROOT is configured to use an external
523 /// scheduler, setting a value for 'numthreads' might not have any effect.
524 ///
525 /// \note Use `DisableImplicitMT()` to disable multi-threading (some locks will remain in place as
526 /// described in EnableThreadSafety()). `EnableImplicitMT(1)` creates a thread-pool of size 1.
527 void EnableImplicitMT(UInt_t numthreads)
528 {
529#ifdef R__USE_IMT
531 return;
533 static void (*sym)(UInt_t) = (void(*)(UInt_t))Internal::GetSymInLibImt("ROOT_TImplicitMT_EnableImplicitMT");
534 if (sym)
535 sym(numthreads);
537#else
538 ::Warning("EnableImplicitMT", "Cannot enable implicit multi-threading with %d threads, please build ROOT with -Dimt=ON", numthreads);
539#endif
540 }
541
542 ////////////////////////////////////////////////////////////////////////////////
543 /// Disables the implicit multi-threading in ROOT (see EnableImplicitMT).
545 {
546#ifdef R__USE_IMT
547 static void (*sym)() = (void(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_DisableImplicitMT");
548 if (sym)
549 sym();
551#else
552 ::Warning("DisableImplicitMT", "Cannot disable implicit multi-threading, please build ROOT with -Dimt=ON");
553#endif
554 }
555
556 ////////////////////////////////////////////////////////////////////////////////
557 /// Returns true if the implicit multi-threading in ROOT is enabled.
559 {
561 }
562
563 ////////////////////////////////////////////////////////////////////////////////
564 /// Returns the size of ROOT's thread pool
566 {
567#ifdef R__USE_IMT
568 static UInt_t (*sym)() = (UInt_t(*)())Internal::GetSymInLibImt("ROOT_MT_GetThreadPoolSize");
569 if (sym)
570 return sym();
571 else
572 return 0;
573#else
574 return 0;
575#endif
576 }
577
578 ////////////////////////////////////////////////////////////////////////////////
579 /// Returns the size of the pool used for implicit multi-threading.
581 {
582 return GetThreadPoolSize();
583 }
584} // end of ROOT namespace
585
587
588// Global debug flag (set to > 0 to get debug output).
589// Can be set either via the interpreter (gDebug is exported to CINT),
590// via the rootrc resource "Root.Debug", via the shell environment variable
591// ROOTDEBUG, or via the debugger.
593
594
596
597////////////////////////////////////////////////////////////////////////////////
598/// Default ctor.
599
601 fLineIsProcessing(0), fVersion(0), fVersionInt(0), fVersionCode(0),
602 fVersionDate(0), fVersionTime(0), fBuiltDate(0), fBuiltTime(0),
603 fTimer(0), fApplication(nullptr), fInterpreter(nullptr), fBatch(kTRUE),
604 fIsWebDisplay(kFALSE), fIsWebDisplayBatch(kFALSE), fEditHistograms(kTRUE),
605 fFromPopUp(kTRUE),fMustClean(kTRUE),fForceStyle(kFALSE),
606 fInterrupt(kFALSE),fEscape(kFALSE),fExecutingMacro(kFALSE),fEditorMode(0),
607 fPrimitive(nullptr),fSelectPad(nullptr),fClasses(nullptr),fTypes(nullptr),fGlobals(nullptr),fGlobalFunctions(nullptr),
608 fClosedObjects(nullptr),fFiles(nullptr),fMappedFiles(nullptr),fSockets(nullptr),fCanvases(nullptr),fStyles(nullptr),fFunctions(nullptr),
609 fTasks(nullptr),fColors(nullptr),fGeometries(nullptr),fBrowsers(nullptr),fSpecials(nullptr),fCleanups(nullptr),
610 fMessageHandlers(nullptr),fStreamerInfo(nullptr),fClassGenerators(nullptr),fSecContexts(nullptr),
611 fProofs(nullptr),fClipboard(nullptr),fDataSets(nullptr),fUUIDs(nullptr),fRootFolder(nullptr),fBrowsables(nullptr),
612 fPluginManager(nullptr)
613{
614}
615
616////////////////////////////////////////////////////////////////////////////////
617/// Initialize the ROOT system. The creation of the TROOT object initializes
618/// the ROOT system. It must be the first ROOT related action that is
619/// performed by a program. The TROOT object must be created on the stack
620/// (can not be called via new since "operator new" is protected). The
621/// TROOT object is either created as a global object (outside the main()
622/// program), or it is one of the first objects created in main().
623/// Make sure that the TROOT object stays in scope for as long as ROOT
624/// related actions are performed. TROOT is a so called singleton so
625/// only one instance of it can be created. The single TROOT object can
626/// always be accessed via the global pointer gROOT.
627/// The name and title arguments can be used to identify the running
628/// application. The initfunc argument can contain an array of
629/// function pointers (last element must be 0). These functions are
630/// executed at the end of the constructor. This way one can easily
631/// extend the ROOT system without adding permanent dependencies
632/// (e.g. the graphics system is initialized via such a function).
633
634TROOT::TROOT(const char *name, const char *title, VoidFuncPtr_t *initfunc)
635 : TDirectory(), fLineIsProcessing(0), fVersion(0), fVersionInt(0), fVersionCode(0),
636 fVersionDate(0), fVersionTime(0), fBuiltDate(0), fBuiltTime(0),
637 fTimer(0), fApplication(nullptr), fInterpreter(nullptr), fBatch(kTRUE),
638 fIsWebDisplay(kFALSE), fIsWebDisplayBatch(kFALSE), fEditHistograms(kTRUE),
639 fFromPopUp(kTRUE),fMustClean(kTRUE),fForceStyle(kFALSE),
640 fInterrupt(kFALSE),fEscape(kFALSE),fExecutingMacro(kFALSE),fEditorMode(0),
641 fPrimitive(nullptr),fSelectPad(nullptr),fClasses(nullptr),fTypes(nullptr),fGlobals(nullptr),fGlobalFunctions(nullptr),
642 fClosedObjects(nullptr),fFiles(nullptr),fMappedFiles(nullptr),fSockets(nullptr),fCanvases(nullptr),fStyles(nullptr),fFunctions(nullptr),
643 fTasks(nullptr),fColors(nullptr),fGeometries(nullptr),fBrowsers(nullptr),fSpecials(nullptr),fCleanups(nullptr),
644 fMessageHandlers(nullptr),fStreamerInfo(nullptr),fClassGenerators(nullptr),fSecContexts(nullptr),
645 fProofs(nullptr),fClipboard(nullptr),fDataSets(nullptr),fUUIDs(nullptr),fRootFolder(nullptr),fBrowsables(nullptr),
646 fPluginManager(nullptr)
647{
649 //Warning("TROOT", "only one instance of TROOT allowed");
650 return;
651 }
652
654
656 gDirectory = nullptr;
657
658 SetName(name);
659 SetTitle(title);
660
661 // will be used by global "operator delete" so make sure it is set
662 // before anything is deleted
663 fMappedFiles = nullptr;
664
665 // create already here, but only initialize it after gEnv has been created
667
668 // Initialize Operating System interface
669 InitSystem();
670
671 // Initialize static directory functions
672 GetRootSys();
673 GetBinDir();
674 GetLibDir();
676 GetEtcDir();
677 GetDataDir();
678 GetDocDir();
679 GetMacroDir();
681 GetSourceDir();
682 GetIconPath();
684
686
687 TDirectory::BuildDirectory(nullptr, nullptr);
688
689 // Initialize interface to CINT C++ interpreter
690 fVersionInt = 0; // check in TROOT dtor in case TCling fails
691 fClasses = nullptr; // might be checked via TCling ctor
692 fEnums = nullptr;
693
694 fConfigOptions = R__CONFIGUREOPTIONS;
695 fConfigFeatures = R__CONFIGUREFEATURES;
701 fBuiltDate = IDATQQ(__DATE__);
702 fBuiltTime = ITIMQQ(__TIME__);
703
704 ReadGitInfo();
705
706 fClasses = new THashTable(800,3); fClasses->UseRWLock();
707 //fIdMap = new IdMap_t;
710
711 // usedToIdentifyRootClingByDlSym is available when TROOT is part of
712 // rootcling.
713 if (!dlsym(RTLD_DEFAULT, "usedToIdentifyRootClingByDlSym")) {
714 // initialize plugin manager early
716 }
717
718 TSystemDirectory *workdir = new TSystemDirectory("workdir", gSystem->WorkingDirectory());
719
720 auto setNameLocked = [](TSeqCollection *l, const char *collection_name) {
721 l->SetName(collection_name);
722 l->UseRWLock();
723 return l;
724 };
725
726 fTimer = 0;
727 fApplication = nullptr;
728 fColors = setNameLocked(new TObjArray(1000), "ListOfColors");
729 fTypes = nullptr;
730 fGlobals = nullptr;
731 fGlobalFunctions = nullptr;
732 // fList was created in TDirectory::Build but with different sizing.
733 delete fList;
734 fList = new THashList(1000,3); fList->UseRWLock();
735 fClosedObjects = setNameLocked(new TList, "ClosedFiles");
736 fFiles = setNameLocked(new TList, "Files");
737 fMappedFiles = setNameLocked(new TList, "MappedFiles");
738 fSockets = setNameLocked(new TList, "Sockets");
739 fCanvases = setNameLocked(new TList, "Canvases");
740 fStyles = setNameLocked(new TList, "Styles");
741 fFunctions = setNameLocked(new TList, "Functions");
742 fTasks = setNameLocked(new TList, "Tasks");
743 fGeometries = setNameLocked(new TList, "Geometries");
744 fBrowsers = setNameLocked(new TList, "Browsers");
745 fSpecials = setNameLocked(new TList, "Specials");
746 fBrowsables = (TList*)setNameLocked(new TList, "Browsables");
747 fCleanups = setNameLocked(new THashList, "Cleanups");
748 fMessageHandlers = setNameLocked(new TList, "MessageHandlers");
749 fSecContexts = setNameLocked(new TList, "SecContexts");
750 fProofs = setNameLocked(new TList, "Proofs");
751 fClipboard = setNameLocked(new TList, "Clipboard");
752 fDataSets = setNameLocked(new TList, "DataSets");
754
756 fUUIDs = new TProcessUUID();
757
758 fRootFolder = new TFolder();
759 fRootFolder->SetName("root");
760 fRootFolder->SetTitle("root of all folders");
761 fRootFolder->AddFolder("Classes", "List of Active Classes",fClasses);
762 fRootFolder->AddFolder("Colors", "List of Active Colors",fColors);
763 fRootFolder->AddFolder("MapFiles", "List of MapFiles",fMappedFiles);
764 fRootFolder->AddFolder("Sockets", "List of Socket Connections",fSockets);
765 fRootFolder->AddFolder("Canvases", "List of Canvases",fCanvases);
766 fRootFolder->AddFolder("Styles", "List of Styles",fStyles);
767 fRootFolder->AddFolder("Functions", "List of Functions",fFunctions);
768 fRootFolder->AddFolder("Tasks", "List of Tasks",fTasks);
769 fRootFolder->AddFolder("Geometries","List of Geometries",fGeometries);
770 fRootFolder->AddFolder("Browsers", "List of Browsers",fBrowsers);
771 fRootFolder->AddFolder("Specials", "List of Special Objects",fSpecials);
772 fRootFolder->AddFolder("Handlers", "List of Message Handlers",fMessageHandlers);
773 fRootFolder->AddFolder("Cleanups", "List of RecursiveRemove Collections",fCleanups);
774 fRootFolder->AddFolder("StreamerInfo","List of Active StreamerInfo Classes",fStreamerInfo);
775 fRootFolder->AddFolder("SecContexts","List of Security Contexts",fSecContexts);
776 fRootFolder->AddFolder("PROOF Sessions", "List of PROOF sessions",fProofs);
777 fRootFolder->AddFolder("ROOT Memory","List of Objects in the gROOT Directory",fList);
778 fRootFolder->AddFolder("ROOT Files","List of Connected ROOT Files",fFiles);
779
780 // by default, add the list of files, tasks, canvases and browsers in the Cleanups list
786 // And add TROOT's TDirectory personality
788
793 fEscape = kFALSE;
795 fPrimitive = nullptr;
796 fSelectPad = nullptr;
797 fEditorMode = 0;
798 fDefCanvasName = "c1";
800 fLineIsProcessing = 1; // This prevents WIN32 "Windows" thread to pick ROOT objects with mouse
801 gDirectory = this;
802 gPad = nullptr;
803
804 //set name of graphical cut class for the graphics editor
805 //cannot call SetCutClassName at this point because the TClass of TCutG
806 //is not yet build
807 fCutClassName = "TCutG";
808
809 // Create a default MessageHandler
810 new TMessageHandler((TClass*)nullptr);
811
812 // Create some styles
813 gStyle = nullptr;
815 SetStyle(gEnv->GetValue("Canvas.Style", "Modern"));
816
817 // Setup default (batch) graphics and GUI environment
820 gGXBatch = new TVirtualX("Batch", "ROOT Interface to batch graphics");
822
823#if defined(R__WIN32)
824 fBatch = kFALSE;
825#elif defined(R__HAS_COCOA)
826 fBatch = kFALSE;
827#else
828 if (gSystem->Getenv("DISPLAY"))
829 fBatch = kFALSE;
830 else
831 fBatch = kTRUE;
832#endif
833
834 int i = 0;
835 while (initfunc && initfunc[i]) {
836 (initfunc[i])();
837 fBatch = kFALSE; // put system in graphics mode (backward compatible)
838 i++;
839 }
840
841 // Set initial/default list of browsable objects
842 fBrowsables->Add(fRootFolder, "root");
843 fBrowsables->Add(fProofs, "PROOF Sessions");
845 fBrowsables->Add(fFiles, "ROOT Files");
846
847 atexit(CleanUpROOTAtExit);
848
850}
851
852////////////////////////////////////////////////////////////////////////////////
853/// Clean up and free resources used by ROOT (files, network sockets,
854/// shared memory segments, etc.).
855
857{
858 using namespace ROOT::Internal;
859
860 if (gROOTLocal == this) {
861
862 // If the interpreter has not yet been initialized, don't bother
864
865 // Mark the object as invalid, so that we can veto some actions
866 // (like autoloading) while we are in the destructor.
868
869 // Turn-off the global mutex to avoid recreating mutexes that have
870 // already been deleted during the destruction phase
871 if (gGlobalMutex) {
873 gGlobalMutex = nullptr;
874 delete m;
875 }
876
877 // Return when error occurred in TCling, i.e. when setup file(s) are
878 // out of date
879 if (!fVersionInt) return;
880
881 // ATTENTION!!! Order is important!
882
884
885 // FIXME: Causes rootcling to deadlock, debug and uncomment
886 // SafeDelete(fRootFolder);
887
888#ifdef R__COMPLETE_MEM_TERMINATION
889 fSpecials->Delete(); SafeDelete(fSpecials); // delete special objects : PostScript, Minuit, Html
890#endif
891
892 fClosedObjects->Delete("slow"); // and closed files
893 fFiles->Delete("slow"); // and files
895 fSecContexts->Delete("slow"); SafeDelete(fSecContexts); // and security contexts
896 fSockets->Delete(); SafeDelete(fSockets); // and sockets
897 fMappedFiles->Delete("slow"); // and mapped files
898 TSeqCollection *tl = fMappedFiles; fMappedFiles = nullptr; delete tl;
899
901
902 delete fUUIDs;
903 TProcessID::Cleanup(); // and list of ProcessIDs
904
911
912#ifdef R__COMPLETE_MEM_TERMINATION
917#endif
918
919 // Stop emitting signals
921
923
924#ifdef R__COMPLETE_MEM_TERMINATION
930
931 fCleanups->Clear();
933 delete gClassTable; gClassTable = 0;
934 delete gEnv; gEnv = 0;
935
936 if (fTypes) fTypes->Delete();
938 if (fGlobals) fGlobals->Delete();
942 fEnums.load()->Delete();
943
944 // FIXME: Causes segfault in rootcling, debug and uncomment
945 // fClasses->Delete(); SafeDelete(fClasses); // TClass'es must be deleted last
946#endif
947
948 // Remove shared libraries produced by the TSystem::CompileMacro() call
950
951 // Cleanup system class
955 delete gSystem;
956
957 // ROOT-6022:
958 // if (gInterpreterLib) dlclose(gInterpreterLib);
959#ifdef R__COMPLETE_MEM_TERMINATION
960 // On some 'newer' platform (Fedora Core 17+, Ubuntu 12), the
961 // initialization order is (by default?) is 'wrong' and so we can't
962 // delete the interpreter now .. because any of the static in the
963 // interpreter's library have already been deleted.
964 // On the link line, we must list the most dependent .o file
965 // and end with the least dependent (LLVM libraries), unfortunately,
966 // Fedora Core 17+ or Ubuntu 12 will also execute the initialization
967 // in the same order (hence doing libCore's before LLVM's and
968 // vice et versa for both the destructor. We worked around the
969 // initialization order by delay the TROOT creation until first use.
970 // We can not do the same for destruction as we have no way of knowing
971 // the last access ...
972 // So for now, let's avoid delete TCling except in the special build
973 // checking the completeness of the termination deletion.
974
975 // TODO: Should we do more cleanup here than just call delete?
976 // Segfaults rootcling in some cases, debug and uncomment:
977 //
978 // delete fInterpreter;
979
980 // We cannot delete fCleanups because of the logic in atexit which needs it.
982#endif
983
984#ifdef _MSC_VER
985 // usedToIdentifyRootClingByDlSym is available when TROOT is part of rootcling.
986 if (dlsym(RTLD_DEFAULT, "usedToIdentifyRootClingByDlSym")) {
987 // deleting the interpreter makes things crash at exit in some cases
988 delete fInterpreter;
989 }
990#else
991 // deleting the interpreter makes things crash at exit in some cases
992 delete fInterpreter;
993#endif
994
995 // Prints memory stats
997
998 gROOTLocal = nullptr;
1000 }
1001}
1002
1003////////////////////////////////////////////////////////////////////////////////
1004/// Add a class to the list and map of classes.
1005/// This routine is deprecated, use TClass::AddClass directly.
1006
1008{
1009 TClass::AddClass(cl);
1010}
1011
1012////////////////////////////////////////////////////////////////////////////////
1013/// Add a class generator. This generator will be called by TClass::GetClass
1014/// in case its does not find a loaded rootcint dictionary to request the
1015/// creation of a TClass object.
1016
1018{
1019 if (!generator) return;
1020 fClassGenerators->Add(generator);
1021}
1022
1023////////////////////////////////////////////////////////////////////////////////
1024/// Append object to this directory.
1025///
1026/// If replace is true:
1027/// remove any existing objects with the same same (if the name is not "")
1028
1029void TROOT::Append(TObject *obj, Bool_t replace /* = kFALSE */)
1030{
1032 TDirectory::Append(obj,replace);
1033}
1034
1035////////////////////////////////////////////////////////////////////////////////
1036/// Add browsable objects to TBrowser.
1037
1039{
1040 TObject *obj;
1041 TIter next(fBrowsables);
1042
1043 while ((obj = (TObject *) next())) {
1044 const char *opt = next.GetOption();
1045 if (opt && strlen(opt))
1046 b->Add(obj, opt);
1047 else
1048 b->Add(obj, obj->GetName());
1049 }
1050}
1051
1052////////////////////////////////////////////////////////////////////////////////
1053/// return class status bit kClassSaved for class cl
1054/// This function is called by the SavePrimitive functions writing
1055/// the C++ code for an object.
1056
1058{
1059 if (cl == nullptr) return kFALSE;
1060 if (cl->TestBit(TClass::kClassSaved)) return kTRUE;
1062 return kFALSE;
1063}
1064
1065namespace {
1066 static void R__ListSlowClose(TList *files)
1067 {
1068 // Routine to close a list of files using the 'slow' techniques
1069 // that also for the deletion ot update the list itself.
1070
1071 static TObject harmless;
1072 TObjLink *cursor = files->FirstLink();
1073 while (cursor) {
1074 TDirectory *dir = static_cast<TDirectory*>( cursor->GetObject() );
1075 if (dir) {
1076 // In order for the iterator to stay valid, we must
1077 // prevent the removal of the object (dir) from the list
1078 // (which is done in TFile::Close). We can also can not
1079 // just move to the next iterator since the Close might
1080 // also (indirectly) remove that file.
1081 // So we SetObject to a harmless value, so that 'dir'
1082 // is not seen as part of the list.
1083 // We will later, remove all the object (see files->Clear()
1084 cursor->SetObject(&harmless); // this must not be zero otherwise things go wrong.
1085 // See related comment at the files->Clear("nodelete");
1086 dir->Close("nodelete");
1087 // Put it back
1088 cursor->SetObject(dir);
1089 }
1090 cursor = cursor->Next();
1091 };
1092 // Now were done, clear the list but do not delete the objects as
1093 // they have been moved to the list of closed objects and must be
1094 // deleted from there in order to avoid a double delete from a
1095 // use objects (on the interpreter stack).
1096 files->Clear("nodelete");
1097 }
1098
1099 static void R__ListSlowDeleteContent(TList *files)
1100 {
1101 // Routine to delete the content of list of files using the 'slow' techniques
1102
1103 static TObject harmless;
1104 TObjLink *cursor = files->FirstLink();
1105 while (cursor) {
1106 TDirectory *dir = dynamic_cast<TDirectory*>( cursor->GetObject() );
1107 if (dir) {
1108 // In order for the iterator to stay valid, we must
1109 // prevent the removal of the object (dir) from the list
1110 // (which is done in TFile::Close). We can also can not
1111 // just move to the next iterator since the Close might
1112 // also (indirectly) remove that file.
1113 // So we SetObject to a harmless value, so that 'dir'
1114 // is not seen as part of the list.
1115 // We will later, remove all the object (see files->Clear()
1116 cursor->SetObject(&harmless); // this must not be zero otherwise things go wrong.
1117 // See related comment at the files->Clear("nodelete");
1118 dir->GetList()->Delete("slow");
1119 // Put it back
1120 cursor->SetObject(dir);
1121 }
1122 cursor = cursor->Next();
1123 };
1124 }
1125}
1126
1127////////////////////////////////////////////////////////////////////////////////
1128/// Close any files and sockets that gROOT knows about.
1129/// This can be used to insures that the files and sockets are closed before any library is unloaded!
1130
1132{
1133 if (fFiles && fFiles->First()) {
1134 R__ListSlowClose(static_cast<TList*>(fFiles));
1135 }
1136 // and Close TROOT itself.
1137 Close("slow");
1138 // Now sockets.
1139 if (fSockets && fSockets->First()) {
1140 if (nullptr==fCleanups->FindObject(fSockets) ) {
1143 }
1144 CallFunc_t *socketCloser = gInterpreter->CallFunc_Factory();
1145 Longptr_t offset = 0;
1146 TClass *socketClass = TClass::GetClass("TSocket");
1147 gInterpreter->CallFunc_SetFuncProto(socketCloser, socketClass->GetClassInfo(), "Close", "", &offset);
1148 if (gInterpreter->CallFunc_IsValid(socketCloser)) {
1149 static TObject harmless;
1150 TObjLink *cursor = static_cast<TList*>(fSockets)->FirstLink();
1151 TList notclosed;
1152 while (cursor) {
1153 TObject *socket = cursor->GetObject();
1154 // In order for the iterator to stay valid, we must
1155 // prevent the removal of the object (dir) from the list
1156 // (which is done in TFile::Close). We can also can not
1157 // just move to the next iterator since the Close might
1158 // also (indirectly) remove that file.
1159 // So we SetObject to a harmless value, so that 'dir'
1160 // is not seen as part of the list.
1161 // We will later, remove all the object (see files->Clear()
1162 cursor->SetObject(&harmless); // this must not be zero otherwise things go wrong.
1163
1164 if (socket->IsA()->InheritsFrom(socketClass)) {
1165 gInterpreter->CallFunc_Exec(socketCloser, ((char*)socket)+offset);
1166 // Put the object in the closed list for later deletion.
1167 socket->SetBit(kMustCleanup);
1169 } else {
1170 // Crap ... this is not a socket, likely Proof or something, let's try to find a Close
1171 Longptr_t other_offset;
1172 CallFunc_t *otherCloser = gInterpreter->CallFunc_Factory();
1173 gInterpreter->CallFunc_SetFuncProto(otherCloser, socket->IsA()->GetClassInfo(), "Close", "", &other_offset);
1174 if (gInterpreter->CallFunc_IsValid(otherCloser)) {
1175 gInterpreter->CallFunc_Exec(otherCloser, ((char*)socket)+other_offset);
1176 // Put the object in the closed list for later deletion.
1177 socket->SetBit(kMustCleanup);
1179 } else {
1180 notclosed.AddLast(socket);
1181 }
1182 gInterpreter->CallFunc_Delete(otherCloser);
1183 // Put it back
1184 cursor->SetObject(socket);
1185 }
1186 cursor = cursor->Next();
1187 }
1188 // Now were done, clear the list
1189 fSockets->Clear();
1190 // Read the one we did not close
1191 cursor = notclosed.FirstLink();
1192 while (cursor) {
1193 static_cast<TList*>(fSockets)->AddLast(cursor->GetObject());
1194 cursor = cursor->Next();
1195 }
1196 }
1197 gInterpreter->CallFunc_Delete(socketCloser);
1198 }
1199 if (fMappedFiles && fMappedFiles->First()) {
1200 R__ListSlowClose(static_cast<TList*>(fMappedFiles));
1201 }
1202
1203}
1204
1205////////////////////////////////////////////////////////////////////////////////
1206/// Execute the cleanups necessary at the end of the process, in particular
1207/// those that must be executed before the library start being unloaded.
1208
1210{
1211 // This will not delete the objects 'held' by the TFiles so that
1212 // they can still be 'reacheable' when ResetGlobals is run.
1213 CloseFiles();
1214
1215 if (gInterpreter) {
1216 gInterpreter->ResetGlobals();
1217 }
1218
1219 // Now delete the objects 'held' by the TFiles so that it
1220 // is done before the tear down of the libraries.
1222 R__ListSlowDeleteContent(static_cast<TList*>(fClosedObjects));
1223 }
1224
1225 // Now a set of simpler things to delete. See the same ordering in
1226 // TROOT::~TROOT
1227 fFunctions->Delete();
1229 fBrowsers->Delete();
1230 fCanvases->Delete("slow");
1231 fColors->Delete();
1232 fStyles->Delete();
1233
1235
1236 if (gInterpreter) {
1237 gInterpreter->ShutDown();
1238 }
1239}
1240
1241
1242////////////////////////////////////////////////////////////////////////////////
1243/// Find an object in one Root folder
1244
1246{
1247 Error("FindObject","Not yet implemented");
1248 return nullptr;
1249}
1250
1251////////////////////////////////////////////////////////////////////////////////
1252/// Returns address of a ROOT object if it exists
1253///
1254/// If name contains at least one "/" the function calls FindObjectany
1255/// else
1256/// This function looks in the following order in the ROOT lists:
1257/// - List of files
1258/// - List of memory mapped files
1259/// - List of functions
1260/// - List of geometries
1261/// - List of canvases
1262/// - List of styles
1263/// - List of specials
1264/// - List of materials in current geometry
1265/// - List of shapes in current geometry
1266/// - List of matrices in current geometry
1267/// - List of Nodes in current geometry
1268/// - Current Directory in memory
1269/// - Current Directory on file
1270
1271TObject *TROOT::FindObject(const char *name) const
1272{
1273 if (name && strstr(name,"/")) return FindObjectAny(name);
1274
1275 TObject *temp = nullptr;
1276
1277 temp = fFiles->FindObject(name); if (temp) return temp;
1278 temp = fMappedFiles->FindObject(name); if (temp) return temp;
1279 {
1281 temp = fFunctions->FindObject(name);if (temp) return temp;
1282 }
1283 temp = fGeometries->FindObject(name); if (temp) return temp;
1284 temp = fCanvases->FindObject(name); if (temp) return temp;
1285 temp = fStyles->FindObject(name); if (temp) return temp;
1286 {
1288 temp = fSpecials->FindObject(name); if (temp) return temp;
1289 }
1290 TIter next(fGeometries);
1291 TObject *obj;
1292 while ((obj=next())) {
1293 temp = obj->FindObject(name); if (temp) return temp;
1294 }
1295 if (gDirectory) temp = gDirectory->Get(name);
1296 if (temp) return temp;
1297 if (gPad) {
1298 TVirtualPad *canvas = gPad->GetVirtCanvas();
1299 if (fCanvases->FindObject(canvas)) { //this check in case call from TCanvas ctor
1300 temp = canvas->FindObject(name);
1301 if (!temp && canvas != gPad) temp = gPad->FindObject(name);
1302 }
1303 }
1304 return temp;
1305}
1306
1307////////////////////////////////////////////////////////////////////////////////
1308/// Returns address and folder of a ROOT object if it exists
1309///
1310/// This function looks in the following order in the ROOT lists:
1311/// - List of files
1312/// - List of memory mapped files
1313/// - List of functions
1314/// - List of geometries
1315/// - List of canvases
1316/// - List of styles
1317/// - List of specials
1318/// - List of materials in current geometry
1319/// - List of shapes in current geometry
1320/// - List of matrices in current geometry
1321/// - List of Nodes in current geometry
1322/// - Current Directory in memory
1323/// - Current Directory on file
1324
1325TObject *TROOT::FindSpecialObject(const char *name, void *&where)
1326{
1327 TObject *temp = nullptr;
1328 where = nullptr;
1329
1330 if (!temp) {
1331 temp = fFiles->FindObject(name);
1332 where = fFiles;
1333 }
1334 if (!temp) {
1335 temp = fMappedFiles->FindObject(name);
1336 where = fMappedFiles;
1337 }
1338 if (!temp) {
1340 temp = fFunctions->FindObject(name);
1341 where = fFunctions;
1342 }
1343 if (!temp) {
1344 temp = fCanvases->FindObject(name);
1345 where = fCanvases;
1346 }
1347 if (!temp) {
1348 temp = fStyles->FindObject(name);
1349 where = fStyles;
1350 }
1351 if (!temp) {
1352 temp = fSpecials->FindObject(name);
1353 where = fSpecials;
1354 }
1355 if (!temp) {
1356 TObject *glast = fGeometries->Last();
1357 if (glast) {where = glast; temp = glast->FindObject(name);}
1358 }
1359 if (!temp && gDirectory) {
1360 temp = gDirectory->Get(name);
1361 where = gDirectory;
1362 }
1363 if (!temp && gPad) {
1364 TVirtualPad *canvas = gPad->GetVirtCanvas();
1365 if (fCanvases->FindObject(canvas)) { //this check in case call from TCanvas ctor
1366 temp = canvas->FindObject(name);
1367 where = canvas;
1368 if (!temp && canvas != gPad) {
1369 temp = gPad->FindObject(name);
1370 where = gPad;
1371 }
1372 }
1373 }
1374 if (!temp) return nullptr;
1375 if (temp->TestBit(kNotDeleted)) return temp;
1376 return nullptr;
1377}
1378
1379////////////////////////////////////////////////////////////////////////////////
1380/// Return a pointer to the first object with name starting at //root.
1381/// This function scans the list of all folders.
1382/// if no object found in folders, it scans the memory list of all files.
1383
1385{
1387 if (obj) return obj;
1388 return gDirectory->FindObjectAnyFile(name);
1389}
1390
1391////////////////////////////////////////////////////////////////////////////////
1392/// Scan the memory lists of all files for an object with name
1393
1395{
1397 TDirectory *d;
1398 TIter next(GetListOfFiles());
1399 while ((d = (TDirectory*)next())) {
1400 // Call explicitly TDirectory::FindObject to restrict the search to the
1401 // already in memory object.
1402 TObject *obj = d->TDirectory::FindObject(name);
1403 if (obj) return obj;
1404 }
1405 return nullptr;
1406}
1407
1408////////////////////////////////////////////////////////////////////////////////
1409/// Returns class name of a ROOT object including CINT globals.
1410
1411const char *TROOT::FindObjectClassName(const char *name) const
1412{
1413 // Search first in the list of "standard" objects
1414 TObject *obj = FindObject(name);
1415 if (obj) return obj->ClassName();
1416
1417 // Is it a global variable?
1418 TGlobal *g = GetGlobal(name);
1419 if (g) return g->GetTypeName();
1420
1421 return nullptr;
1422}
1423
1424////////////////////////////////////////////////////////////////////////////////
1425/// Return path name of obj somewhere in the //root/... path.
1426/// The function returns the first occurence of the object in the list
1427/// of folders. The returned string points to a static char array in TROOT.
1428/// If this function is called in a loop or recursively, it is the
1429/// user's responsibility to copy this string in their area.
1430
1431const char *TROOT::FindObjectPathName(const TObject *) const
1432{
1433 Error("FindObjectPathName","Not yet implemented");
1434 return "??";
1435}
1436
1437////////////////////////////////////////////////////////////////////////////////
1438/// return a TClass object corresponding to 'name' assuming it is an STL container.
1439/// In particular we looking for possible alternative name (default template
1440/// parameter, typedefs template arguments, typedefed name).
1441
1442TClass *TROOT::FindSTLClass(const char *name, Bool_t load, Bool_t silent) const
1443{
1444 // Example of inputs are
1445 // vector<int> (*)
1446 // vector<Int_t>
1447 // vector<long long>
1448 // vector<Long_64_t> (*)
1449 // vector<int, allocator<int> >
1450 // vector<Int_t, allocator<int> >
1451 //
1452 // One of the possibly expensive operation is the resolving of the typedef
1453 // which can provoke the parsing of the header files (and/or the loading
1454 // of clang pcms information).
1455
1457
1458 // Remove std::, allocator, typedef, add Long64_t, etc. in just one call.
1459 std::string normalized;
1461
1462 TClass *cl = nullptr;
1463 if (normalized != name) cl = TClass::GetClass(normalized.c_str(),load,silent);
1464
1465 if (load && cl==nullptr) {
1466 // Create an Emulated class for this container.
1467 cl = gInterpreter->GenerateTClass(normalized.c_str(), kTRUE, silent);
1468 }
1469
1470 return cl;
1471}
1472
1473////////////////////////////////////////////////////////////////////////////////
1474/// Return pointer to class with name. Obsolete, use TClass::GetClass directly
1475
1476TClass *TROOT::GetClass(const char *name, Bool_t load, Bool_t silent) const
1477{
1478 return TClass::GetClass(name,load,silent);
1479}
1480
1481
1482////////////////////////////////////////////////////////////////////////////////
1483/// Return pointer to class from its name. Obsolete, use TClass::GetClass directly
1484/// See TClass::GetClass
1485
1486TClass *TROOT::GetClass(const std::type_info& typeinfo, Bool_t load, Bool_t silent) const
1487{
1488 return TClass::GetClass(typeinfo,load,silent);
1489}
1490
1491////////////////////////////////////////////////////////////////////////////////
1492/// Return address of color with index color.
1493
1495{
1497 TObjArray *lcolors = (TObjArray*) GetListOfColors();
1498 if (!lcolors) return nullptr;
1499 if (color < 0 || color >= lcolors->GetSize()) return nullptr;
1500 TColor *col = (TColor*)lcolors->At(color);
1501 if (col && col->GetNumber() == color) return col;
1502 TIter next(lcolors);
1503 while ((col = (TColor *) next()))
1504 if (col->GetNumber() == color) return col;
1505
1506 return nullptr;
1507}
1508
1509////////////////////////////////////////////////////////////////////////////////
1510/// Return a default canvas.
1511
1513{
1514 return (TCanvas*)gROOT->ProcessLine("TCanvas::MakeDefCanvas();");
1515}
1516
1517////////////////////////////////////////////////////////////////////////////////
1518/// Return pointer to type with name.
1519
1520TDataType *TROOT::GetType(const char *name, Bool_t /* load */) const
1521{
1522 return (TDataType*)gROOT->GetListOfTypes()->FindObject(name);
1523}
1524
1525////////////////////////////////////////////////////////////////////////////////
1526/// Return pointer to file with name.
1527
1528TFile *TROOT::GetFile(const char *name) const
1529{
1531 return (TFile*)GetListOfFiles()->FindObject(name);
1532}
1533
1534////////////////////////////////////////////////////////////////////////////////
1535/// Return pointer to style with name
1536
1537TStyle *TROOT::GetStyle(const char *name) const
1538{
1540}
1541
1542////////////////////////////////////////////////////////////////////////////////
1543/// Return pointer to function with name.
1544
1546{
1547 if (name == nullptr || name[0] == 0) {
1548 return nullptr;
1549 }
1550
1551 {
1554 if (f1) return f1;
1555 }
1556
1557 gROOT->ProcessLine("TF1::InitStandardFunctions();");
1558
1560 return fFunctions->FindObject(name);
1561}
1562
1563////////////////////////////////////////////////////////////////////////////////
1564
1566{
1567 if (!gInterpreter) return nullptr;
1568
1570
1572}
1573
1574////////////////////////////////////////////////////////////////////////////////
1575/// Return pointer to global variable by name. If load is true force
1576/// reading of all currently defined globals from CINT (more expensive).
1577
1578TGlobal *TROOT::GetGlobal(const char *name, Bool_t load) const
1579{
1580 return (TGlobal *)gROOT->GetListOfGlobals(load)->FindObject(name);
1581}
1582
1583////////////////////////////////////////////////////////////////////////////////
1584/// Return pointer to global variable with address addr.
1585
1586TGlobal *TROOT::GetGlobal(const TObject *addr, Bool_t /* load */) const
1587{
1588 if (addr == nullptr || ((Longptr_t)addr) == -1) return nullptr;
1589
1590 TInterpreter::DeclId_t decl = gInterpreter->GetDataMemberAtAddr(addr);
1591 if (decl) {
1592 TListOfDataMembers *globals = ((TListOfDataMembers*)(gROOT->GetListOfGlobals(kFALSE)));
1593 return (TGlobal*)globals->Get(decl);
1594 }
1595 // If we are actually looking for a global that is held by a global
1596 // pointer (for example gRandom), we need to find a pointer with the
1597 // correct value.
1598 decl = gInterpreter->GetDataMemberWithValue(addr);
1599 if (decl) {
1600 TListOfDataMembers *globals = ((TListOfDataMembers*)(gROOT->GetListOfGlobals(kFALSE)));
1601 return (TGlobal*)globals->Get(decl);
1602 }
1603 return nullptr;
1604}
1605
1606////////////////////////////////////////////////////////////////////////////////
1607/// Internal routine returning, and creating if necessary, the list
1608/// of global function.
1609
1611{
1613 return fGlobalFunctions;
1614}
1615
1616////////////////////////////////////////////////////////////////////////////////
1617/// Return the collection of functions named "name".
1618
1620{
1621 return ((TListOfFunctions*)fGlobalFunctions)->GetListForObject(name);
1622}
1623
1624////////////////////////////////////////////////////////////////////////////////
1625/// Return pointer to global function by name.
1626/// If params != 0 it will also resolve overloading other it returns the first
1627/// name match.
1628/// If params == 0 and load is true force reading of all currently defined
1629/// global functions from Cling.
1630/// The param string must be of the form: "3189,\"aap\",1.3".
1631
1632TFunction *TROOT::GetGlobalFunction(const char *function, const char *params,
1633 Bool_t load)
1634{
1635 if (!params) {
1638 } else {
1639 if (!fInterpreter)
1640 Fatal("GetGlobalFunction", "fInterpreter not initialized");
1641
1643 TInterpreter::DeclId_t decl = gInterpreter->GetFunctionWithValues(nullptr,
1644 function, params,
1645 false);
1646
1647 if (!decl) return nullptr;
1648
1649 TFunction *f = GetGlobalFunctions()->Get(decl);
1650 if (f) return f;
1651
1652 Error("GetGlobalFunction",
1653 "\nDid not find matching TFunction <%s> with \"%s\".",
1654 function,params);
1655 return nullptr;
1656 }
1657}
1658
1659////////////////////////////////////////////////////////////////////////////////
1660/// Return pointer to global function by name. If proto != 0
1661/// it will also resolve overloading. If load is true force reading
1662/// of all currently defined global functions from CINT (more expensive).
1663/// The proto string must be of the form: "int, char*, float".
1664
1666 const char *proto, Bool_t load)
1667{
1668 if (!proto) {
1671 } else {
1672 if (!fInterpreter)
1673 Fatal("GetGlobalFunctionWithPrototype", "fInterpreter not initialized");
1674
1676 TInterpreter::DeclId_t decl = gInterpreter->GetFunctionWithPrototype(nullptr,
1677 function, proto);
1678
1679 if (!decl) return nullptr;
1680
1681 TFunction *f = GetGlobalFunctions()->Get(decl);
1682 if (f) return f;
1683
1684 Error("GetGlobalFunctionWithPrototype",
1685 "\nDid not find matching TFunction <%s> with \"%s\".",
1686 function,proto);
1687 return nullptr;
1688 }
1689}
1690
1691////////////////////////////////////////////////////////////////////////////////
1692/// Return pointer to Geometry with name
1693
1695{
1697}
1698
1699////////////////////////////////////////////////////////////////////////////////
1700
1702{
1703 if(!fEnums.load()) {
1705 // Test again just in case, another thread did the work while we were
1706 // waiting.
1707 if (!fEnums.load()) fEnums = new TListOfEnumsWithLock(nullptr);
1708 }
1709 if (load) {
1711 (*fEnums).Load(); // Refresh the list of enums.
1712 }
1713 return fEnums.load();
1714}
1715
1716////////////////////////////////////////////////////////////////////////////////
1717
1719{
1721 if(!fFuncTemplate) {
1723 }
1724 return fFuncTemplate;
1725}
1726
1727////////////////////////////////////////////////////////////////////////////////
1728/// Return list containing the TGlobals currently defined.
1729/// Since globals are created and deleted during execution of the
1730/// program, we need to update the list of globals every time we
1731/// execute this method. However, when calling this function in
1732/// a (tight) loop where no interpreter symbols will be created
1733/// you can set load=kFALSE (default).
1734
1736{
1737 if (!fGlobals) {
1739 // We add to the list the "funcky-fake" globals.
1740
1741 // provide special functor for gROOT, while ROOT::GetROOT() does not return reference
1742 TGlobalMappedFunction::MakeFunctor("gROOT", "TROOT*", ROOT::GetROOT, [] {
1743 ROOT::GetROOT();
1744 return (void *)&ROOT::Internal::gROOTLocal;
1745 });
1746
1748 TGlobalMappedFunction::MakeFunctor("gVirtualX", "TVirtualX*", TVirtualX::Instance);
1750
1751 // Don't let TGlobalMappedFunction delete our globals, now that we take them.
1755 }
1756
1757 if (!fInterpreter)
1758 Fatal("GetListOfGlobals", "fInterpreter not initialized");
1759
1760 if (load) fGlobals->Load();
1761
1762 return fGlobals;
1763}
1764
1765////////////////////////////////////////////////////////////////////////////////
1766/// Return list containing the TFunctions currently defined.
1767/// Since functions are created and deleted during execution of the
1768/// program, we need to update the list of functions every time we
1769/// execute this method. However, when calling this function in
1770/// a (tight) loop where no interpreter symbols will be created
1771/// you can set load=kFALSE (default).
1772
1774{
1776
1777 if (!fGlobalFunctions) {
1778 fGlobalFunctions = new TListOfFunctions(nullptr);
1779 }
1780
1781 if (!fInterpreter)
1782 Fatal("GetListOfGlobalFunctions", "fInterpreter not initialized");
1783
1784 // A thread that calls with load==true and a thread that calls with load==false
1785 // will conflict here (the load==true will be updating the list while the
1786 // other is reading it). To solve the problem, we could use a read-write lock
1787 // inside the list itself.
1788 if (load) fGlobalFunctions->Load();
1789
1790 return fGlobalFunctions;
1791}
1792
1793////////////////////////////////////////////////////////////////////////////////
1794/// Return a dynamic list giving access to all TDataTypes (typedefs)
1795/// currently defined.
1796///
1797/// The list is populated on demand. Calling
1798/// ~~~ {.cpp}
1799/// gROOT->GetListOfTypes()->FindObject(nameoftype);
1800/// ~~~
1801/// will return the TDataType corresponding to 'nameoftype'. If the
1802/// TDataType is not already in the list itself and the type does exist,
1803/// a new TDataType will be created and added to the list.
1804///
1805/// Calling
1806/// ~~~ {.cpp}
1807/// gROOT->GetListOfTypes()->ls(); // or Print()
1808/// ~~~
1809/// list only the typedefs that have been previously accessed through the
1810/// list (plus the builtins types).
1811
1813{
1814 if (!fInterpreter)
1815 Fatal("GetListOfTypes", "fInterpreter not initialized");
1816
1817 return fTypes;
1818}
1819
1820////////////////////////////////////////////////////////////////////////////////
1821/// Get number of classes.
1822
1824{
1825 return fClasses->GetSize();
1826}
1827
1828////////////////////////////////////////////////////////////////////////////////
1829/// Get number of types.
1830
1832{
1833 return fTypes->GetSize();
1834}
1835
1836////////////////////////////////////////////////////////////////////////////////
1837/// Execute command when system has been idle for idleTimeInSec seconds.
1838
1839void TROOT::Idle(UInt_t idleTimeInSec, const char *command)
1840{
1841 if (!fApplication.load())
1843
1844 if (idleTimeInSec <= 0)
1845 (*fApplication).RemoveIdleTimer();
1846 else
1847 (*fApplication).SetIdleTimer(idleTimeInSec, command);
1848}
1849
1850////////////////////////////////////////////////////////////////////////////////
1851/// Check whether className is a known class, and only autoload
1852/// if we can. Helper function for TROOT::IgnoreInclude().
1853
1854static TClass* R__GetClassIfKnown(const char* className)
1855{
1856 // Check whether the class is available for auto-loading first:
1857 const char* libsToLoad = gInterpreter->GetClassSharedLibs(className);
1858 TClass* cla = nullptr;
1859 if (libsToLoad) {
1860 // trigger autoload, and only create TClass in this case.
1861 return TClass::GetClass(className);
1862 } else if (gROOT->GetListOfClasses()
1863 && (cla = (TClass*)gROOT->GetListOfClasses()->FindObject(className))) {
1864 // cla assigned in if statement
1865 } else if (gClassTable->FindObject(className)) {
1866 return TClass::GetClass(className);
1867 }
1868 return cla;
1869}
1870
1871////////////////////////////////////////////////////////////////////////////////
1872/// Return 1 if the name of the given include file corresponds to a class that
1873/// is known to ROOT, e.g. "TLorentzVector.h" versus TLorentzVector.
1874
1875Int_t TROOT::IgnoreInclude(const char *fname, const char * /*expandedfname*/)
1876{
1877 if (fname == nullptr) return 0;
1878
1879 TString stem(fname);
1880 // Remove extension if any, ignore files with extension not being .h*
1881 Int_t where = stem.Last('.');
1882 if (where != kNPOS) {
1883 if (stem.EndsWith(".so") || stem.EndsWith(".sl") ||
1884 stem.EndsWith(".dl") || stem.EndsWith(".a") ||
1885 stem.EndsWith(".dll", TString::kIgnoreCase))
1886 return 0;
1887 stem.Remove(where);
1888 }
1889
1890 TString className = gSystem->BaseName(stem);
1891 TClass* cla = R__GetClassIfKnown(className);
1892 if (!cla) {
1893 // Try again with modifications to the file name:
1894 className = stem;
1895 className.ReplaceAll("/", "::");
1896 className.ReplaceAll("\\", "::");
1897 if (className.Contains(":::")) {
1898 // "C:\dir" becomes "C:::dir".
1899 // fname corresponds to whatever is stated after #include and
1900 // a full path name usually means that it's not a regular #include
1901 // but e.g. a ".L", so we can assume that this is not a header of
1902 // a class in a namespace (a global-namespace class would have been
1903 // detected already before).
1904 return 0;
1905 }
1906 cla = R__GetClassIfKnown(className);
1907 }
1908
1909 if (!cla) {
1910 return 0;
1911 }
1912
1913 // cla is valid, check wether it's actually in the header of the same name:
1914 if (cla->GetDeclFileLine() <= 0) return 0; // to a void an error with VisualC++
1915 TString decfile = gSystem->BaseName(cla->GetDeclFileName());
1916 if (decfile != gSystem->BaseName(fname)) {
1917 return 0;
1918 }
1919 return 1;
1920}
1921
1922////////////////////////////////////////////////////////////////////////////////
1923/// Initialize operating system interface.
1924
1926{
1927 if (gSystem == nullptr) {
1928#if defined(R__UNIX)
1929#if defined(R__HAS_COCOA)
1930 gSystem = new TMacOSXSystem;
1931#else
1932 gSystem = new TUnixSystem;
1933#endif
1934#elif defined(R__WIN32)
1935 gSystem = new TWinNTSystem;
1936#else
1937 gSystem = new TSystem;
1938#endif
1939
1940 if (gSystem->Init())
1941 fprintf(stderr, "Fatal in <TROOT::InitSystem>: can't init operating system layer\n");
1942
1943 if (!gSystem->HomeDirectory()) {
1944 fprintf(stderr, "Fatal in <TROOT::InitSystem>: HOME directory not set\n");
1945 fprintf(stderr, "Fix this by defining the HOME shell variable\n");
1946 }
1947
1948 // read default files
1949 gEnv = new TEnv(".rootrc");
1950
1953
1954 gDebug = gEnv->GetValue("Root.Debug", 0);
1955
1956 if (!gEnv->GetValue("Root.ErrorHandlers", 1))
1958
1959 // The old "Root.ZipMode" had a discrepancy between documentation vs actual meaning.
1960 // Also, a value with the meaning "default" wasn't available. To solved this,
1961 // "Root.ZipMode" was replaced by "Root.CompressionAlgorithm". Warn about usage of
1962 // the old value, if it's set to 0, but silently translate the setting to
1963 // "Root.CompressionAlgorithm" for values > 1.
1964 Int_t oldzipmode = gEnv->GetValue("Root.ZipMode", -1);
1965 if (oldzipmode == 0) {
1966 fprintf(stderr, "Warning in <TROOT::InitSystem>: ignoring old rootrc entry \"Root.ZipMode = 0\"!\n");
1967 } else {
1968 if (oldzipmode == -1 || oldzipmode == 1) {
1969 // Not set or default value, use "default" for "Root.CompressionAlgorithm":
1970 oldzipmode = 0;
1971 }
1972 // else keep the old zipmode (e.g. "3") as "Root.CompressionAlgorithm"
1973 // if "Root.CompressionAlgorithm" isn't set; see below.
1974 }
1975
1976 Int_t zipmode = gEnv->GetValue("Root.CompressionAlgorithm", oldzipmode);
1977 if (zipmode != 0) R__SetZipMode(zipmode);
1978
1979 const char *sdeb;
1980 if ((sdeb = gSystem->Getenv("ROOTDEBUG")))
1981 gDebug = atoi(sdeb);
1982
1983 if (gDebug > 0 && isatty(2))
1984 fprintf(stderr, "Info in <TROOT::InitSystem>: running with gDebug = %d\n", gDebug);
1985
1986#if defined(R__HAS_COCOA)
1987 // create and delete a dummy TUrl so that TObjectStat table does not contain
1988 // objects that are deleted after recording is turned-off (in next line),
1989 // like the TUrl::fgSpecialProtocols list entries which are created in the
1990 // TMacOSXSystem ctor.
1991 { TUrl dummy("/dummy"); }
1992#endif
1993 TObject::SetObjectStat(gEnv->GetValue("Root.ObjectStat", 0));
1994 }
1995}
1996
1997////////////////////////////////////////////////////////////////////////////////
1998/// Load and initialize thread library.
1999
2001{
2002 if (gEnv->GetValue("Root.UseThreads", 0) || gEnv->GetValue("Root.EnableThreadSafety", 0)) {
2004 }
2005}
2006
2007////////////////////////////////////////////////////////////////////////////////
2008/// Initialize the interpreter. Should be called only after main(),
2009/// to make sure LLVM/Clang is fully initialized.
2010
2012{
2013 // usedToIdentifyRootClingByDlSym is available when TROOT is part of
2014 // rootcling.
2015 if (!dlsym(RTLD_DEFAULT, "usedToIdentifyRootClingByDlSym")
2016 && !dlsym(RTLD_DEFAULT, "usedToIdentifyStaticRoot")) {
2017 char *libRIO = gSystem->DynamicPathName("libRIO");
2018 void *libRIOHandle = dlopen(libRIO, RTLD_NOW|RTLD_GLOBAL);
2019 delete [] libRIO;
2020 if (!libRIOHandle) {
2021 TString err = dlerror();
2022 fprintf(stderr, "Fatal in <TROOT::InitInterpreter>: cannot load library %s\n", err.Data());
2023 exit(1);
2024 }
2025
2026 char *libcling = gSystem->DynamicPathName("libCling");
2027 gInterpreterLib = dlopen(libcling, RTLD_LAZY|RTLD_LOCAL);
2028 delete [] libcling;
2029
2030 if (!gInterpreterLib) {
2031 TString err = dlerror();
2032 fprintf(stderr, "Fatal in <TROOT::InitInterpreter>: cannot load library %s\n", err.Data());
2033 exit(1);
2034 }
2035 dlerror(); // reset error message
2036 } else {
2037 gInterpreterLib = RTLD_DEFAULT;
2038 }
2040 if (!CreateInterpreter) {
2041 TString err = dlerror();
2042 fprintf(stderr, "Fatal in <TROOT::InitInterpreter>: cannot load symbol %s\n", err.Data());
2043 exit(1);
2044 }
2045 // Schedule the destruction of TROOT.
2046 atexit(at_exit_of_TROOT);
2047
2048 gDestroyInterpreter = (DestroyInterpreter_t*) dlsym(gInterpreterLib, "DestroyInterpreter");
2049 if (!gDestroyInterpreter) {
2050 TString err = dlerror();
2051 fprintf(stderr, "Fatal in <TROOT::InitInterpreter>: cannot load symbol %s\n", err.Data());
2052 exit(1);
2053 }
2054
2055 const char *interpArgs[] = {
2056#ifdef NDEBUG
2057 "-DNDEBUG",
2058#else
2059 "-UNDEBUG",
2060#endif
2061#ifdef DEBUG
2062 "-DDEBUG",
2063#else
2064 "-UDEBUG",
2065#endif
2066#ifdef _DEBUG
2067 "-D_DEBUG",
2068#else
2069 "-U_DEBUG",
2070#endif
2071 nullptr};
2072
2074
2077
2078 fgRootInit = kTRUE;
2079
2080 // initialize gClassTable is not already done
2081 if (!gClassTable)
2082 new TClassTable;
2083
2084 // Initialize all registered dictionaries.
2085 for (std::vector<ModuleHeaderInfo_t>::const_iterator
2086 li = GetModuleHeaderInfoBuffer().begin(),
2087 le = GetModuleHeaderInfoBuffer().end(); li != le; ++li) {
2088 // process buffered module registrations
2089 fInterpreter->RegisterModule(li->fModuleName,
2090 li->fHeaders,
2091 li->fIncludePaths,
2092 li->fPayloadCode,
2093 li->fFwdDeclCode,
2094 li->fTriggerFunc,
2095 li->fFwdNargsToKeepColl,
2096 li->fClassesHeaders,
2097 kTRUE /*lateRegistration*/,
2098 li->fHasCxxModule);
2099 }
2100 GetModuleHeaderInfoBuffer().clear();
2101
2103}
2104
2105////////////////////////////////////////////////////////////////////////////////
2106/// Helper function used by TClass::GetClass().
2107/// This function attempts to load the dictionary for 'classname'
2108/// either from the TClassTable or from the list of generator.
2109/// If silent is 'true', do not warn about missing dictionary for the class.
2110/// (typically used for class that are used only for transient members)
2111///
2112/// The 'requestedname' is expected to be already normalized.
2113
2114TClass *TROOT::LoadClass(const char *requestedname, Bool_t silent) const
2115{
2116 return TClass::LoadClass(requestedname, silent);
2117}
2118
2119////////////////////////////////////////////////////////////////////////////////
2120/// Check if class "classname" is known to the interpreter (in fact,
2121/// this check is not needed anymore, so classname is ignored). If
2122/// not it will load library "libname". If the library couldn't be found with original
2123/// libname and if the name was not prefixed with lib, try to prefix with "lib" and search again.
2124/// If DynamicPathName still couldn't find the library, return -1.
2125/// If check is true it will only check if libname exists and is
2126/// readable.
2127/// Returns 0 on successful loading, -1 in case libname does not
2128/// exist or in case of error and -2 in case of version mismatch.
2129
2130Int_t TROOT::LoadClass(const char * /*classname*/, const char *libname,
2131 Bool_t check)
2132{
2133 TString lib(libname);
2134
2135 // Check if libname exists in path or not
2136 if (char *path = gSystem->DynamicPathName(lib, kTRUE)) {
2137 // If check == true, only check if it exists and if it's readable
2138 if (check) {
2139 delete [] path;
2140 return 0;
2141 }
2142
2143 // If check == false, try to load the library
2144 else {
2145 int err = gSystem->Load(path, nullptr, kTRUE);
2146 delete [] path;
2147
2148 // TSystem::Load returns 1 when the library was already loaded, return success in this case.
2149 if (err == 1)
2150 err = 0;
2151 return err;
2152 }
2153 } else {
2154 // This is the branch where libname didn't exist
2155 if (check) {
2156 FileStat_t stat;
2157 if (!gSystem->GetPathInfo(libname, stat) && (R_ISREG(stat.fMode) &&
2159 return 0;
2160 }
2161
2162 // Take care of user who didn't write the whole name
2163 if (!lib.BeginsWith("lib")) {
2164 lib = "lib" + lib;
2165 return LoadClass("", lib.Data(), check);
2166 }
2167 }
2168
2169 // Execution reaches here when library was prefixed with lib, check is false and couldn't find
2170 // the library name.
2171 return -1;
2172}
2173
2174////////////////////////////////////////////////////////////////////////////////
2175/// Return true if the file is local and is (likely) to be a ROOT file
2176
2177Bool_t TROOT::IsRootFile(const char *filename) const
2178{
2179 Bool_t result = kFALSE;
2180 FILE *mayberootfile = fopen(filename,"rb");
2181 if (mayberootfile) {
2182 char header[5];
2183 if (fgets(header,5,mayberootfile)) {
2184 result = strncmp(header,"root",4)==0;
2185 }
2186 fclose(mayberootfile);
2187 }
2188 return result;
2189}
2190
2191////////////////////////////////////////////////////////////////////////////////
2192/// To list all objects of the application.
2193/// Loop on all objects created in the ROOT linked lists.
2194/// Objects may be files and windows or any other object directly
2195/// attached to the ROOT linked list.
2196
2197void TROOT::ls(Option_t *option) const
2198{
2199// TObject::SetDirLevel();
2200// GetList()->R__FOR_EACH(TObject,ls)(option);
2201 TDirectory::ls(option);
2202}
2203
2204////////////////////////////////////////////////////////////////////////////////
2205/// Load a macro in the interpreter's memory. Equivalent to the command line
2206/// command ".L filename". If the filename has "+" or "++" appended
2207/// the macro will be compiled by ACLiC. The filename must have the format:
2208/// [path/]macro.C[+|++[g|O]].
2209/// The possible error codes are defined by TInterpreter::EErrorCode.
2210/// If check is true it will only check if filename exists and is
2211/// readable.
2212/// Returns 0 on successful loading and -1 in case filename does not
2213/// exist or in case of error.
2214
2215Int_t TROOT::LoadMacro(const char *filename, int *error, Bool_t check)
2216{
2217 Int_t err = -1;
2218 Int_t lerr, *terr;
2219 if (error)
2220 terr = error;
2221 else
2222 terr = &lerr;
2223
2224 if (fInterpreter) {
2225 TString aclicMode;
2226 TString arguments;
2227 TString io;
2228 TString fname = gSystem->SplitAclicMode(filename, aclicMode, arguments, io);
2229
2230 if (arguments.Length()) {
2231 Warning("LoadMacro", "argument(%s) ignored in %s", arguments.Data(), GetMacroPath());
2232 }
2233 char *mac = gSystem->Which(GetMacroPath(), fname, kReadPermission);
2234 if (!mac) {
2235 if (!check)
2236 Error("LoadMacro", "macro %s not found in path %s", fname.Data(), GetMacroPath());
2237 *terr = TInterpreter::kFatal;
2238 } else {
2239 err = 0;
2240 if (!check) {
2241 fname = mac;
2242 fname += aclicMode;
2243 fname += io;
2244 gInterpreter->LoadMacro(fname.Data(), (TInterpreter::EErrorCode*)terr);
2245 if (*terr)
2246 err = -1;
2247 }
2248 }
2249 delete [] mac;
2250 }
2251 return err;
2252}
2253
2254////////////////////////////////////////////////////////////////////////////////
2255/// Execute a macro in the interpreter. Equivalent to the command line
2256/// command ".x filename". If the filename has "+" or "++" appended
2257/// the macro will be compiled by ACLiC. The filename must have the format:
2258/// [path/]macro.C[+|++[g|O]][(args)].
2259/// The possible error codes are defined by TInterpreter::EErrorCode.
2260/// If padUpdate is true (default) update the current pad.
2261/// Returns the macro return value.
2262
2263Longptr_t TROOT::Macro(const char *filename, Int_t *error, Bool_t padUpdate)
2264{
2265 Longptr_t result = 0;
2266
2267 if (fInterpreter) {
2268 TString aclicMode;
2269 TString arguments;
2270 TString io;
2271 TString fname = gSystem->SplitAclicMode(filename, aclicMode, arguments, io);
2272
2273 char *mac = gSystem->Which(GetMacroPath(), fname, kReadPermission);
2274 if (!mac) {
2275 Error("Macro", "macro %s not found in path %s", fname.Data(), GetMacroPath());
2276 if (error)
2277 *error = TInterpreter::kFatal;
2278 } else {
2279 fname = mac;
2280 fname += aclicMode;
2281 fname += arguments;
2282 fname += io;
2283 result = gInterpreter->ExecuteMacro(fname, (TInterpreter::EErrorCode*)error);
2284 }
2285 delete [] mac;
2286
2287 if (padUpdate && gPad)
2288 gPad->Update();
2289 }
2290
2291 return result;
2292}
2293
2294////////////////////////////////////////////////////////////////////////////////
2295/// Process message id called by obj.
2296
2297void TROOT::Message(Int_t id, const TObject *obj)
2298{
2299 TIter next(fMessageHandlers);
2300 TMessageHandler *mh;
2301 while ((mh = (TMessageHandler*)next())) {
2302 mh->HandleMessage(id,obj);
2303 }
2304}
2305
2306////////////////////////////////////////////////////////////////////////////////
2307/// Process interpreter command via TApplication::ProcessLine().
2308/// On Win32 the line will be processed asynchronously by sending
2309/// it to the CINT interpreter thread. For explicit synchronous processing
2310/// use ProcessLineSync(). On non-Win32 platforms there is no difference
2311/// between ProcessLine() and ProcessLineSync().
2312/// The possible error codes are defined by TInterpreter::EErrorCode. In
2313/// particular, error will equal to TInterpreter::kProcessing until the
2314/// CINT interpreted thread has finished executing the line.
2315/// Returns the result of the command, cast to a Longptr_t.
2316
2318{
2319 TString sline = line;
2320 sline = sline.Strip(TString::kBoth);
2321
2322 if (!fApplication.load())
2324
2325 return (*fApplication).ProcessLine(sline, kFALSE, error);
2326}
2327
2328////////////////////////////////////////////////////////////////////////////////
2329/// Process interpreter command via TApplication::ProcessLine().
2330/// On Win32 the line will be processed synchronously (i.e. it will
2331/// only return when the CINT interpreter thread has finished executing
2332/// the line). On non-Win32 platforms there is no difference between
2333/// ProcessLine() and ProcessLineSync().
2334/// The possible error codes are defined by TInterpreter::EErrorCode.
2335/// Returns the result of the command, cast to a Longptr_t.
2336
2338{
2339 TString sline = line;
2340 sline = sline.Strip(TString::kBoth);
2341
2342 if (!fApplication.load())
2344
2345 return (*fApplication).ProcessLine(sline, kTRUE, error);
2346}
2347
2348////////////////////////////////////////////////////////////////////////////////
2349/// Process interpreter command directly via CINT interpreter.
2350/// Only executable statements are allowed (no variable declarations),
2351/// In all other cases use TROOT::ProcessLine().
2352/// The possible error codes are defined by TInterpreter::EErrorCode.
2353
2355{
2356 TString sline = line;
2357 sline = sline.Strip(TString::kBoth);
2358
2359 if (!fApplication.load())
2361
2362 Longptr_t result = 0;
2363
2364 if (fInterpreter) {
2366 result = gInterpreter->Calc(sline, code);
2367 }
2368
2369 return result;
2370}
2371
2372////////////////////////////////////////////////////////////////////////////////
2373/// Read Git commit information and branch name from the
2374/// etc/gitinfo.txt file.
2375
2377{
2378#ifdef ROOT_GIT_COMMIT
2379 fGitCommit = ROOT_GIT_COMMIT;
2380#endif
2381#ifdef ROOT_GIT_BRANCH
2382 fGitBranch = ROOT_GIT_BRANCH;
2383#endif
2384
2385 TString gitinfo = "gitinfo.txt";
2386 char *filename = gSystem->ConcatFileName(TROOT::GetEtcDir(), gitinfo);
2387
2388 FILE *fp = fopen(filename, "r");
2389 if (fp) {
2390 TString s;
2391 // read branch name
2392 s.Gets(fp);
2393 fGitBranch = s;
2394 // read commit SHA1
2395 s.Gets(fp);
2396 fGitCommit = s;
2397 // read date/time make was run
2398 s.Gets(fp);
2399 fGitDate = s;
2400 fclose(fp);
2401 }
2402 delete [] filename;
2403}
2404
2406 TTHREAD_TLS(Bool_t) fgReadingObject = false;
2407 return fgReadingObject;
2408}
2409
2410////////////////////////////////////////////////////////////////////////////////
2411/// Deprecated (will be removed in next release).
2412
2414{
2415 return GetReadingObject();
2416}
2417
2419{
2420 GetReadingObject() = flag;
2421}
2422
2423
2424////////////////////////////////////////////////////////////////////////////////
2425/// Return date/time make was run.
2426
2428{
2429 if (fGitDate == "") {
2430 Int_t iday,imonth,iyear, ihour, imin;
2431 static const char *months[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
2432 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
2433 Int_t idate = gROOT->GetBuiltDate();
2434 Int_t itime = gROOT->GetBuiltTime();
2435 iday = idate%100;
2436 imonth = (idate/100)%100;
2437 iyear = idate/10000;
2438 ihour = itime/100;
2439 imin = itime%100;
2440 fGitDate.Form("%s %02d %4d, %02d:%02d:00", months[imonth-1], iday, iyear, ihour, imin);
2441 }
2442 return fGitDate;
2443}
2444
2445////////////////////////////////////////////////////////////////////////////////
2446/// Recursively remove this object from the list of Cleanups.
2447/// Typically RecursiveRemove is implemented by classes that can contain
2448/// mulitple references to a same object or shared ownership of the object
2449/// with others.
2450
2452{
2454
2456}
2457
2458////////////////////////////////////////////////////////////////////////////////
2459/// Refresh all browsers. Call this method when some command line
2460/// command or script has changed the browser contents. Not needed
2461/// for objects that have the kMustCleanup bit set. Most useful to
2462/// update browsers that show the file system or other objects external
2463/// to the running ROOT session.
2464
2466{
2467 TIter next(GetListOfBrowsers());
2468 TBrowser *b;
2469 while ((b = (TBrowser*) next()))
2470 b->SetRefreshFlag(kTRUE);
2471}
2472////////////////////////////////////////////////////////////////////////////////
2473/// Insure that the files, canvases and sockets are closed.
2474
2475static void CallCloseFiles()
2476{
2478 gROOT->CloseFiles();
2479 }
2480}
2481
2482////////////////////////////////////////////////////////////////////////////////
2483/// Called by static dictionary initialization to register clang modules
2484/// for headers. Calls TCling::RegisterModule() unless gCling
2485/// is NULL, i.e. during startup, where the information is buffered in
2486/// the static GetModuleHeaderInfoBuffer().
2487
2488void TROOT::RegisterModule(const char* modulename,
2489 const char** headers,
2490 const char** includePaths,
2491 const char* payloadCode,
2492 const char* fwdDeclCode,
2493 void (*triggerFunc)(),
2494 const TInterpreter::FwdDeclArgsToKeepCollection_t& fwdDeclsArgToSkip,
2495 const char** classesHeaders,
2496 bool hasCxxModule)
2497{
2498
2499 // First a side track to insure proper end of process behavior.
2500
2501 // Register for each loaded dictionary (and thus for each library),
2502 // that we need to Close the ROOT files as soon as this library
2503 // might start being unloaded after main.
2504 //
2505 // By calling atexit here (rather than directly from within the
2506 // library) we make sure that this is not called if the library is
2507 // 'only' dlclosed.
2508
2509 // On Ubuntu the linker strips the unused libraries. Eventhough
2510 // stressHistogram is explicitly linked against libNet, it is not
2511 // retained and thus is loaded only as needed in the middle part of
2512 // the execution. Concretely this also means that it is loaded
2513 // *after* the construction of the TApplication object and thus
2514 // after the registration (atexit) of the EndOfProcessCleanups
2515 // routine. Consequently, after the end of main, libNet is
2516 // unloaded before EndOfProcessCleanups is called. When
2517 // EndOfProcessCleanups is executed it indirectly needs the TClass
2518 // for TSocket and its search will use resources that have already
2519 // been unloaded (technically the function static in TUnixSystem's
2520 // DynamicPath and the dictionary from libNet).
2521
2522 // Similarly, the ordering (before this commit) was broken in the
2523 // following case:
2524
2525 // TApplication creation (EndOfProcessCleanups registration)
2526 // load UserLibrary
2527 // create TFile
2528 // Append UserObject to TFile
2529
2530 // and after the end of main the order of execution was
2531
2532 // unload UserLibrary
2533 // call EndOfProcessCleanups
2534 // Write the TFile
2535 // attempt to write the user object.
2536 // ....
2537
2538 // where what we need is to have the files closen/written before
2539 // the unloading of the library.
2540
2541 // To solve the problem we now register an atexit function for
2542 // every dictionary thus making sure there is at least one executed
2543 // before the first library tear down after main.
2544
2545 // If atexit is called directly within a library's code, the
2546 // function will called *either* when the library is 'dlclose'd or
2547 // after then end of main (whichever comes first). We do *not*
2548 // want the files to be closed whenever a library is unloaded via
2549 // dlclose. To avoid this, we add the function (CallCloseFiles)
2550 // from the dictionary indirectly (via ROOT::RegisterModule). In
2551 // this case the function will only only be called either when
2552 // libCore is 'dlclose'd or right after the end of main.
2553
2554 atexit(CallCloseFiles);
2555
2556 // Now register with TCling.
2557 if (TROOT::Initialized()) {
2558 gCling->RegisterModule(modulename, headers, includePaths, payloadCode, fwdDeclCode, triggerFunc,
2559 fwdDeclsArgToSkip, classesHeaders, false, hasCxxModule);
2560 } else {
2561 GetModuleHeaderInfoBuffer().push_back(ModuleHeaderInfo_t(modulename, headers, includePaths, payloadCode,
2562 fwdDeclCode, triggerFunc, fwdDeclsArgToSkip,
2563 classesHeaders, hasCxxModule));
2564 }
2565}
2566
2567////////////////////////////////////////////////////////////////////////////////
2568/// Remove an object from the in-memory list.
2569/// Since TROOT is global resource, this is lock protected.
2570
2572{
2574 return TDirectory::Remove(obj);
2575}
2576
2577////////////////////////////////////////////////////////////////////////////////
2578/// Remove a class from the list and map of classes.
2579/// This routine is deprecated, use TClass::RemoveClass directly.
2580
2582{
2583 TClass::RemoveClass(oldcl);
2584}
2585
2586////////////////////////////////////////////////////////////////////////////////
2587/// Delete all global interpreter objects created since the last call to Reset
2588///
2589/// If option="a" is set reset to startup context (i.e. unload also
2590/// all loaded files, classes, structs, typedefs, etc.).
2591///
2592/// This function is typically used at the beginning (or end) of an unnamed macro
2593/// to clean the environment.
2594///
2595/// IMPORTANT WARNING:
2596/// Do not use this call from within any function (neither compiled nor
2597/// interpreted. This should only be used from a unnamed macro
2598/// (which starts with a { (curly braces) ). For example, using TROOT::Reset
2599/// from within an interpreted function will lead to the unloading of the
2600/// dictionary and source file, including the one defining the function being
2601/// executed.
2602///
2603
2605{
2606 if (IsExecutingMacro()) return; //True when TMacro::Exec runs
2607 if (fInterpreter) {
2608 if (!strncmp(option, "a", 1)) {
2611 } else
2612 gInterpreter->ResetGlobals();
2613
2614 if (fGlobals) fGlobals->Unload();
2616
2617 SaveContext();
2618 }
2619}
2620
2621////////////////////////////////////////////////////////////////////////////////
2622/// Save the current interpreter context.
2623
2625{
2626 if (fInterpreter)
2627 gInterpreter->SaveGlobalsContext();
2628}
2629
2630////////////////////////////////////////////////////////////////////////////////
2631/// Set the default graphical cut class name for the graphics editor
2632/// By default the graphics editor creates an instance of a class TCutG.
2633/// This function may be called to specify a different class that MUST
2634/// derive from TCutG
2635
2637{
2638 if (!name) {
2639 Error("SetCutClassName","Invalid class name");
2640 return;
2641 }
2643 if (!cl) {
2644 Error("SetCutClassName","Unknown class:%s",name);
2645 return;
2646 }
2647 if (!cl->InheritsFrom("TCutG")) {
2648 Error("SetCutClassName","Class:%s does not derive from TCutG",name);
2649 return;
2650 }
2652}
2653
2654////////////////////////////////////////////////////////////////////////////////
2655/// Set editor mode
2656
2657void TROOT::SetEditorMode(const char *mode)
2658{
2659 fEditorMode = 0;
2660 if (!mode[0]) return;
2661 if (!strcmp(mode,"Arc")) {fEditorMode = kArc; return;}
2662 if (!strcmp(mode,"Line")) {fEditorMode = kLine; return;}
2663 if (!strcmp(mode,"Arrow")) {fEditorMode = kArrow; return;}
2664 if (!strcmp(mode,"Button")) {fEditorMode = kButton; return;}
2665 if (!strcmp(mode,"Diamond")) {fEditorMode = kDiamond; return;}
2666 if (!strcmp(mode,"Ellipse")) {fEditorMode = kEllipse; return;}
2667 if (!strcmp(mode,"Pad")) {fEditorMode = kPad; return;}
2668 if (!strcmp(mode,"Pave")) {fEditorMode = kPave; return;}
2669 if (!strcmp(mode,"PaveLabel")){fEditorMode = kPaveLabel; return;}
2670 if (!strcmp(mode,"PaveText")) {fEditorMode = kPaveText; return;}
2671 if (!strcmp(mode,"PavesText")){fEditorMode = kPavesText; return;}
2672 if (!strcmp(mode,"PolyLine")) {fEditorMode = kPolyLine; return;}
2673 if (!strcmp(mode,"CurlyLine")){fEditorMode = kCurlyLine; return;}
2674 if (!strcmp(mode,"CurlyArc")) {fEditorMode = kCurlyArc; return;}
2675 if (!strcmp(mode,"Text")) {fEditorMode = kText; return;}
2676 if (!strcmp(mode,"Marker")) {fEditorMode = kMarker; return;}
2677 if (!strcmp(mode,"CutG")) {fEditorMode = kCutG; return;}
2678}
2679
2680////////////////////////////////////////////////////////////////////////////////
2681/// Change current style to style with name stylename
2682
2683void TROOT::SetStyle(const char *stylename)
2684{
2685 TString style_name = stylename;
2686
2687 TStyle *style = GetStyle(style_name);
2688 if (style) style->cd();
2689 else Error("SetStyle","Unknown style:%s",style_name.Data());
2690}
2691
2692
2693//-------- Static Member Functions ---------------------------------------------
2694
2695
2696////////////////////////////////////////////////////////////////////////////////
2697/// Decrease the indentation level for ls().
2698
2700{
2701 return --fgDirLevel;
2702}
2703
2704////////////////////////////////////////////////////////////////////////////////
2705///return directory level
2706
2708{
2709 return fgDirLevel;
2710}
2711
2712////////////////////////////////////////////////////////////////////////////////
2713/// Get macro search path. Static utility function.
2714
2716{
2717 TString &macroPath = ROOT::GetMacroPath();
2718
2719 if (macroPath.Length() == 0) {
2720 macroPath = gEnv->GetValue("Root.MacroPath", (char*)nullptr);
2721#if defined(R__WIN32)
2722 macroPath.ReplaceAll("; ", ";");
2723#else
2724 macroPath.ReplaceAll(": ", ":");
2725#endif
2726 if (macroPath.Length() == 0)
2727#if !defined(R__WIN32)
2728 macroPath = ".:" + TROOT::GetMacroDir();
2729#else
2730 macroPath = ".;" + TROOT::GetMacroDir();
2731#endif
2732 }
2733
2734 return macroPath;
2735}
2736
2737////////////////////////////////////////////////////////////////////////////////
2738/// Set or extend the macro search path. Static utility function.
2739/// If newpath=0 or "" reset to value specified in the rootrc file.
2740
2741void TROOT::SetMacroPath(const char *newpath)
2742{
2743 TString &macroPath = ROOT::GetMacroPath();
2744
2745 if (!newpath || !*newpath)
2746 macroPath = "";
2747 else
2748 macroPath = newpath;
2749}
2750
2751////////////////////////////////////////////////////////////////////////////////
2752/// \brief Specify where web graphics shall be rendered
2753///
2754/// The input parameter `webdisplay` defines where web graphics is rendered.
2755/// `webdisplay` parameter may contain:
2756///
2757/// - "off": turns off the web display and comes back to normal graphics in
2758/// interactive mode.
2759/// - "batch": turns the web display in batch mode. It can be prepended with
2760/// another string which is considered as the new current web display.
2761/// - "nobatch": turns the web display in interactive mode. It can be
2762/// prepended with another string which is considered as the new current web display.
2763///
2764/// If the option "off" is not set, this method turns the normal graphics to
2765/// "Batch" to avoid the loading of local graphics libraries.
2766
2767void TROOT::SetWebDisplay(const char *webdisplay)
2768{
2769 const char *wd = webdisplay;
2770 if (!wd)
2771 wd = "";
2772
2773 if (!strcmp(wd, "off")) {
2776 fWebDisplay = "";
2777 } else {
2779 if (!strncmp(wd, "batch", 5)) {
2781 wd += 5;
2782 } else if (!strncmp(wd, "nobatch", 7)) {
2784 wd += 7;
2785 } else {
2787 }
2788 fWebDisplay = wd;
2789 }
2790}
2791
2792////////////////////////////////////////////////////////////////////////////////
2793/// Increase the indentation level for ls().
2794
2796{
2797 return ++fgDirLevel;
2798}
2799
2800////////////////////////////////////////////////////////////////////////////////
2801/// Functions used by ls() to indent an object hierarchy.
2802
2804{
2805 for (int i = 0; i < fgDirLevel; i++) std::cout.put(' ');
2806}
2807
2808////////////////////////////////////////////////////////////////////////////////
2809/// Initialize ROOT explicitly.
2810
2812 (void) gROOT;
2813}
2814
2815////////////////////////////////////////////////////////////////////////////////
2816/// Return kTRUE if the TROOT object has been initialized.
2817
2819{
2820 return fgRootInit;
2821}
2822
2823////////////////////////////////////////////////////////////////////////////////
2824/// Return Indentation level for ls().
2825
2827{
2828 fgDirLevel = level;
2829}
2830
2831////////////////////////////////////////////////////////////////////////////////
2832/// Convert version code to an integer, i.e. 331527 -> 51507.
2833
2835{
2836 return 10000*(code>>16) + 100*((code&65280)>>8) + (code&255);
2837}
2838
2839////////////////////////////////////////////////////////////////////////////////
2840/// Convert version as an integer to version code as used in RVersion.h.
2841
2843{
2844 int a = v/10000;
2845 int b = (v - a*10000)/100;
2846 int c = v - a*10000 - b*100;
2847 return (a << 16) + (b << 8) + c;
2848}
2849
2850////////////////////////////////////////////////////////////////////////////////
2851/// Return ROOT version code as defined in RVersion.h.
2852
2854{
2855 return ROOT_VERSION_CODE;
2856}
2857////////////////////////////////////////////////////////////////////////////////
2858/// Provide command line arguments to the interpreter construction.
2859/// These arguments are added to the existing flags (e.g. `-DNDEBUG`).
2860/// They are evaluated once per process, at the time where TROOT (and thus
2861/// TInterpreter) is constructed.
2862/// Returns the new flags.
2863
2864const std::vector<std::string> &TROOT::AddExtraInterpreterArgs(const std::vector<std::string> &args) {
2865 static std::vector<std::string> sArgs = {};
2866 sArgs.insert(sArgs.begin(), args.begin(), args.end());
2867 return sArgs;
2868}
2869
2870////////////////////////////////////////////////////////////////////////////////
2871/// INTERNAL function!
2872/// Used by rootcling to inject interpreter arguments through a C-interface layer.
2873
2875 static const char** extraInterpArgs = nullptr;
2876 return extraInterpArgs;
2877}
2878
2879////////////////////////////////////////////////////////////////////////////////
2880
2881#ifdef ROOTPREFIX
2882static Bool_t IgnorePrefix() {
2883 static Bool_t ignorePrefix = gSystem->Getenv("ROOTIGNOREPREFIX");
2884 return ignorePrefix;
2885}
2886#endif
2887
2888////////////////////////////////////////////////////////////////////////////////
2889/// Get the rootsys directory in the installation. Static utility function.
2890
2892 // Avoid returning a reference to a temporary because of the conversion
2893 // between std::string and TString.
2894 const static TString rootsys = ROOT::FoundationUtils::GetRootSys();
2895 return rootsys;
2896}
2897
2898////////////////////////////////////////////////////////////////////////////////
2899/// Get the binary directory in the installation. Static utility function.
2900
2902#ifdef ROOTBINDIR
2903 if (IgnorePrefix()) {
2904#endif
2905 static TString rootbindir;
2906 if (rootbindir.IsNull()) {
2907 rootbindir = "bin";
2908 gSystem->PrependPathName(GetRootSys(), rootbindir);
2909 }
2910 return rootbindir;
2911#ifdef ROOTBINDIR
2912 } else {
2913 const static TString rootbindir = ROOTBINDIR;
2914 return rootbindir;
2915 }
2916#endif
2917}
2918
2919////////////////////////////////////////////////////////////////////////////////
2920/// Get the library directory in the installation. Static utility function.
2921
2923#ifdef ROOTLIBDIR
2924 if (IgnorePrefix()) {
2925#endif
2926 static TString rootlibdir;
2927 if (rootlibdir.IsNull()) {
2928 rootlibdir = "lib";
2929 gSystem->PrependPathName(GetRootSys(), rootlibdir);
2930 }
2931 return rootlibdir;
2932#ifdef ROOTLIBDIR
2933 } else {
2934 const static TString rootlibdir = ROOTLIBDIR;
2935 return rootlibdir;
2936 }
2937#endif
2938}
2939
2940////////////////////////////////////////////////////////////////////////////////
2941/// Get the include directory in the installation. Static utility function.
2942
2944 // Avoid returning a reference to a temporary because of the conversion
2945 // between std::string and TString.
2946 const static TString includedir = ROOT::FoundationUtils::GetIncludeDir();
2947 return includedir;
2948}
2949
2950////////////////////////////////////////////////////////////////////////////////
2951/// Get the sysconfig directory in the installation. Static utility function.
2952
2954 // Avoid returning a reference to a temporary because of the conversion
2955 // between std::string and TString.
2956 const static TString etcdir = ROOT::FoundationUtils::GetEtcDir();
2957 return etcdir;
2958}
2959
2960////////////////////////////////////////////////////////////////////////////////
2961/// Get the data directory in the installation. Static utility function.
2962
2964#ifdef ROOTDATADIR
2965 if (IgnorePrefix()) {
2966#endif
2967 return GetRootSys();
2968#ifdef ROOTDATADIR
2969 } else {
2970 const static TString rootdatadir = ROOTDATADIR;
2971 return rootdatadir;
2972 }
2973#endif
2974}
2975
2976////////////////////////////////////////////////////////////////////////////////
2977/// Get the documentation directory in the installation. Static utility function.
2978
2980#ifdef ROOTDOCDIR
2981 if (IgnorePrefix()) {
2982#endif
2983 return GetRootSys();
2984#ifdef ROOTDOCDIR
2985 } else {
2986 const static TString rootdocdir = ROOTDOCDIR;
2987 return rootdocdir;
2988 }
2989#endif
2990}
2991
2992////////////////////////////////////////////////////////////////////////////////
2993/// Get the macro directory in the installation. Static utility function.
2994
2996#ifdef ROOTMACRODIR
2997 if (IgnorePrefix()) {
2998#endif
2999 static TString rootmacrodir;
3000 if (rootmacrodir.IsNull()) {
3001 rootmacrodir = "macros";
3002 gSystem->PrependPathName(GetRootSys(), rootmacrodir);
3003 }
3004 return rootmacrodir;
3005#ifdef ROOTMACRODIR
3006 } else {
3007 const static TString rootmacrodir = ROOTMACRODIR;
3008 return rootmacrodir;
3009 }
3010#endif
3011}
3012
3013////////////////////////////////////////////////////////////////////////////////
3014/// Get the tutorials directory in the installation. Static utility function.
3015
3017#ifdef ROOTTUTDIR
3018 if (IgnorePrefix()) {
3019#endif
3020 static TString roottutdir;
3021 if (roottutdir.IsNull()) {
3022 roottutdir = "tutorials";
3023 gSystem->PrependPathName(GetRootSys(), roottutdir);
3024 }
3025 return roottutdir;
3026#ifdef ROOTTUTDIR
3027 } else {
3028 const static TString roottutdir = ROOTTUTDIR;
3029 return roottutdir;
3030 }
3031#endif
3032}
3033
3034////////////////////////////////////////////////////////////////////////////////
3035/// Shut down ROOT.
3036
3038{
3039 if (gROOT)
3040 gROOT->EndOfProcessCleanups();
3041 else if (gInterpreter)
3042 gInterpreter->ShutDown();
3043}
3044
3045////////////////////////////////////////////////////////////////////////////////
3046/// Get the source directory in the installation. Static utility function.
3047
3049#ifdef ROOTSRCDIR
3050 if (IgnorePrefix()) {
3051#endif
3052 static TString rootsrcdir;
3053 if (rootsrcdir.IsNull()) {
3054 rootsrcdir = "src";
3055 gSystem->PrependPathName(GetRootSys(), rootsrcdir);
3056 }
3057 return rootsrcdir;
3058#ifdef ROOTSRCDIR
3059 } else {
3060 const static TString rootsrcdir = ROOTSRCDIR;
3061 return rootsrcdir;
3062 }
3063#endif
3064}
3065
3066////////////////////////////////////////////////////////////////////////////////
3067/// Get the icon path in the installation. Static utility function.
3068
3070#ifdef ROOTICONPATH
3071 if (IgnorePrefix()) {
3072#endif
3073 static TString rooticonpath;
3074 if (rooticonpath.IsNull()) {
3075 rooticonpath = "icons";
3076 gSystem->PrependPathName(GetRootSys(), rooticonpath);
3077 }
3078 return rooticonpath;
3079#ifdef ROOTICONPATH
3080 } else {
3081 const static TString rooticonpath = ROOTICONPATH;
3082 return rooticonpath;
3083 }
3084#endif
3085}
3086
3087////////////////////////////////////////////////////////////////////////////////
3088/// Get the fonts directory in the installation. Static utility function.
3089
3091#ifdef TTFFONTDIR
3092 if (IgnorePrefix()) {
3093#endif
3094 static TString ttffontdir;
3095 if (ttffontdir.IsNull()) {
3096 ttffontdir = "fonts";
3097 gSystem->PrependPathName(GetRootSys(), ttffontdir);
3098 }
3099 return ttffontdir;
3100#ifdef TTFFONTDIR
3101 } else {
3102 const static TString ttffontdir = TTFFONTDIR;
3103 return ttffontdir;
3104 }
3105#endif
3106}
3107
3108////////////////////////////////////////////////////////////////////////////////
3109/// Get the tutorials directory in the installation. Static utility function.
3110/// Backward compatibility function - do not use for new code
3111
3113 return GetTutorialDir();
3114}
@ kMarker
Definition: Buttons.h:34
@ kCurlyArc
Definition: Buttons.h:38
@ kPad
Definition: Buttons.h:30
@ kPolyLine
Definition: Buttons.h:28
@ kDiamond
Definition: Buttons.h:37
@ kPave
Definition: Buttons.h:31
@ kArrow
Definition: Buttons.h:33
@ kPaveText
Definition: Buttons.h:32
@ kCutG
Definition: Buttons.h:38
@ kLine
Definition: Buttons.h:33
@ kPavesText
Definition: Buttons.h:32
@ kCurlyLine
Definition: Buttons.h:38
@ kPaveLabel
Definition: Buttons.h:31
@ kButton
Definition: Buttons.h:37
@ kEllipse
Definition: Buttons.h:32
@ kText
Definition: Buttons.h:30
@ kArc
Definition: Buttons.h:33
The file contains utilities which are foundational and could be used across the core component of ROO...
typedef void(GLAPIENTRYP _GLUfuncptr)(void)
#define SafeDelete(p)
Definition: RConfig.hxx:536
#define d(i)
Definition: RSha256.hxx:102
#define b(i)
Definition: RSha256.hxx:100
#define f(i)
Definition: RSha256.hxx:104
#define c(i)
Definition: RSha256.hxx:101
#define g(i)
Definition: RSha256.hxx:105
#define ROOT_RELEASE
Definition: RVersion.h:17
#define ROOT_RELEASE_TIME
Definition: RVersion.h:19
#define ROOT_VERSION_CODE
Definition: RVersion.h:21
#define ROOT_RELEASE_DATE
Definition: RVersion.h:18
const Ssiz_t kNPOS
Definition: RtypesCore.h:124
int Int_t
Definition: RtypesCore.h:45
long Longptr_t
Definition: RtypesCore.h:82
unsigned int UInt_t
Definition: RtypesCore.h:46
const Bool_t kFALSE
Definition: RtypesCore.h:101
bool Bool_t
Definition: RtypesCore.h:63
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
#define ClassImp(name)
Definition: Rtypes.h:364
void(* VoidFuncPtr_t)()
Definition: Rtypes.h:79
R__EXTERN TClassTable * gClassTable
Definition: TClassTable.h:95
R__DLLEXPORT TInterpreter * CreateInterpreter(void *interpLibHandle, const char *argv[])
Definition: TCling.cxx:598
#define gDirectory
Definition: TDirectory.h:348
R__EXTERN TEnv * gEnv
Definition: TEnv.h:170
void DefaultErrorHandler(Int_t level, Bool_t abort_bool, const char *location, const char *msg)
The default error handler function.
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition: TError.cxx:187
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
Definition: TError.cxx:231
ErrorHandlerFunc_t SetErrorHandler(ErrorHandlerFunc_t newhandler)
Set an errorhandler function. Returns the old handler.
Definition: TError.cxx:92
char name[80]
Definition: TGX11.cxx:110
R__EXTERN TGuiFactory * gBatchGuiFactory
Definition: TGuiFactory.h:67
R__EXTERN TGuiFactory * gGuiFactory
Definition: TGuiFactory.h:66
R__EXTERN TVirtualMutex * gInterpreterMutex
Definition: TInterpreter.h:44
TInterpreter * CreateInterpreter_t(void *shlibHandle, const char *argv[])
Definition: TInterpreter.h:558
R__EXTERN TInterpreter * gCling
Definition: TInterpreter.h:563
#define gInterpreter
Definition: TInterpreter.h:562
void * DestroyInterpreter_t(TInterpreter *)
Definition: TInterpreter.h:559
R__EXTERN TPluginManager * gPluginMgr
Bool_t & GetReadingObject()
Definition: TROOT.cxx:2405
static Int_t IVERSQ()
Return version id as an integer, i.e. "2.22/04" -> 22204.
Definition: TROOT.cxx:183
static Int_t IDATQQ(const char *date)
Return built date as integer, i.e. "Apr 28 2000" -> 20000428.
Definition: TROOT.cxx:193
static TClass * R__GetClassIfKnown(const char *className)
Check whether className is a known class, and only autoload if we can.
Definition: TROOT.cxx:1854
static DestroyInterpreter_t * gDestroyInterpreter
Definition: TROOT.cxx:169
Int_t gDebug
Definition: TROOT.cxx:592
static void * gInterpreterLib
Definition: TROOT.cxx:170
static Int_t ITIMQQ(const char *time)
Return built time as integer (with min precision), i.e.
Definition: TROOT.cxx:214
static void at_exit_of_TROOT()
Definition: TROOT.cxx:288
TVirtualMutex * gROOTMutex
Definition: TROOT.cxx:173
static void CleanUpROOTAtExit()
Clean up at program termination before global objects go out of scope.
Definition: TROOT.cxx:224
static void CallCloseFiles()
Insure that the files, canvases and sockets are closed.
Definition: TROOT.cxx:2475
void R__SetZipMode(int)
#define gROOT
Definition: TROOT.h:404
R__EXTERN TStyle * gStyle
Definition: TStyle.h:412
void(* Func_t)()
Definition: TSystem.h:238
R__EXTERN const char * gRootDir
Definition: TSystem.h:241
@ kReadPermission
Definition: TSystem.h:47
Bool_t R_ISREG(Int_t mode)
Definition: TSystem.h:118
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
R__EXTERN TVirtualMutex * gGlobalMutex
Definition: TVirtualMutex.h:27
#define R__LOCKGUARD(mutex)
#define gPad
Definition: TVirtualPad.h:287
#define R__READ_LOCKGUARD(mutex)
#define gVirtualX
Definition: TVirtualX.h:338
R__EXTERN TVirtualX * gGXBatch
Definition: TVirtualX.h:341
const char * proto
Definition: civetweb.c:16604
char fHolder[sizeof(TROOT)]
Definition: TROOT.cxx:330
static void CreateApplication()
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:37
The Canvas class.
Definition: TCanvas.h:23
TVirtualPad * cd(Int_t subpadnumber=0) override
Set current canvas & pad.
Definition: TCanvas.cxx:706
Objects following this interface can be passed onto the TROOT object to implement a user customized w...
This class registers for all classes their name, id and dictionary function in a hash table.
Definition: TClassTable.h:36
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:80
static void AddClass(TClass *cl)
static: Add a class to the list and map of classes.
Definition: TClass.cxx:494
static TClass * LoadClass(const char *requestedname, Bool_t silent)
Helper function used by TClass::GetClass().
Definition: TClass.cxx:5742
Short_t GetDeclFileLine() const
Definition: TClass.h:426
static void RemoveClass(TClass *cl)
static: Remove a class from the list and map of classes
Definition: TClass.cxx:520
ClassInfo_t * GetClassInfo() const
Definition: TClass.h:430
Bool_t InheritsFrom(const char *cl) const
Return kTRUE if this class inherits from a class with name "classname".
Definition: TClass.cxx:4867
const char * GetDeclFileName() const
Return name of the file containing the declaration of this class.
Definition: TClass.cxx:3416
@ kClassSaved
Definition: TClass.h:94
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.
Definition: TClass.cxx:2955
Collection abstract base class.
Definition: TCollection.h:65
virtual TObject * FindObject(const char *name) const
Find an object in this collection using its name.
virtual bool UseRWLock()
Set this collection to use a RW lock upon access, making it thread safe.
virtual void Clear(Option_t *option="")=0
virtual void AddAll(const TCollection *col)
Add all objects from collection col to this collection.
virtual void RecursiveRemove(TObject *obj)
Remove object from this collection and recursively remove the object from all other objects (and coll...
virtual void Delete(Option_t *option="")=0
Delete this object.
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
virtual void Add(TObject *obj)=0
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:184
The color creation and management class.
Definition: TColor.h:19
static void InitializeColors()
Initialize colors used by the TCanvas based graphics (via TColor objects).
Definition: TColor.cxx:1095
Int_t GetNumber() const
Definition: TColor.h:55
Basic data type descriptor (datatype information is obtained from CINT).
Definition: TDataType.h:44
Describe directory structure in memory.
Definition: TDirectory.h:45
virtual void Close(Option_t *option="")
Delete all objects from memory and directory structure itself.
Definition: TDirectory.cxx:593
virtual TList * GetList() const
Definition: TDirectory.h:213
void ls(Option_t *option="") const override
List Directory contents.
virtual void Append(TObject *obj, Bool_t replace=kFALSE)
Append object to this directory.
Definition: TDirectory.cxx:191
void SetName(const char *newname) override
Set the name for directory If the directory name is changed after the directory was written once,...
void BuildDirectory(TFile *motherFile, TDirectory *motherDir)
Initialise directory to defaults.
Definition: TDirectory.cxx:238
static std::atomic< TDirectory * > & CurrentDirectory()
Return the current directory for the current thread.
Definition: TDirectory.cxx:387
virtual TObject * Remove(TObject *)
Remove an object from the in-memory list.
TList * fList
Definition: TDirectory.h:138
The TEnv class reads config files, by default named .rootrc.
Definition: TEnv.h:124
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
Definition: TEnv.cxx:491
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format.
Definition: TFile.h:54
A TFolder object is a collection of objects and folders.
Definition: TFolder.h:30
TFolder * AddFolder(const char *name, const char *title, TCollection *collection=0)
Create a new folder and add it to the list of folders of this folder, return a pointer to the created...
Definition: TFolder.cxx:188
virtual TObject * FindObjectAny(const char *name) const
Return a pointer to the first object with name starting at this folder.
Definition: TFolder.cxx:349
Dictionary for function template This class describes one single function template.
Global functions class (global functions are obtained from CINT).
Definition: TFunction.h:30
static void MakeFunctor(const char *name, const char *type, GlobFunc &func)
Definition: TGlobal.h:73
static TList & GetEarlyRegisteredGlobals()
Returns list collected globals Used to storeTGlobalMappedFunctions from other libs,...
Definition: TGlobal.cxx:185
Global variables class (global variables are obtained from CINT).
Definition: TGlobal.h:28
This ABC is a factory for GUI components.
Definition: TGuiFactory.h:42
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
Definition: THashList.h:34
THashTable implements a hash table to store TObject's.
Definition: THashTable.h:35
virtual void RegisterModule(const char *, const char **, const char **, const char *, const char *, void(*)(), const FwdDeclArgsToKeepCollection_t &fwdDeclArgsToKeep, const char **classesHeaders, Bool_t lateRegistration=false, Bool_t hasCxxModule=false)=0
virtual void Reset()=0
virtual void Initialize()=0
std::vector< std::pair< std::string, int > > FwdDeclArgsToKeepCollection_t
Definition: TInterpreter.h:137
virtual void SaveContext()=0
TDictionary::DeclId_t DeclId_t
Definition: TInterpreter.h:290
Option_t * GetOption() const
Definition: TCollection.h:253
A collection of TDataMember objects designed for fast access given a DeclId_t and for keep track of T...
virtual void Delete(Option_t *option="")
Delete all TDataMember object files.
void Unload()
Mark 'all func' as being unloaded.
TDictionary * Get(DeclId_t id)
Return (after creating it if necessary) the TDataMember describing the data member corresponding to t...
void Load()
Load all the DataMembers known to the interpreter for the scope 'fClass' into this collection.
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...
virtual TObject * FindObject(const char *name) const
Specialize FindObject to do search for the a function just by name or create it if its not already in...
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
TFunction * Get(DeclId_t id)
Return (after creating it if necessary) the TMethod or TFunction describing the function correspondin...
void Load()
Load all the functions known to the interpreter for the scope 'fClass' into this collection.
void Unload()
Mark 'all func' as being unloaded.
virtual void Delete(Option_t *option="")
Delete all TFunction object files.
A collection of TDataType designed to hold the typedef information and numerical type information.
Definition: TListOfTypes.h:31
A doubly linked list.
Definition: TList.h:44
virtual void Add(TObject *obj)
Definition: TList.h:87
virtual TObjLink * FirstLink() const
Definition: TList.h:108
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:470
virtual void AddLast(TObject *obj)
Add object at the end of the list.
Definition: TList.cxx:152
virtual void Clear(Option_t *option="")
Remove all objects from the list.
Definition: TList.cxx:402
Handle messages that might be generated by the system.
virtual void HandleMessage(Long_t id, const TObject *obj)
Store message origin, keep statistics and call Notify().
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition: TNamed.cxx:140
An array of TObjects.
Definition: TObjArray.h:37
TObject * At(Int_t idx) const
Definition: TObjArray.h:166
Mother of all ROOT objects.
Definition: TObject.h:37
static void SetObjectStat(Bool_t stat)
Turn on/off tracking of objects in the TObjectTable.
Definition: TObject.cxx:974
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:359
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:187
@ kNotDeleted
object has not been deleted
Definition: TObject.h:78
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition: TObject.cxx:130
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:879
virtual TObject * FindObject(const char *name) const
Must be redefined in derived classes.
Definition: TObject.cxx:323
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:696
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:893
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition: TObject.cxx:921
@ kInvalidObject
if object ctor succeeded but object should not be used
Definition: TObject.h:68
@ kMustCleanup
if object destructor must call RecursiveRemove()
Definition: TObject.h:60
This class implements a plugin library manager.
void LoadHandlersFromEnv(TEnv *env)
Load plugin handlers specified in config file, like:
static void Cleanup()
static function (called by TROOT destructor) to delete all TProcessIDs
Definition: TProcessID.cxx:204
static TProcessID * AddProcessID()
Static function to add a new TProcessID to the list of PIDs.
Definition: TProcessID.cxx:116
This class is a specialized TProcessID managing the list of UUIDs.
Definition: TProcessUUID.h:32
static Bool_t BlockAllSignals(Bool_t b)
Block or unblock all signals. Returns the previous block status.
Definition: TQObject.cxx:1057
ROOT top level object description.
Definition: TROOT.h:94
static Int_t IncreaseDirLevel()
Increase the indentation level for ls().
Definition: TROOT.cxx:2795
Int_t IgnoreInclude(const char *fname, const char *expandedfname)
Return 1 if the name of the given include file corresponds to a class that is known to ROOT,...
Definition: TROOT.cxx:1875
Int_t fVersionCode
Definition: TROOT.h:115
void Message(Int_t id, const TObject *obj)
Process message id called by obj.
Definition: TROOT.cxx:2297
void RemoveClass(TClass *)
Remove a class from the list and map of classes.
Definition: TROOT.cxx:2581
TSeqCollection * fProofs
Definition: TROOT.h:162
TCollection * fClassGenerators
Definition: TROOT.h:160
TROOT()
Default ctor.
Definition: TROOT.cxx:600
void SetCutClassName(const char *name="TCutG")
Set the default graphical cut class name for the graphics editor By default the graphics editor creat...
Definition: TROOT.cxx:2636
TSeqCollection * fCanvases
Definition: TROOT.h:149
const TObject * fPrimitive
Definition: TROOT.h:138
Bool_t fIsWebDisplay
Definition: TROOT.h:128
TFolder * fRootFolder
Definition: TROOT.h:167
void AddClassGenerator(TClassGenerator *gen)
Add a class generator.
Definition: TROOT.cxx:1017
TSeqCollection * fGeometries
Definition: TROOT.h:154
TString fCutClassName
Definition: TROOT.h:170
TInterpreter * fInterpreter
Definition: TROOT.h:125
std::vector< std::pair< std::string, int > > FwdDeclArgsToKeepCollection_t
Definition: TROOT.h:187
Int_t fVersionTime
Definition: TROOT.h:117
void EndOfProcessCleanups()
Execute the cleanups necessary at the end of the process, in particular those that must be executed b...
Definition: TROOT.cxx:1209
Bool_t fBatch
Definition: TROOT.h:126
TSeqCollection * GetListOfFiles() const
Definition: TROOT.h:237
Bool_t fEscape
Definition: TROOT.h:135
static const TString & GetBinDir()
Get the binary directory in the installation. Static utility function.
Definition: TROOT.cxx:2901
Int_t fVersionInt
Definition: TROOT.h:114
static const TString & GetIncludeDir()
Get the include directory in the installation. Static utility function.
Definition: TROOT.cxx:2943
Longptr_t ProcessLine(const char *line, Int_t *error=0)
Process interpreter command via TApplication::ProcessLine().
Definition: TROOT.cxx:2317
Longptr_t ProcessLineFast(const char *line, Int_t *error=0)
Process interpreter command directly via CINT interpreter.
Definition: TROOT.cxx:2354
Bool_t fFromPopUp
Definition: TROOT.h:131
TSeqCollection * fSockets
Definition: TROOT.h:148
static const char * GetMacroPath()
Get macro search path. Static utility function.
Definition: TROOT.cxx:2715
TCollection * fFunctions
Definition: TROOT.h:151
void SaveContext()
Save the current interpreter context.
Definition: TROOT.cxx:2624
Bool_t IsExecutingMacro() const
Definition: TROOT.h:280
TDataType * GetType(const char *name, Bool_t load=kFALSE) const
Return pointer to type with name.
Definition: TROOT.cxx:1520
static void Initialize()
Initialize ROOT explicitly.
Definition: TROOT.cxx:2811
TFunction * GetGlobalFunctionWithPrototype(const char *name, const char *proto=0, Bool_t load=kFALSE)
Return pointer to global function by name.
Definition: TROOT.cxx:1665
static void ShutDown()
Shut down ROOT.
Definition: TROOT.cxx:3037
TObject * GetFunction(const char *name) const
Return pointer to function with name.
Definition: TROOT.cxx:1545
static Int_t ConvertVersionCode2Int(Int_t code)
Convert version code to an integer, i.e. 331527 -> 51507.
Definition: TROOT.cxx:2834
TSeqCollection * fMessageHandlers
Definition: TROOT.h:158
void SetStyle(const char *stylename="Default")
Change current style to style with name stylename.
Definition: TROOT.cxx:2683
AListOfEnums_t fEnums
Definition: TROOT.h:165
void ReadGitInfo()
Read Git commit information and branch name from the etc/gitinfo.txt file.
Definition: TROOT.cxx:2376
static Bool_t fgRootInit
Definition: TROOT.h:103
void RefreshBrowsers()
Refresh all browsers.
Definition: TROOT.cxx:2465
void CloseFiles()
Close any files and sockets that gROOT knows about.
Definition: TROOT.cxx:1131
std::atomic< TApplication * > fApplication
Definition: TROOT.h:124
const char * FindObjectPathName(const TObject *obj) const
Return path name of obj somewhere in the //root/... path.
Definition: TROOT.cxx:1431
static Int_t ConvertVersionInt2Code(Int_t v)
Convert version as an integer to version code as used in RVersion.h.
Definition: TROOT.cxx:2842
TFile * GetFile() const
Definition: TROOT.h:260
static const TString & GetTTFFontDir()
Get the fonts directory in the installation. Static utility function.
Definition: TROOT.cxx:3090
Bool_t fForceStyle
Definition: TROOT.h:133
TCanvas * MakeDefCanvas() const
Return a default canvas.
Definition: TROOT.cxx:1512
TCollection * fTypes
Definition: TROOT.h:141
TColor * GetColor(Int_t color) const
Return address of color with index color.
Definition: TROOT.cxx:1494
TGlobal * GetGlobal(const char *name, Bool_t load=kFALSE) const
Return pointer to global variable by name.
Definition: TROOT.cxx:1578
TClass * FindSTLClass(const char *name, Bool_t load, Bool_t silent=kFALSE) const
return a TClass object corresponding to 'name' assuming it is an STL container.
Definition: TROOT.cxx:1442
TSeqCollection * fStreamerInfo
Definition: TROOT.h:159
static const TString & GetIconPath()
Get the icon path in the installation. Static utility function.
Definition: TROOT.cxx:3069
TCollection * GetListOfGlobalFunctions(Bool_t load=kFALSE)
Return list containing the TFunctions currently defined.
Definition: TROOT.cxx:1773
TString fGitDate
Definition: TROOT.h:122
TSeqCollection * fSpecials
Definition: TROOT.h:156
TCollection * GetListOfFunctionTemplates()
Definition: TROOT.cxx:1718
static void RegisterModule(const char *modulename, const char **headers, const char **includePaths, const char *payLoadCode, const char *fwdDeclCode, void(*triggerFunc)(), const FwdDeclArgsToKeepCollection_t &fwdDeclsArgToSkip, const char **classesHeaders, bool hasCxxModule=false)
Called by static dictionary initialization to register clang modules for headers.
Definition: TROOT.cxx:2488
TCollection * fClasses
Definition: TROOT.h:140
Bool_t fEditHistograms
Definition: TROOT.h:130
TListOfDataMembers * fGlobals
Definition: TROOT.h:143
TListOfFunctionTemplates * fFuncTemplate
Definition: TROOT.h:142
Int_t fTimer
Definition: TROOT.h:123
TSeqCollection * fDataSets
Definition: TROOT.h:164
TString fConfigOptions
Definition: TROOT.h:111
TStyle * GetStyle(const char *name) const
Return pointer to style with name.
Definition: TROOT.cxx:1537
TCollection * GetListOfEnums(Bool_t load=kFALSE)
Definition: TROOT.cxx:1701
void InitInterpreter()
Initialize the interpreter.
Definition: TROOT.cxx:2011
TCollection * GetListOfGlobals(Bool_t load=kFALSE)
Return list containing the TGlobals currently defined.
Definition: TROOT.cxx:1735
virtual TObject * FindObjectAnyFile(const char *name) const
Scan the memory lists of all files for an object with name.
Definition: TROOT.cxx:1394
static void SetDirLevel(Int_t level=0)
Return Indentation level for ls().
Definition: TROOT.cxx:2826
TSeqCollection * fSecContexts
Definition: TROOT.h:161
TString fWebDisplay
Definition: TROOT.h:127
static const char * GetTutorialsDir()
Get the tutorials directory in the installation.
Definition: TROOT.cxx:3112
TCollection * GetListOfFunctionOverloads(const char *name) const
Return the collection of functions named "name".
Definition: TROOT.cxx:1619
TSeqCollection * fCleanups
Definition: TROOT.h:157
static Bool_t Initialized()
Return kTRUE if the TROOT object has been initialized.
Definition: TROOT.cxx:2818
void RecursiveRemove(TObject *obj)
Recursively remove this object from the list of Cleanups.
Definition: TROOT.cxx:2451
Int_t fLineIsProcessing
Definition: TROOT.h:100
static const TString & GetSourceDir()
Get the source directory in the installation. Static utility function.
Definition: TROOT.cxx:3048
static const TString & GetMacroDir()
Get the macro directory in the installation. Static utility function.
Definition: TROOT.cxx:2995
TString fGitCommit
Definition: TROOT.h:120
TSeqCollection * fClosedObjects
Definition: TROOT.h:145
TSeqCollection * fTasks
Definition: TROOT.h:152
void Browse(TBrowser *b)
Add browsable objects to TBrowser.
Definition: TROOT.cxx:1038
TFunction * GetGlobalFunction(const char *name, const char *params=0, Bool_t load=kFALSE)
Return pointer to global function by name.
Definition: TROOT.cxx:1632
TSeqCollection * fClipboard
Definition: TROOT.h:163
const char * GetGitDate()
Return date/time make was run.
Definition: TROOT.cxx:2427
void SetEditorMode(const char *mode="")
Set editor mode.
Definition: TROOT.cxx:2657
static const TString & GetTutorialDir()
Get the tutorials directory in the installation. Static utility function.
Definition: TROOT.cxx:3016
virtual ~TROOT()
Clean up and free resources used by ROOT (files, network sockets, shared memory segments,...
Definition: TROOT.cxx:856
TSeqCollection * fColors
Definition: TROOT.h:153
void Idle(UInt_t idleTimeInSec, const char *command=0)
Execute command when system has been idle for idleTimeInSec seconds.
Definition: TROOT.cxx:1839
TSeqCollection * GetListOfBrowsers() const
Definition: TROOT.h:245
Bool_t ReadingObject() const
Deprecated (will be removed in next release).
Definition: TROOT.cxx:2413
TSeqCollection * fStyles
Definition: TROOT.h:150
Int_t fVersionDate
Definition: TROOT.h:116
TSeqCollection * GetListOfColors() const
Definition: TROOT.h:232
virtual void Append(TObject *obj, Bool_t replace=kFALSE)
Append object to this directory.
Definition: TROOT.cxx:1029
Int_t fBuiltTime
Definition: TROOT.h:119
static const std::vector< std::string > & AddExtraInterpreterArgs(const std::vector< std::string > &args)
Provide command line arguments to the interpreter construction.
Definition: TROOT.cxx:2864
TClass * GetClass(const char *name, Bool_t load=kTRUE, Bool_t silent=kFALSE) const
Return pointer to class with name. Obsolete, use TClass::GetClass directly.
Definition: TROOT.cxx:1476
TVirtualPad * fSelectPad
Definition: TROOT.h:139
TSeqCollection * fFiles
Definition: TROOT.h:146
virtual TObject * FindObjectAny(const char *name) const
Return a pointer to the first object with name starting at //root.
Definition: TROOT.cxx:1384
static const TString & GetRootSys()
Get the rootsys directory in the installation. Static utility function.
Definition: TROOT.cxx:2891
TListOfFunctions * GetGlobalFunctions()
Internal routine returning, and creating if necessary, the list of global function.
Definition: TROOT.cxx:1610
Bool_t fInterrupt
Definition: TROOT.h:134
Bool_t fMustClean
Definition: TROOT.h:132
TObject * Remove(TObject *)
Remove an object from the in-memory list.
Definition: TROOT.cxx:2571
Int_t LoadClass(const char *classname, const char *libname, Bool_t check=kFALSE)
Check if class "classname" is known to the interpreter (in fact, this check is not needed anymore,...
Definition: TROOT.cxx:2130
void AddClass(TClass *cl)
Add a class to the list and map of classes.
Definition: TROOT.cxx:1007
static Int_t RootVersionCode()
Return ROOT version code as defined in RVersion.h.
Definition: TROOT.cxx:2853
TObject * FindSpecialObject(const char *name, void *&where)
Returns address and folder of a ROOT object if it exists.
Definition: TROOT.cxx:1325
void InitSystem()
Initialize operating system interface.
Definition: TROOT.cxx:1925
Bool_t ClassSaved(TClass *cl)
return class status bit kClassSaved for class cl This function is called by the SavePrimitive functio...
Definition: TROOT.cxx:1057
TString fGitBranch
Definition: TROOT.h:121
TCollection * GetListOfTypes(Bool_t load=kFALSE)
Return a dynamic list giving access to all TDataTypes (typedefs) currently defined.
Definition: TROOT.cxx:1812
virtual TObject * FindObject(const char *name) const
Returns address of a ROOT object if it exists.
Definition: TROOT.cxx:1271
static Int_t fgDirLevel
Definition: TROOT.h:102
Bool_t IsRootFile(const char *filename) const
Return true if the file is local and is (likely) to be a ROOT file.
Definition: TROOT.cxx:2177
static void IndentLevel()
Functions used by ls() to indent an object hierarchy.
Definition: TROOT.cxx:2803
static const TString & GetDocDir()
Get the documentation directory in the installation. Static utility function.
Definition: TROOT.cxx:2979
static const TString & GetEtcDir()
Get the sysconfig directory in the installation. Static utility function.
Definition: TROOT.cxx:2953
Int_t GetNclasses() const
Get number of classes.
Definition: TROOT.cxx:1823
static const char **& GetExtraInterpreterArgs()
INTERNAL function! Used by rootcling to inject interpreter arguments through a C-interface layer.
Definition: TROOT.cxx:2874
static void SetMacroPath(const char *newpath)
Set or extend the macro search path.
Definition: TROOT.cxx:2741
void InitThreads()
Load and initialize thread library.
Definition: TROOT.cxx:2000
TProcessUUID * fUUIDs
Definition: TROOT.h:166
TString fConfigFeatures
Definition: TROOT.h:112
TFunctionTemplate * GetFunctionTemplate(const char *name)
Definition: TROOT.cxx:1565
TPluginManager * fPluginManager
Definition: TROOT.h:169
TObject * GetGeometry(const char *name) const
Return pointer to Geometry with name.
Definition: TROOT.cxx:1694
Bool_t fExecutingMacro
Definition: TROOT.h:136
Int_t fBuiltDate
Definition: TROOT.h:118
Bool_t fIsWebDisplayBatch
Definition: TROOT.h:129
Longptr_t ProcessLineSync(const char *line, Int_t *error=0)
Process interpreter command via TApplication::ProcessLine().
Definition: TROOT.cxx:2337
TSeqCollection * fMappedFiles
Definition: TROOT.h:147
Int_t GetNtypes() const
Get number of types.
Definition: TROOT.cxx:1831
static const TString & GetLibDir()
Get the library directory in the installation. Static utility function.
Definition: TROOT.cxx:2922
void ls(Option_t *option="") const
To list all objects of the application.
Definition: TROOT.cxx:2197
TSeqCollection * fBrowsers
Definition: TROOT.h:155
TString fDefCanvasName
Definition: TROOT.h:171
TListOfFunctions * fGlobalFunctions
Definition: TROOT.h:144
TList * fBrowsables
Definition: TROOT.h:168
static Int_t DecreaseDirLevel()
Decrease the indentation level for ls().
Definition: TROOT.cxx:2699
void Reset(Option_t *option="")
Delete all global interpreter objects created since the last call to Reset.
Definition: TROOT.cxx:2604
Int_t fEditorMode
Definition: TROOT.h:137
const char * FindObjectClassName(const char *name) const
Returns class name of a ROOT object including CINT globals.
Definition: TROOT.cxx:1411
static const TString & GetDataDir()
Get the data directory in the installation. Static utility function.
Definition: TROOT.cxx:2963
void SetWebDisplay(const char *webdisplay)
Specify where web graphics shall be rendered.
Definition: TROOT.cxx:2767
Int_t LoadMacro(const char *filename, Int_t *error=0, Bool_t check=kFALSE)
Load a macro in the interpreter's memory.
Definition: TROOT.cxx:2215
Longptr_t Macro(const char *filename, Int_t *error=0, Bool_t padUpdate=kTRUE)
Execute a macro in the interpreter.
Definition: TROOT.cxx:2263
TSeqCollection * GetListOfGeometries() const
Definition: TROOT.h:244
TSeqCollection * GetListOfStyles() const
Definition: TROOT.h:241
TString fVersion
Definition: TROOT.h:113
static Int_t GetDirLevel()
return directory level
Definition: TROOT.cxx:2707
void SetReadingObject(Bool_t flag=kTRUE)
Definition: TROOT.cxx:2418
Sequenceable collection abstract base class.
virtual void AddLast(TObject *obj)=0
virtual TObject * Last() const =0
virtual TObject * First() const =0
virtual void Add(TObject *obj)
static void PrintStatistics()
Print memory usage statistics.
Definition: TStorage.cxx:406
Basic string class.
Definition: TString.h:136
Ssiz_t Length() const
Definition: TString.h:410
Bool_t EndsWith(const char *pat, ECaseCompare cmp=kExact) const
Return true if string ends with the specified string.
Definition: TString.cxx:2202
TSubString Strip(EStripType s=kTrailing, char c=' ') const
Return a substring of self stripped at beginning and/or end.
Definition: TString.cxx:1131
const char * Data() const
Definition: TString.h:369
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition: TString.h:692
@ kBoth
Definition: TString.h:267
@ kIgnoreCase
Definition: TString.h:268
Ssiz_t Last(char c) const
Find last occurrence of a character c.
Definition: TString.cxx:916
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
Definition: TString.h:615
Bool_t IsNull() const
Definition: TString.h:407
TString & Remove(Ssiz_t pos)
Definition: TString.h:673
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2314
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
TStyle objects may be created to define special styles.
Definition: TStyle.h:29
static void BuildStyles()
Create some standard styles.
Definition: TStyle.cxx:509
Describes an Operating System directory for the browser.
Abstract base class defining a generic interface to the underlying Operating System.
Definition: TSystem.h:266
virtual Func_t DynFindSymbol(const char *module, const char *entry)
Find specific entry point in specified library.
Definition: TSystem.cxx:2042
virtual const char * Getenv(const char *env)
Get environment variable.
Definition: TSystem.cxx:1663
virtual TString SplitAclicMode(const char *filename, TString &mode, TString &args, TString &io) const
This method split a filename of the form:
Definition: TSystem.cxx:4241
virtual char * ConcatFileName(const char *dir, const char *name)
Concatenate a directory and a file name. User must delete returned string.
Definition: TSystem.cxx:1071
virtual void CleanCompiledMacros()
Remove the shared libs produced by the CompileMacro() function.
Definition: TSystem.cxx:4351
virtual int Load(const char *module, const char *entry="", Bool_t system=kFALSE)
Load a shared library.
Definition: TSystem.cxx:1855
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.
Definition: TSystem.cxx:1398
virtual const char * PrependPathName(const char *dir, TString &name)
Concatenate a directory and a file name.
Definition: TSystem.cxx:1081
virtual Bool_t AccessPathName(const char *path, EAccessMode mode=kFileExists)
Returns FALSE if one can access a file using the specified access mode.
Definition: TSystem.cxx:1296
virtual Bool_t Init()
Initialize the OS interface.
Definition: TSystem.cxx:182
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
Definition: TSystem.cxx:935
virtual const char * WorkingDirectory()
Return working directory.
Definition: TSystem.cxx:872
virtual char * Which(const char *search, const char *file, EAccessMode mode=kFileExists)
Find location of file in a search path.
Definition: TSystem.cxx:1546
virtual const char * HomeDirectory(const char *userName=nullptr)
Return the user's home directory.
Definition: TSystem.cxx:888
virtual const char * GetError()
Return system error string.
Definition: TSystem.cxx:253
virtual void ResetSignals()
Reset signals handlers to previous behaviour.
Definition: TSystem.cxx:587
char * DynamicPathName(const char *lib, Bool_t quiet=kFALSE)
Find a dynamic library called lib using the system search paths.
Definition: TSystem.cxx:2018
This class represents a WWW compatible URL.
Definition: TUrl.h:33
This class implements a mutex interface.
Definition: TVirtualMutex.h:32
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition: TVirtualPad.h:51
static TVirtualPad *& Pad()
Return the current pad for the current thread.
Definition: TVirtualPad.cxx:27
Semi-Abstract base class defining a generic interface to the underlying, low level,...
Definition: TVirtualX.h:46
static TVirtualX *& Instance()
Returns gVirtualX global.
Definition: TVirtualX.cxx:57
TLine * line
TF1 * f1
Definition: legend1.C:11
const std::string & GetIncludeDir()
\ returns the include directory in the installation.
const std::string & GetRootSys()
const std::string & GetEtcDir()
static Func_t GetSymInLibImt(const char *funcname)
Definition: TROOT.cxx:393
static GetROOTFun_t gGetROOT
Definition: TROOT.cxx:391
R__EXTERN TROOT * gROOTLocal
Definition: TROOT.h:377
void DisableParBranchProcessing()
Globally disables the IMT use case of parallel branch processing, deactivating the corresponding lock...
Definition: TROOT.cxx:426
std::function< const char *()> ErrorSystemMsgHandlerFunc_t
Retrieves the error string associated with the last system error.
Definition: TError.h:59
static Bool_t & IsImplicitMTEnabledImpl()
Keeps track of the status of ImplicitMT w/o resorting to the load of libImt.
Definition: TROOT.cxx:455
void MinimalErrorHandler(int level, Bool_t abort, const char *location, const char *msg)
A very simple error handler that is usually replaced by the TROOT default error handler.
Definition: TError.cxx:69
TROOT *(* GetROOTFun_t)()
Definition: TROOT.cxx:389
ErrorSystemMsgHandlerFunc_t SetErrorSystemMsgHandler(ErrorSystemMsgHandlerFunc_t h)
Returns the previous system error message handler.
Definition: TError.cxx:59
void EnableParBranchProcessing()
Globally enables the parallel branch processing, which is a case of implicit multi-threading (IMT) in...
Definition: TROOT.cxx:412
Bool_t IsParBranchProcessingEnabled()
Returns true if parallel branch processing is enabled.
Definition: TROOT.cxx:439
TROOT * GetROOT2()
Definition: TROOT.cxx:379
TROOT * GetROOT1()
Definition: TROOT.cxx:372
void ReleaseDefaultErrorHandler()
Destructs resources that are taken by using the default error handler.
void function(const Char_t *name_, T fun, const Char_t *docstring=0)
Definition: RExports.h:152
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
TString & GetMacroPath()
Definition: TROOT.cxx:468
void EnableImplicitMT(UInt_t numthreads=0)
Enable ROOT's implicit multi-threading for all objects and methods that provide an internal paralleli...
Definition: TROOT.cxx:527
Bool_t IsImplicitMTEnabled()
Returns true if the implicit multi-threading in ROOT is enabled.
Definition: TROOT.cxx:558
UInt_t GetThreadPoolSize()
Returns the size of ROOT's thread pool.
Definition: TROOT.cxx:565
R__EXTERN TVirtualRWMutex * gCoreMutex
void EnableThreadSafety()
Enables the global mutex to make ROOT thread safe/aware.
Definition: TROOT.cxx:493
UInt_t GetImplicitMTPoolSize()
Returns the size of the pool used for implicit multi-threading.
Definition: TROOT.cxx:580
TROOT * GetROOT()
Definition: TROOT.cxx:464
void DisableImplicitMT()
Disables the implicit multi-threading in ROOT (see EnableImplicitMT).
Definition: TROOT.cxx:544
void GetNormalizedName(std::string &norm_name, std::string_view name)
Return the normalized name.
Definition: TClassEdit.cxx:837
static constexpr double s
static constexpr double mm
Int_t fMode
Definition: TSystem.h:127
TCanvas * style()
Definition: style.C:1
auto * m
Definition: textangle.C:8
auto * l
Definition: textangle.C:4
auto * a
Definition: textangle.C:12
#define sym(otri1, otri2)
Definition: triangle.c:933