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