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
630
631////////////////////////////////////////////////////////////////////////////////
632/// Default ctor.
633
635
636////////////////////////////////////////////////////////////////////////////////
637/// Initialize the ROOT system. The creation of the TROOT object initializes
638/// the ROOT system. It must be the first ROOT related action that is
639/// performed by a program. The TROOT object must be created on the stack
640/// (can not be called via new since "operator new" is protected). The
641/// TROOT object is either created as a global object (outside the main()
642/// program), or it is one of the first objects created in main().
643/// Make sure that the TROOT object stays in scope for as long as ROOT
644/// related actions are performed. TROOT is a so called singleton so
645/// only one instance of it can be created. The single TROOT object can
646/// always be accessed via the global pointer gROOT.
647/// The name and title arguments can be used to identify the running
648/// application. The initfunc argument can contain an array of
649/// function pointers (last element must be 0). These functions are
650/// executed at the end of the constructor. This way one can easily
651/// extend the ROOT system without adding permanent dependencies
652/// (e.g. the graphics system is initialized via such a function).
653
654TROOT::TROOT(const char *name, const char *title, VoidFuncPtr_t *initfunc) : TDirectory()
655{
657 //Warning("TROOT", "only one instance of TROOT allowed");
658 return;
659 }
660
662
664 gDirectory = nullptr;
665
666 SetName(name);
667 SetTitle(title);
668
669 // will be used by global "operator delete" so make sure it is set
670 // before anything is deleted
671 fMappedFiles = nullptr;
672
673 // create already here, but only initialize it after gEnv has been created
675
676 // Initialize Operating System interface
677 InitSystem();
678
679 // Initialize static directory functions
680 GetRootSys();
681 GetBinDir();
682 GetLibDir();
684 GetEtcDir();
685 GetDataDir();
686 GetDocDir();
687 GetMacroDir();
689 GetSourceDir();
690 GetIconPath();
692
693 gRootDir = GetRootSys().Data();
694
695 TDirectory::BuildDirectory(nullptr, nullptr);
696
697 // Initialize interface to CINT C++ interpreter
698 fVersionInt = 0; // check in TROOT dtor in case TCling fails
699 fClasses = nullptr; // might be checked via TCling ctor
700 fEnums = nullptr;
701
711
712 ReadGitInfo();
713
714 fClasses = new THashTable(800,3); fClasses->UseRWLock();
715 //fIdMap = new IdMap_t;
718
719 // usedToIdentifyRootClingByDlSym is available when TROOT is part of
720 // rootcling.
721 if (!dlsym(RTLD_DEFAULT, "usedToIdentifyRootClingByDlSym")) {
722 // initialize plugin manager early
724 }
725
727
728 auto setNameLocked = [](TSeqCollection *l, const char *collection_name) {
729 l->SetName(collection_name);
730 l->UseRWLock();
731 return l;
732 };
733
734 fTimer = 0;
735 fApplication = nullptr;
736 fColors = setNameLocked(new TObjArray(1000), "ListOfColors");
737 fColors->SetOwner();
738 fTypes = nullptr;
739 fGlobals = nullptr;
740 fGlobalFunctions = nullptr;
741 // fList was created in TDirectory::Build but with different sizing.
742 delete fList;
743 fList = new THashList(1000,3); fList->UseRWLock();
744 fClosedObjects = setNameLocked(new TList, "ClosedFiles");
745 fFiles = setNameLocked(new TList, "Files");
746 fMappedFiles = setNameLocked(new TList, "MappedFiles");
747 fSockets = setNameLocked(new TList, "Sockets");
748 fCanvases = setNameLocked(new TList, "Canvases");
749 fStyles = setNameLocked(new TList, "Styles");
750 fFunctions = setNameLocked(new TList, "Functions");
751 fTasks = setNameLocked(new TList, "Tasks");
752 fGeometries = setNameLocked(new TList, "Geometries");
753 fBrowsers = setNameLocked(new TList, "Browsers");
754 fSpecials = setNameLocked(new TList, "Specials");
755 fBrowsables = (TList*)setNameLocked(new TList, "Browsables");
756 fCleanups = setNameLocked(new THashList, "Cleanups");
757 fMessageHandlers = setNameLocked(new TList, "MessageHandlers");
758 fSecContexts = setNameLocked(new TList, "SecContexts");
759 fClipboard = setNameLocked(new TList, "Clipboard");
760 fDataSets = setNameLocked(new TList, "DataSets");
762
764 fUUIDs = new TProcessUUID();
765
766 fRootFolder = new TFolder();
767 fRootFolder->SetName("root");
768 fRootFolder->SetTitle("root of all folders");
769 fRootFolder->AddFolder("Classes", "List of Active Classes",fClasses);
770 fRootFolder->AddFolder("Colors", "List of Active Colors",fColors);
771 fRootFolder->AddFolder("MapFiles", "List of MapFiles",fMappedFiles);
772 fRootFolder->AddFolder("Sockets", "List of Socket Connections",fSockets);
773 fRootFolder->AddFolder("Canvases", "List of Canvases",fCanvases);
774 fRootFolder->AddFolder("Styles", "List of Styles",fStyles);
775 fRootFolder->AddFolder("Functions", "List of Functions",fFunctions);
776 fRootFolder->AddFolder("Tasks", "List of Tasks",fTasks);
777 fRootFolder->AddFolder("Geometries","List of Geometries",fGeometries);
778 fRootFolder->AddFolder("Browsers", "List of Browsers",fBrowsers);
779 fRootFolder->AddFolder("Specials", "List of Special Objects",fSpecials);
780 fRootFolder->AddFolder("Handlers", "List of Message Handlers",fMessageHandlers);
781 fRootFolder->AddFolder("Cleanups", "List of RecursiveRemove Collections",fCleanups);
782 fRootFolder->AddFolder("StreamerInfo","List of Active StreamerInfo Classes",fStreamerInfo);
783 fRootFolder->AddFolder("SecContexts","List of Security Contexts",fSecContexts);
784 fRootFolder->AddFolder("ROOT Memory","List of Objects in the gROOT Directory",fList);
785 fRootFolder->AddFolder("ROOT Files","List of Connected ROOT Files",fFiles);
786
787 // by default, add the list of files, tasks, canvases and browsers in the Cleanups list
793 // And add TROOT's TDirectory personality
795
800 fEscape = kFALSE;
802 fPrimitive = nullptr;
803 fSelectPad = nullptr;
804 fEditorMode = 0;
805 fDefCanvasName = "c1";
807 fLineIsProcessing = 1; // This prevents WIN32 "Windows" thread to pick ROOT objects with mouse
808 gDirectory = this;
809 gPad = nullptr;
810
811 //set name of graphical cut class for the graphics editor
812 //cannot call SetCutClassName at this point because the TClass of TCutG
813 //is not yet build
814 fCutClassName = "TCutG";
815
816 // Create a default MessageHandler
817 new TMessageHandler((TClass*)nullptr);
818
819 // Create some styles
820 gStyle = nullptr;
822 SetStyle(gEnv->GetValue("Canvas.Style", "Modern"));
823
824 // Setup default (batch) graphics and GUI environment
827 gGXBatch = new TVirtualX("Batch", "ROOT Interface to batch graphics");
829
830#if defined(R__WIN32)
831 fBatch = kFALSE;
832#elif defined(R__HAS_COCOA)
833 fBatch = kFALSE;
834#else
835 if (gSystem->Getenv("DISPLAY"))
836 fBatch = kFALSE;
837 else
838 fBatch = kTRUE;
839#endif
840
841 const char *webdisplay = gSystem->Getenv("ROOT_WEBDISPLAY");
842 if (!webdisplay || !*webdisplay)
843 webdisplay = gEnv->GetValue("WebGui.Display", "");
844 if (webdisplay && *webdisplay)
845 SetWebDisplay(webdisplay);
846
847 int i = 0;
848 while (initfunc && initfunc[i]) {
849 (initfunc[i])();
850 fBatch = kFALSE; // put system in graphics mode (backward compatible)
851 i++;
852 }
853
854 // Set initial/default list of browsable objects
855 fBrowsables->Add(fRootFolder, "root");
857 fBrowsables->Add(fFiles, "ROOT Files");
858
860
862}
863
864////////////////////////////////////////////////////////////////////////////////
865/// Clean up and free resources used by ROOT (files, network sockets,
866/// shared memory segments, etc.).
867
869{
870 using namespace ROOT::Internal;
871
872 if (gROOTLocal == this) {
873
874 // TMapFile must be closed before they are deleted, so run CloseFiles
875 // (possibly a second time if the application has an explicit TApplication
876 // object, but in that this is a no-op). TMapFile needs the slow close
877 // so that the custome operator delete can properly find out whether the
878 // memory being 'freed' is part of a memory mapped file or not.
879 CloseFiles();
880
881 // If the interpreter has not yet been initialized, don't bother
882 gGetROOT = &GetROOT1;
883
884 // Mark the object as invalid, so that we can veto some actions
885 // (like autoloading) while we are in the destructor.
887
888 // Turn-off the global mutex to avoid recreating mutexes that have
889 // already been deleted during the destruction phase
890 if (gGlobalMutex) {
892 gGlobalMutex = nullptr;
893 delete m;
894 }
895
896 // Return when error occurred in TCling, i.e. when setup file(s) are
897 // out of date
898 if (!fVersionInt) return;
899
900 // ATTENTION!!! Order is important!
901
903
904 // FIXME: Causes rootcling to deadlock, debug and uncomment
905 // SafeDelete(fRootFolder);
906
907#ifdef R__COMPLETE_MEM_TERMINATION
908 fSpecials->Delete(); SafeDelete(fSpecials); // delete special objects : PostScript, Minuit, Html
909#endif
910
911 fClosedObjects->Delete("slow"); // and closed files
912 fFiles->Delete("slow"); // and files
914 fSecContexts->Delete("slow"); SafeDelete(fSecContexts); // and security contexts
915 fSockets->Delete(); SafeDelete(fSockets); // and sockets
916 fMappedFiles->Delete("slow"); // and mapped files
917 TSeqCollection *tl = fMappedFiles; fMappedFiles = nullptr; delete tl;
918
920
921 delete fUUIDs;
922 TProcessID::Cleanup(); // and list of ProcessIDs
923
930
931#ifdef R__COMPLETE_MEM_TERMINATION
936#endif
937
938 // Stop emitting signals
940
942
943#ifdef R__COMPLETE_MEM_TERMINATION
948
949 fCleanups->Clear();
951 delete gClassTable; gClassTable = 0;
952 delete gEnv; gEnv = 0;
953
954 if (fTypes) fTypes->Delete();
956 if (fGlobals) fGlobals->Delete();
960 fEnums.load()->Delete();
961
962 fClasses->Delete(); SafeDelete(fClasses); // TClass'es must be deleted last
963#endif
964
965 // Remove shared libraries produced by the TSystem::CompileMacro() call
967
968 // Cleanup system class
972 delete gSystem;
973
974 // ROOT-6022:
975 // if (gInterpreterLib) dlclose(gInterpreterLib);
976#ifdef R__COMPLETE_MEM_TERMINATION
977 // On some 'newer' platform (Fedora Core 17+, Ubuntu 12), the
978 // initialization order is (by default?) is 'wrong' and so we can't
979 // delete the interpreter now .. because any of the static in the
980 // interpreter's library have already been deleted.
981 // On the link line, we must list the most dependent .o file
982 // and end with the least dependent (LLVM libraries), unfortunately,
983 // Fedora Core 17+ or Ubuntu 12 will also execute the initialization
984 // in the same order (hence doing libCore's before LLVM's and
985 // vice et versa for both the destructor. We worked around the
986 // initialization order by delay the TROOT creation until first use.
987 // We can not do the same for destruction as we have no way of knowing
988 // the last access ...
989 // So for now, let's avoid delete TCling except in the special build
990 // checking the completeness of the termination deletion.
991
992 // TODO: Should we do more cleanup here than just call delete?
993 // Segfaults rootcling in some cases, debug and uncomment:
994 //
995 // delete fInterpreter;
996
997 // We cannot delete fCleanups because of the logic in atexit which needs it.
999#endif
1000
1001#ifdef _MSC_VER
1002 // usedToIdentifyRootClingByDlSym is available when TROOT is part of rootcling.
1003 if (dlsym(RTLD_DEFAULT, "usedToIdentifyRootClingByDlSym")) {
1004 // deleting the interpreter makes things crash at exit in some cases
1005 delete fInterpreter;
1006 }
1007#else
1008 // deleting the interpreter makes things crash at exit in some cases
1009 delete fInterpreter;
1010#endif
1011
1012 // Prints memory stats
1014
1015 gROOTLocal = nullptr;
1017 }
1018}
1019
1020////////////////////////////////////////////////////////////////////////////////
1021/// Add a class to the list and map of classes.
1022/// This routine is deprecated, use TClass::AddClass directly.
1023
1025{
1026 TClass::AddClass(cl);
1027}
1028
1029////////////////////////////////////////////////////////////////////////////////
1030/// Add a class generator. This generator will be called by TClass::GetClass
1031/// in case its does not find a loaded rootcint dictionary to request the
1032/// creation of a TClass object.
1033
1039
1040////////////////////////////////////////////////////////////////////////////////
1041/// Append object to this directory.
1042///
1043/// If replace is true:
1044/// remove any existing objects with the same same (if the name is not "")
1045
1046void TROOT::Append(TObject *obj, Bool_t replace /* = kFALSE */)
1047{
1049 TDirectory::Append(obj,replace);
1050}
1051
1052////////////////////////////////////////////////////////////////////////////////
1053/// Add browsable objects to TBrowser.
1054
1056{
1057 TObject *obj;
1058 TIter next(fBrowsables);
1059
1060 while ((obj = (TObject *) next())) {
1061 const char *opt = next.GetOption();
1062 if (opt && strlen(opt))
1063 b->Add(obj, opt);
1064 else
1065 b->Add(obj, obj->GetName());
1066 }
1067}
1068
1069namespace {
1070 std::set<TClass *> &GetClassSavedSet()
1071 {
1072 static thread_local std::set<TClass*> gClassSaved;
1073 return gClassSaved;
1074 }
1075}
1076
1077////////////////////////////////////////////////////////////////////////////////
1078/// return class status 'ClassSaved' for class cl
1079/// This function is called by the SavePrimitive functions writing
1080/// the C++ code for an object.
1081
1083{
1084 if (cl == nullptr)
1085 return kFALSE;
1086
1087 auto result = GetClassSavedSet().insert(cl);
1088
1089 // Return false on the first insertion only.
1090 return !result.second;
1091}
1092
1093////////////////////////////////////////////////////////////////////////////////
1094/// Reset the ClassSaved status of all classes
1096{
1097 GetClassSavedSet().clear();
1098}
1099
1100namespace {
1101 template <typename Content>
1102 static void R__ListSlowClose(TList *files)
1103 {
1104 // Routine to close a list of files using the 'slow' techniques
1105 // that also for the deletion ot update the list itself.
1106
1107 static TObject harmless;
1108 TObjLink *cursor = files->FirstLink();
1109 while (cursor) {
1110 Content *dir = static_cast<Content*>( cursor->GetObject() );
1111 if (dir) {
1112 // In order for the iterator to stay valid, we must
1113 // prevent the removal of the object (dir) from the list
1114 // (which is done in TFile::Close). We can also can not
1115 // just move to the next iterator since the Close might
1116 // also (indirectly) remove that file.
1117 // So we SetObject to a harmless value, so that 'dir'
1118 // is not seen as part of the list.
1119 // We will later, remove all the object (see files->Clear()
1120 cursor->SetObject(&harmless); // this must not be zero otherwise things go wrong.
1121 // See related comment at the files->Clear("nodelete");
1122 dir->Close("nodelete");
1123 // Put it back
1124 cursor->SetObject(dir);
1125 }
1126 cursor = cursor->Next();
1127 };
1128 // Now were done, clear the list but do not delete the objects as
1129 // they have been moved to the list of closed objects and must be
1130 // deleted from there in order to avoid a double delete from a
1131 // use objects (on the interpreter stack).
1132 files->Clear("nodelete");
1133 }
1134
1136 {
1137 // Routine to delete the content of list of files using the 'slow' techniques
1138
1139 static TObject harmless;
1140 TObjLink *cursor = files->FirstLink();
1141 while (cursor) {
1142 TDirectory *dir = dynamic_cast<TDirectory*>( cursor->GetObject() );
1143 if (dir) {
1144 // In order for the iterator to stay valid, we must
1145 // prevent the removal of the object (dir) from the list
1146 // (which is done in TFile::Close). We can also can not
1147 // just move to the next iterator since the Close might
1148 // also (indirectly) remove that file.
1149 // So we SetObject to a harmless value, so that 'dir'
1150 // is not seen as part of the list.
1151 // We will later, remove all the object (see files->Clear()
1152 cursor->SetObject(&harmless); // this must not be zero otherwise things go wrong.
1153 // See related comment at the files->Clear("nodelete");
1154 dir->GetList()->Delete("slow");
1155 // Put it back
1156 cursor->SetObject(dir);
1157 }
1158 cursor = cursor->Next();
1159 };
1160 }
1161}
1162
1163////////////////////////////////////////////////////////////////////////////////
1164/// Close any files and sockets that gROOT knows about.
1165/// This can be used to insures that the files and sockets are closed before any library is unloaded!
1166
1168{
1169 // Close files without deleting the objects (`ResetGlobals` will be called
1170 // next; see `EndOfProcessCleanups()` below.)
1171 if (fFiles && fFiles->First()) {
1173 }
1174 // and Close TROOT itself.
1175 Close("nodelete");
1176 // Now sockets.
1177 if (fSockets && fSockets->First()) {
1178 if (nullptr==fCleanups->FindObject(fSockets) ) {
1181 }
1182 CallFunc_t *socketCloser = gInterpreter->CallFunc_Factory();
1183 Longptr_t offset = 0;
1184 TClass *socketClass = TClass::GetClass("TSocket");
1185 gInterpreter->CallFunc_SetFuncProto(socketCloser, socketClass->GetClassInfo(), "Close", "", &offset);
1186 if (gInterpreter->CallFunc_IsValid(socketCloser)) {
1187 static TObject harmless;
1188 TObjLink *cursor = static_cast<TList*>(fSockets)->FirstLink();
1190 while (cursor) {
1191 TObject *socket = cursor->GetObject();
1192 // In order for the iterator to stay valid, we must
1193 // prevent the removal of the object (dir) from the list
1194 // (which is done in TFile::Close). We can also can not
1195 // just move to the next iterator since the Close might
1196 // also (indirectly) remove that file.
1197 // So we SetObject to a harmless value, so that 'dir'
1198 // is not seen as part of the list.
1199 // We will later, remove all the object (see files->Clear()
1200 cursor->SetObject(&harmless); // this must not be zero otherwise things go wrong.
1201
1202 if (socket->IsA()->InheritsFrom(socketClass)) {
1203 gInterpreter->CallFunc_Exec(socketCloser, ((char*)socket)+offset);
1204 // Put the object in the closed list for later deletion.
1205 socket->SetBit(kMustCleanup);
1207 } else {
1208 // Crap ... this is not a socket, let's try to find a Close
1210 CallFunc_t *otherCloser = gInterpreter->CallFunc_Factory();
1211 gInterpreter->CallFunc_SetFuncProto(otherCloser, socket->IsA()->GetClassInfo(), "Close", "", &other_offset);
1212 if (gInterpreter->CallFunc_IsValid(otherCloser)) {
1213 gInterpreter->CallFunc_Exec(otherCloser, ((char*)socket)+other_offset);
1214 // Put the object in the closed list for later deletion.
1215 socket->SetBit(kMustCleanup);
1217 } else {
1218 notclosed.AddLast(socket);
1219 }
1220 gInterpreter->CallFunc_Delete(otherCloser);
1221 // Put it back
1222 cursor->SetObject(socket);
1223 }
1224 cursor = cursor->Next();
1225 }
1226 // Now were done, clear the list
1227 fSockets->Clear();
1228 // Read the one we did not close
1229 cursor = notclosed.FirstLink();
1230 while (cursor) {
1231 static_cast<TList*>(fSockets)->AddLast(cursor->GetObject());
1232 cursor = cursor->Next();
1233 }
1234 }
1235 gInterpreter->CallFunc_Delete(socketCloser);
1236 }
1237 if (fMappedFiles && fMappedFiles->First()) {
1239 }
1240
1241}
1242
1243////////////////////////////////////////////////////////////////////////////////
1244/// Execute the cleanups necessary at the end of the process, in particular
1245/// those that must be executed before the library start being unloaded.
1246
1248{
1249 // This will not delete the objects 'held' by the TFiles so that
1250 // they can still be 'reacheable' when ResetGlobals is run.
1251 CloseFiles();
1252
1253 if (gInterpreter) {
1254 // This might delete some of the objects 'held' by the TFiles (hence
1255 // `CloseFiles` must not delete them)
1256 gInterpreter->ResetGlobals();
1257 }
1258
1259 // Now delete the objects still 'held' by the TFiles so that it
1260 // is done before the tear down of the libraries.
1263 }
1264 fList->Delete("slow");
1265
1266 // Now a set of simpler things to delete. See the same ordering in
1267 // TROOT::~TROOT
1268 fFunctions->Delete();
1270 fBrowsers->Delete();
1271 fCanvases->Delete("slow");
1272 fColors->Delete();
1273 fStyles->Delete();
1274
1276
1277 if (gInterpreter) {
1278 gInterpreter->ShutDown();
1279 }
1280}
1281
1282
1283////////////////////////////////////////////////////////////////////////////////
1284/// Find an object in one Root folder
1285
1287{
1288 Error("FindObject","Not yet implemented");
1289 return nullptr;
1290}
1291
1292////////////////////////////////////////////////////////////////////////////////
1293/// Returns address of a ROOT object if it exists
1294///
1295/// If name contains at least one "/" the function calls FindObjectany
1296/// else
1297/// This function looks in the following order in the ROOT lists:
1298/// - List of files
1299/// - List of memory mapped files
1300/// - List of functions
1301/// - List of geometries
1302/// - List of canvases
1303/// - List of styles
1304/// - List of specials
1305/// - List of materials in current geometry
1306/// - List of shapes in current geometry
1307/// - List of matrices in current geometry
1308/// - List of Nodes in current geometry
1309/// - Current Directory in memory
1310/// - Current Directory on file
1311
1312TObject *TROOT::FindObject(const char *name) const
1313{
1314 if (name && strstr(name,"/")) return FindObjectAny(name);
1315
1316 TObject *temp = nullptr;
1317
1318 temp = fFiles->FindObject(name); if (temp) return temp;
1319 temp = fMappedFiles->FindObject(name); if (temp) return temp;
1320 {
1322 temp = fFunctions->FindObject(name);if (temp) return temp;
1323 }
1324 temp = fGeometries->FindObject(name); if (temp) return temp;
1325 temp = fCanvases->FindObject(name); if (temp) return temp;
1326 temp = fStyles->FindObject(name); if (temp) return temp;
1327 {
1329 temp = fSpecials->FindObject(name); if (temp) return temp;
1330 }
1331 TIter next(fGeometries);
1332 TObject *obj;
1333 while ((obj=next())) {
1334 temp = obj->FindObject(name); if (temp) return temp;
1335 }
1336 if (gDirectory) temp = gDirectory->Get(name);
1337 if (temp) return temp;
1338 if (gPad) {
1339 TVirtualPad *canvas = gPad->GetVirtCanvas();
1340 if (fCanvases->FindObject(canvas)) { //this check in case call from TCanvas ctor
1341 temp = canvas->FindObject(name);
1342 if (!temp && canvas != gPad) temp = gPad->FindObject(name);
1343 }
1344 }
1345 return temp;
1346}
1347
1348////////////////////////////////////////////////////////////////////////////////
1349/// Returns address and folder of a ROOT object if it exists
1350///
1351/// This function looks in the following order in the ROOT lists:
1352/// - List of files
1353/// - List of memory mapped files
1354/// - List of functions
1355/// - List of geometries
1356/// - List of canvases
1357/// - List of styles
1358/// - List of specials
1359/// - List of materials in current geometry
1360/// - List of shapes in current geometry
1361/// - List of matrices in current geometry
1362/// - List of Nodes in current geometry
1363/// - Current Directory in memory
1364/// - Current Directory on file
1365
1367{
1368 TObject *temp = nullptr;
1369 where = nullptr;
1370
1371 if (!temp) {
1372 temp = fFiles->FindObject(name);
1373 where = fFiles;
1374 }
1375 if (!temp) {
1376 temp = fMappedFiles->FindObject(name);
1378 }
1379 if (!temp) {
1381 temp = fFunctions->FindObject(name);
1382 where = fFunctions;
1383 }
1384 if (!temp) {
1385 temp = fCanvases->FindObject(name);
1386 where = fCanvases;
1387 }
1388 if (!temp) {
1389 temp = fStyles->FindObject(name);
1390 where = fStyles;
1391 }
1392 if (!temp) {
1393 temp = fSpecials->FindObject(name);
1394 where = fSpecials;
1395 }
1396 if (!temp) {
1398 if (glast) {where = glast; temp = glast->FindObject(name);}
1399 }
1400 if (!temp && gDirectory) {
1401 gDirectory->GetObject(name, temp);
1402 where = gDirectory;
1403 }
1404 if (!temp && gPad) {
1405 TVirtualPad *canvas = gPad->GetVirtCanvas();
1406 if (fCanvases->FindObject(canvas)) { //this check in case call from TCanvas ctor
1407 temp = canvas->FindObject(name);
1408 where = canvas;
1409 if (!temp && canvas != gPad) {
1410 temp = gPad->FindObject(name);
1411 where = gPad;
1412 }
1413 }
1414 }
1415 if (!temp) return nullptr;
1416 if (!ROOT::Detail::HasBeenDeleted(temp)) return temp;
1417 return nullptr;
1418}
1419
1420////////////////////////////////////////////////////////////////////////////////
1421/// Return a pointer to the first object with name starting at //root.
1422/// This function scans the list of all folders.
1423/// if no object found in folders, it scans the memory list of all files.
1424
1426{
1428 if (obj) return obj;
1429 return gDirectory->FindObjectAnyFile(name);
1430}
1431
1432////////////////////////////////////////////////////////////////////////////////
1433/// Scan the memory lists of all files for an object with name
1434
1436{
1438 TDirectory *d;
1439 TIter next(GetListOfFiles());
1440 while ((d = (TDirectory*)next())) {
1441 // Call explicitly TDirectory::FindObject to restrict the search to the
1442 // already in memory object.
1443 TObject *obj = d->TDirectory::FindObject(name);
1444 if (obj) return obj;
1445 }
1446 return nullptr;
1447}
1448
1449////////////////////////////////////////////////////////////////////////////////
1450/// Returns class name of a ROOT object including CINT globals.
1451
1452const char *TROOT::FindObjectClassName(const char *name) const
1453{
1454 // Search first in the list of "standard" objects
1455 TObject *obj = FindObject(name);
1456 if (obj) return obj->ClassName();
1457
1458 // Is it a global variable?
1459 TGlobal *g = GetGlobal(name);
1460 if (g) return g->GetTypeName();
1461
1462 return nullptr;
1463}
1464
1465////////////////////////////////////////////////////////////////////////////////
1466/// Return path name of obj somewhere in the //root/... path.
1467/// The function returns the first occurence of the object in the list
1468/// of folders. The returned string points to a static char array in TROOT.
1469/// If this function is called in a loop or recursively, it is the
1470/// user's responsibility to copy this string in their area.
1471
1472const char *TROOT::FindObjectPathName(const TObject *) const
1473{
1474 Error("FindObjectPathName","Not yet implemented");
1475 return "??";
1476}
1477
1478////////////////////////////////////////////////////////////////////////////////
1479/// return a TClass object corresponding to 'name' assuming it is an STL container.
1480/// In particular we looking for possible alternative name (default template
1481/// parameter, typedefs template arguments, typedefed name).
1482
1484{
1485 // Example of inputs are
1486 // vector<int> (*)
1487 // vector<Int_t>
1488 // vector<long long>
1489 // vector<Long_64_t> (*)
1490 // vector<int, allocator<int> >
1491 // vector<Int_t, allocator<int> >
1492 //
1493 // One of the possibly expensive operation is the resolving of the typedef
1494 // which can provoke the parsing of the header files (and/or the loading
1495 // of clang pcms information).
1496
1498
1499 // Remove std::, allocator, typedef, add Long64_t, etc. in just one call.
1500 std::string normalized;
1502
1503 TClass *cl = nullptr;
1504 if (normalized != name) cl = TClass::GetClass(normalized.c_str(),load,silent);
1505
1506 if (load && cl==nullptr) {
1507 // Create an Emulated class for this container.
1508 cl = gInterpreter->GenerateTClass(normalized.c_str(), kTRUE, silent);
1509 }
1510
1511 return cl;
1512}
1513
1514////////////////////////////////////////////////////////////////////////////////
1515/// Return pointer to class with name. Obsolete, use TClass::GetClass directly
1516
1517TClass *TROOT::GetClass(const char *name, Bool_t load, Bool_t silent) const
1518{
1519 return TClass::GetClass(name,load,silent);
1520}
1521
1522
1523////////////////////////////////////////////////////////////////////////////////
1524/// Return pointer to class from its name. Obsolete, use TClass::GetClass directly
1525/// See TClass::GetClass
1526
1527TClass *TROOT::GetClass(const std::type_info& typeinfo, Bool_t load, Bool_t silent) const
1528{
1529 return TClass::GetClass(typeinfo,load,silent);
1530}
1531
1532////////////////////////////////////////////////////////////////////////////////
1533/// Return address of color with index color.
1534
1536{
1539 if (!lcolors) return nullptr;
1540 if (color < 0 || color >= lcolors->GetSize()) return nullptr;
1541 TColor *col = (TColor*)lcolors->At(color);
1542 if (col && col->GetNumber() == color) return col;
1543 TIter next(lcolors);
1544 while ((col = (TColor *) next()))
1545 if (col->GetNumber() == color) return col;
1546
1547 return nullptr;
1548}
1549
1550////////////////////////////////////////////////////////////////////////////////
1551/// Return a default canvas.
1552
1554{
1555 return (TCanvas*)gROOT->ProcessLine("TCanvas::MakeDefCanvas();");
1556}
1557
1558////////////////////////////////////////////////////////////////////////////////
1559/// Return pointer to type with name.
1560
1561TDataType *TROOT::GetType(const char *name, Bool_t /* load */) const
1562{
1563 return (TDataType*)gROOT->GetListOfTypes()->FindObject(name);
1564}
1565
1566////////////////////////////////////////////////////////////////////////////////
1567/// Return pointer to file with name.
1568
1569TFile *TROOT::GetFile(const char *name) const
1570{
1572 return (TFile*)GetListOfFiles()->FindObject(name);
1573}
1574
1575////////////////////////////////////////////////////////////////////////////////
1576/// Return pointer to style with name
1577
1578TStyle *TROOT::GetStyle(const char *name) const
1579{
1581}
1582
1583////////////////////////////////////////////////////////////////////////////////
1584/// Return pointer to function with name.
1585
1587{
1588 if (!name || !*name)
1589 return nullptr;
1590
1591 static std::atomic<bool> isInited = false;
1592
1593 // Capture the state before calling FindObject as it could change
1594 // between the end of FindObject and the if statement
1595 bool wasInited = isInited.load();
1596
1597 auto f1 = fFunctions->FindObject(name);
1598 if (f1 || wasInited)
1599 return f1;
1600
1601 // If 2 threads gets here at the same time, the static initialization "lock"
1602 // will stall one of them until ProcessLine is finished and both will return the
1603 // correct answer.
1604 // Note: if one (or more) thread(s) is suspended right after the 'isInited.load()`
1605 // and restart after this thread has finished the initialization (i.e. a rare case),
1606 // the only penalty we pay is a spurious 2nd lookup for an unknown function.
1607 [[maybe_unused]] static const auto _res = []() {
1608 gROOT->ProcessLine("TF1::InitStandardFunctions();");
1609 isInited = true;
1610 return true;
1611 }();
1612 return fFunctions->FindObject(name);
1613}
1614
1615////////////////////////////////////////////////////////////////////////////////
1616
1618{
1619 if (!gInterpreter) return nullptr;
1620
1622
1624}
1625
1626////////////////////////////////////////////////////////////////////////////////
1627/// Return pointer to global variable by name. If load is true force
1628/// reading of all currently defined globals from CINT (more expensive).
1629
1630TGlobal *TROOT::GetGlobal(const char *name, Bool_t load) const
1631{
1632 return (TGlobal *)gROOT->GetListOfGlobals(load)->FindObject(name);
1633}
1634
1635////////////////////////////////////////////////////////////////////////////////
1636/// Return pointer to global variable with address addr.
1637
1638TGlobal *TROOT::GetGlobal(const TObject *addr, Bool_t /* load */) const
1639{
1640 if (addr == nullptr || ((Longptr_t)addr) == -1) return nullptr;
1641
1642 TInterpreter::DeclId_t decl = gInterpreter->GetDataMemberAtAddr(addr);
1643 if (decl) {
1644 TListOfDataMembers *globals = ((TListOfDataMembers*)(gROOT->GetListOfGlobals(kFALSE)));
1645 return (TGlobal*)globals->Get(decl);
1646 }
1647 // If we are actually looking for a global that is held by a global
1648 // pointer (for example gRandom), we need to find a pointer with the
1649 // correct value.
1650 decl = gInterpreter->GetDataMemberWithValue(addr);
1651 if (decl) {
1652 TListOfDataMembers *globals = ((TListOfDataMembers*)(gROOT->GetListOfGlobals(kFALSE)));
1653 return (TGlobal*)globals->Get(decl);
1654 }
1655 return nullptr;
1656}
1657
1658////////////////////////////////////////////////////////////////////////////////
1659/// Internal routine returning, and creating if necessary, the list
1660/// of global function.
1661
1667
1668////////////////////////////////////////////////////////////////////////////////
1669/// Return the collection of functions named "name".
1670
1672{
1673 return ((TListOfFunctions*)fGlobalFunctions)->GetListForObject(name);
1674}
1675
1676////////////////////////////////////////////////////////////////////////////////
1677/// Return pointer to global function by name.
1678/// If params != 0 it will also resolve overloading other it returns the first
1679/// name match.
1680/// If params == 0 and load is true force reading of all currently defined
1681/// global functions from Cling.
1682/// The param string must be of the form: "3189,\"aap\",1.3".
1683
1684TFunction *TROOT::GetGlobalFunction(const char *function, const char *params,
1685 Bool_t load)
1686{
1687 if (!params) {
1689 return (TFunction *)GetListOfGlobalFunctions(load)->FindObject(function);
1690 } else {
1691 if (!fInterpreter)
1692 Fatal("GetGlobalFunction", "fInterpreter not initialized");
1693
1695 TInterpreter::DeclId_t decl = gInterpreter->GetFunctionWithValues(nullptr,
1696 function, params,
1697 false);
1698
1699 if (!decl) return nullptr;
1700
1702 if (f) return f;
1703
1704 Error("GetGlobalFunction",
1705 "\nDid not find matching TFunction <%s> with \"%s\".",
1706 function,params);
1707 return nullptr;
1708 }
1709}
1710
1711////////////////////////////////////////////////////////////////////////////////
1712/// Return pointer to global function by name. If proto != 0
1713/// it will also resolve overloading. If load is true force reading
1714/// of all currently defined global functions from CINT (more expensive).
1715/// The proto string must be of the form: "int, char*, float".
1716
1718 const char *proto, Bool_t load)
1719{
1720 if (!proto) {
1722 return (TFunction *)GetListOfGlobalFunctions(load)->FindObject(function);
1723 } else {
1724 if (!fInterpreter)
1725 Fatal("GetGlobalFunctionWithPrototype", "fInterpreter not initialized");
1726
1728 TInterpreter::DeclId_t decl = gInterpreter->GetFunctionWithPrototype(nullptr,
1729 function, proto);
1730
1731 if (!decl) return nullptr;
1732
1734 if (f) return f;
1735
1736 Error("GetGlobalFunctionWithPrototype",
1737 "\nDid not find matching TFunction <%s> with \"%s\".",
1738 function,proto);
1739 return nullptr;
1740 }
1741}
1742
1743////////////////////////////////////////////////////////////////////////////////
1744/// Return pointer to Geometry with name
1745
1747{
1749}
1750
1751////////////////////////////////////////////////////////////////////////////////
1752
1754{
1755 if(!fEnums.load()) {
1757 // Test again just in case, another thread did the work while we were
1758 // waiting.
1759 if (!fEnums.load()) fEnums = new TListOfEnumsWithLock(nullptr);
1760 }
1761 if (load) {
1763 (*fEnums).Load(); // Refresh the list of enums.
1764 }
1765 return fEnums.load();
1766}
1767
1768////////////////////////////////////////////////////////////////////////////////
1769
1778
1779////////////////////////////////////////////////////////////////////////////////
1780/// Return list containing the TGlobals currently defined.
1781/// Since globals are created and deleted during execution of the
1782/// program, we need to update the list of globals every time we
1783/// execute this method. However, when calling this function in
1784/// a (tight) loop where no interpreter symbols will be created
1785/// you can set load=kFALSE (default).
1786
1788{
1789 if (!fGlobals) {
1791 // We add to the list the "funcky-fake" globals.
1792
1793 // provide special functor for gROOT, while ROOT::GetROOT() does not return reference
1794 TGlobalMappedFunction::MakeFunctor("gROOT", "TROOT*", ROOT::GetROOT, [] {
1795 ROOT::GetROOT();
1796 return (void *)&ROOT::Internal::gROOTLocal;
1797 });
1798
1800 TGlobalMappedFunction::MakeFunctor("gVirtualX", "TVirtualX*", TVirtualX::Instance);
1802
1803 // Don't let TGlobalMappedFunction delete our globals, now that we take them.
1807 }
1808
1809 if (!fInterpreter)
1810 Fatal("GetListOfGlobals", "fInterpreter not initialized");
1811
1812 if (load) fGlobals->Load();
1813
1814 return fGlobals;
1815}
1816
1817////////////////////////////////////////////////////////////////////////////////
1818/// Return list containing the TFunctions currently defined.
1819/// Since functions are created and deleted during execution of the
1820/// program, we need to update the list of functions every time we
1821/// execute this method. However, when calling this function in
1822/// a (tight) loop where no interpreter symbols will be created
1823/// you can set load=kFALSE (default).
1824
1826{
1828
1829 if (!fGlobalFunctions) {
1830 fGlobalFunctions = new TListOfFunctions(nullptr);
1831 }
1832
1833 if (!fInterpreter)
1834 Fatal("GetListOfGlobalFunctions", "fInterpreter not initialized");
1835
1836 // A thread that calls with load==true and a thread that calls with load==false
1837 // will conflict here (the load==true will be updating the list while the
1838 // other is reading it). To solve the problem, we could use a read-write lock
1839 // inside the list itself.
1840 if (load) fGlobalFunctions->Load();
1841
1842 return fGlobalFunctions;
1843}
1844
1845////////////////////////////////////////////////////////////////////////////////
1846/// Return a dynamic list giving access to all TDataTypes (typedefs)
1847/// currently defined.
1848///
1849/// The list is populated on demand. Calling
1850/// ~~~ {.cpp}
1851/// gROOT->GetListOfTypes()->FindObject(nameoftype);
1852/// ~~~
1853/// will return the TDataType corresponding to 'nameoftype'. If the
1854/// TDataType is not already in the list itself and the type does exist,
1855/// a new TDataType will be created and added to the list.
1856///
1857/// Calling
1858/// ~~~ {.cpp}
1859/// gROOT->GetListOfTypes()->ls(); // or Print()
1860/// ~~~
1861/// list only the typedefs that have been previously accessed through the
1862/// list (plus the builtins types).
1863
1865{
1866 if (!fInterpreter)
1867 Fatal("GetListOfTypes", "fInterpreter not initialized");
1868
1869 return fTypes;
1870}
1871
1872////////////////////////////////////////////////////////////////////////////////
1873/// Get number of classes.
1874
1876{
1877 return fClasses->GetSize();
1878}
1879
1880////////////////////////////////////////////////////////////////////////////////
1881/// Get number of types.
1882
1884{
1885 return fTypes->GetSize();
1886}
1887
1888////////////////////////////////////////////////////////////////////////////////
1889/// Execute command when system has been idle for idleTimeInSec seconds.
1890
1892{
1893 if (!fApplication.load())
1895
1896 if (idleTimeInSec <= 0)
1897 (*fApplication).RemoveIdleTimer();
1898 else
1899 (*fApplication).SetIdleTimer(idleTimeInSec, command);
1900}
1901
1902////////////////////////////////////////////////////////////////////////////////
1903/// Check whether className is a known class, and only autoload
1904/// if we can. Helper function for TROOT::IgnoreInclude().
1905
1906static TClass* R__GetClassIfKnown(const char* className)
1907{
1908 // Check whether the class is available for auto-loading first:
1909 const char* libsToLoad = gInterpreter->GetClassSharedLibs(className);
1910 TClass* cla = nullptr;
1911 if (libsToLoad) {
1912 // trigger autoload, and only create TClass in this case.
1913 return TClass::GetClass(className);
1914 } else if (gROOT->GetListOfClasses()
1915 && (cla = (TClass*)gROOT->GetListOfClasses()->FindObject(className))) {
1916 // cla assigned in if statement
1917 } else if (gClassTable->FindObject(className)) {
1918 return TClass::GetClass(className);
1919 }
1920 return cla;
1921}
1922
1923////////////////////////////////////////////////////////////////////////////////
1924/// Return 1 if the name of the given include file corresponds to a class that
1925/// is known to ROOT, e.g. "TLorentzVector.h" versus TLorentzVector.
1926
1927Int_t TROOT::IgnoreInclude(const char *fname, const char * /*expandedfname*/)
1928{
1929 if (fname == nullptr) return 0;
1930
1932 // Remove extension if any, ignore files with extension not being .h*
1933 Int_t where = stem.Last('.');
1934 if (where != kNPOS) {
1935 if (stem.EndsWith(".so") || stem.EndsWith(".sl") ||
1936 stem.EndsWith(".dl") || stem.EndsWith(".a") ||
1937 stem.EndsWith(".dll", TString::kIgnoreCase))
1938 return 0;
1939 stem.Remove(where);
1940 }
1941
1942 TString className = gSystem->BaseName(stem);
1943 TClass* cla = R__GetClassIfKnown(className);
1944 if (!cla) {
1945 // Try again with modifications to the file name:
1946 className = stem;
1947 className.ReplaceAll("/", "::");
1948 className.ReplaceAll("\\", "::");
1949 if (className.Contains(":::")) {
1950 // "C:\dir" becomes "C:::dir".
1951 // fname corresponds to whatever is stated after #include and
1952 // a full path name usually means that it's not a regular #include
1953 // but e.g. a ".L", so we can assume that this is not a header of
1954 // a class in a namespace (a global-namespace class would have been
1955 // detected already before).
1956 return 0;
1957 }
1958 cla = R__GetClassIfKnown(className);
1959 }
1960
1961 if (!cla) {
1962 return 0;
1963 }
1964
1965 // cla is valid, check wether it's actually in the header of the same name:
1966 if (cla->GetDeclFileLine() <= 0) return 0; // to a void an error with VisualC++
1967 TString decfile = gSystem->BaseName(cla->GetDeclFileName());
1968 if (decfile != gSystem->BaseName(fname)) {
1969 return 0;
1970 }
1971 return 1;
1972}
1973
1974////////////////////////////////////////////////////////////////////////////////
1975/// Initialize operating system interface.
1976
1978{
1979 if (gSystem == nullptr) {
1980#if defined(R__UNIX)
1981#if defined(R__HAS_COCOA)
1982 gSystem = new TMacOSXSystem;
1983#else
1984 gSystem = new TUnixSystem;
1985#endif
1986#elif defined(R__WIN32)
1987 gSystem = new TWinNTSystem;
1988#else
1989 gSystem = new TSystem;
1990#endif
1991
1992 if (gSystem->Init())
1993 fprintf(stderr, "Fatal in <TROOT::InitSystem>: can't init operating system layer\n");
1994
1995 if (!gSystem->HomeDirectory()) {
1996 fprintf(stderr, "Fatal in <TROOT::InitSystem>: HOME directory not set\n");
1997 fprintf(stderr, "Fix this by defining the HOME shell variable\n");
1998 }
1999
2000 // read default files
2001 gEnv = new TEnv(".rootrc");
2002
2005
2006 gDebug = gEnv->GetValue("Root.Debug", 0);
2007
2008 if (!gEnv->GetValue("Root.ErrorHandlers", 1))
2010
2011 // The old "Root.ZipMode" had a discrepancy between documentation vs actual meaning.
2012 // Also, a value with the meaning "default" wasn't available. To solved this,
2013 // "Root.ZipMode" was replaced by "Root.CompressionAlgorithm". Warn about usage of
2014 // the old value, if it's set to 0, but silently translate the setting to
2015 // "Root.CompressionAlgorithm" for values > 1.
2016 Int_t oldzipmode = gEnv->GetValue("Root.ZipMode", -1);
2017 if (oldzipmode == 0) {
2018 fprintf(stderr, "Warning in <TROOT::InitSystem>: ignoring old rootrc entry \"Root.ZipMode = 0\"!\n");
2019 } else {
2020 if (oldzipmode == -1 || oldzipmode == 1) {
2021 // Not set or default value, use "default" for "Root.CompressionAlgorithm":
2022 oldzipmode = 0;
2023 }
2024 // else keep the old zipmode (e.g. "3") as "Root.CompressionAlgorithm"
2025 // if "Root.CompressionAlgorithm" isn't set; see below.
2026 }
2027
2028 Int_t zipmode = gEnv->GetValue("Root.CompressionAlgorithm", oldzipmode);
2029 if (zipmode != 0) R__SetZipMode(zipmode);
2030
2031 const char *sdeb;
2032 if ((sdeb = gSystem->Getenv("ROOTDEBUG")))
2033 gDebug = atoi(sdeb);
2034
2035 if (gDebug > 0 && isatty(2))
2036 fprintf(stderr, "Info in <TROOT::InitSystem>: running with gDebug = %d\n", gDebug);
2037
2038#if defined(R__HAS_COCOA)
2039 // create and delete a dummy TUrl so that TObjectStat table does not contain
2040 // objects that are deleted after recording is turned-off (in next line),
2041 // like the TUrl::fgSpecialProtocols list entries which are created in the
2042 // TMacOSXSystem ctor.
2043 { TUrl dummy("/dummy"); }
2044#endif
2045 TObject::SetObjectStat(gEnv->GetValue("Root.ObjectStat", 0));
2046 }
2047}
2048
2049////////////////////////////////////////////////////////////////////////////////
2050/// Load and initialize thread library.
2051
2053{
2054 if (gEnv->GetValue("Root.UseThreads", 0) || gEnv->GetValue("Root.EnableThreadSafety", 0)) {
2056 }
2057}
2058
2059////////////////////////////////////////////////////////////////////////////////
2060/// Initialize the interpreter. Should be called only after main(),
2061/// to make sure LLVM/Clang is fully initialized.
2062/// This function must be called in a single thread context (static initialization)
2063
2065{
2066 // usedToIdentifyRootClingByDlSym is available when TROOT is part of
2067 // rootcling.
2068 if (!dlsym(RTLD_DEFAULT, "usedToIdentifyRootClingByDlSym")
2069 && !dlsym(RTLD_DEFAULT, "usedToIdentifyStaticRoot")) {
2070 char *libRIO = gSystem->DynamicPathName("libRIO");
2072 delete [] libRIO;
2073 if (!libRIOHandle) {
2074 TString err = dlerror();
2075 fprintf(stderr, "Fatal in <TROOT::InitInterpreter>: cannot load library %s\n", err.Data());
2076 exit(1);
2077 }
2078
2079 char *libcling = gSystem->DynamicPathName("libCling");
2081 delete [] libcling;
2082
2083 if (!gInterpreterLib) {
2084 TString err = dlerror();
2085 fprintf(stderr, "Fatal in <TROOT::InitInterpreter>: cannot load library %s\n", err.Data());
2086 exit(1);
2087 }
2088 dlerror(); // reset error message
2089 } else {
2091 }
2093 if (!CreateInterpreter) {
2094 TString err = dlerror();
2095 fprintf(stderr, "Fatal in <TROOT::InitInterpreter>: cannot load symbol %s\n", err.Data());
2096 exit(1);
2097 }
2098 // Schedule the destruction of TROOT.
2100
2102 if (!gDestroyInterpreter) {
2103 TString err = dlerror();
2104 fprintf(stderr, "Fatal in <TROOT::InitInterpreter>: cannot load symbol %s\n", err.Data());
2105 exit(1);
2106 }
2107
2108 const char *interpArgs[] = {
2109#ifdef NDEBUG
2110 "-DNDEBUG",
2111#else
2112 "-UNDEBUG",
2113#endif
2114#ifdef DEBUG
2115 "-DDEBUG",
2116#else
2117 "-UDEBUG",
2118#endif
2119#ifdef _DEBUG
2120 "-D_DEBUG",
2121#else
2122 "-U_DEBUG",
2123#endif
2124 nullptr};
2125
2127
2130
2131 fgRootInit = kTRUE;
2132
2133 // initialize gClassTable is not already done
2134 if (!gClassTable)
2135 new TClassTable;
2136
2137 // Initialize all registered dictionaries.
2138 for (std::vector<ModuleHeaderInfo_t>::const_iterator
2139 li = GetModuleHeaderInfoBuffer().begin(),
2140 le = GetModuleHeaderInfoBuffer().end(); li != le; ++li) {
2141 // process buffered module registrations
2142 fInterpreter->RegisterModule(li->fModuleName,
2143 li->fHeaders,
2144 li->fIncludePaths,
2145 li->fPayloadCode,
2146 li->fFwdDeclCode,
2147 li->fTriggerFunc,
2148 li->fFwdNargsToKeepColl,
2149 li->fClassesHeaders,
2150 kTRUE /*lateRegistration*/,
2151 li->fHasCxxModule);
2152 }
2153 GetModuleHeaderInfoBuffer().clear();
2154
2156}
2157
2158////////////////////////////////////////////////////////////////////////////////
2159/// Helper function used by TClass::GetClass().
2160/// This function attempts to load the dictionary for 'classname'
2161/// either from the TClassTable or from the list of generator.
2162/// If silent is 'true', do not warn about missing dictionary for the class.
2163/// (typically used for class that are used only for transient members)
2164///
2165/// The 'requestedname' is expected to be already normalized.
2166
2171
2172////////////////////////////////////////////////////////////////////////////////
2173/// Check if class "classname" is known to the interpreter (in fact,
2174/// this check is not needed anymore, so classname is ignored). If
2175/// not it will load library "libname". If the library couldn't be found with original
2176/// libname and if the name was not prefixed with lib, try to prefix with "lib" and search again.
2177/// If DynamicPathName still couldn't find the library, return -1.
2178/// If check is true it will only check if libname exists and is
2179/// readable.
2180/// Returns 0 on successful loading, -1 in case libname does not
2181/// exist or in case of error and -2 in case of version mismatch.
2182
2183Int_t TROOT::LoadClass(const char * /*classname*/, const char *libname,
2184 Bool_t check)
2185{
2186 TString lib(libname);
2187
2188 // Check if libname exists in path or not
2189 if (char *path = gSystem->DynamicPathName(lib, kTRUE)) {
2190 // If check == true, only check if it exists and if it's readable
2191 if (check) {
2192 delete [] path;
2193 return 0;
2194 }
2195
2196 // If check == false, try to load the library
2197 else {
2198 int err = gSystem->Load(path, nullptr, kTRUE);
2199 delete [] path;
2200
2201 // TSystem::Load returns 1 when the library was already loaded, return success in this case.
2202 if (err == 1)
2203 err = 0;
2204 return err;
2205 }
2206 } else {
2207 // This is the branch where libname didn't exist
2208 if (check) {
2209 FileStat_t stat;
2210 if (!gSystem->GetPathInfo(libname, stat) && (R_ISREG(stat.fMode) &&
2212 return 0;
2213 }
2214
2215 // Take care of user who didn't write the whole name
2216 if (!lib.BeginsWith("lib")) {
2217 lib = "lib" + lib;
2218 return LoadClass("", lib.Data(), check);
2219 }
2220 }
2221
2222 // Execution reaches here when library was prefixed with lib, check is false and couldn't find
2223 // the library name.
2224 return -1;
2225}
2226
2227////////////////////////////////////////////////////////////////////////////////
2228/// Return true if the file is local and is (likely) to be a ROOT file
2229
2231{
2234 if (mayberootfile) {
2235 char header[5];
2236 if (fgets(header,5,mayberootfile)) {
2237 result = strncmp(header,"root",4)==0;
2238 }
2240 }
2241 return result;
2242}
2243
2244////////////////////////////////////////////////////////////////////////////////
2245/// To list all objects of the application.
2246/// Loop on all objects created in the ROOT linked lists.
2247/// Objects may be files and windows or any other object directly
2248/// attached to the ROOT linked list.
2249
2251{
2252// TObject::SetDirLevel();
2253// GetList()->R__FOR_EACH(TObject,ls)(option);
2255}
2256
2257////////////////////////////////////////////////////////////////////////////////
2258/// Load a macro in the interpreter's memory. Equivalent to the command line
2259/// command ".L filename". If the filename has "+" or "++" appended
2260/// the macro will be compiled by ACLiC. The filename must have the format:
2261/// [path/]macro.C[+|++[g|O]].
2262/// The possible error codes are defined by TInterpreter::EErrorCode.
2263/// If check is true it will only check if filename exists and is
2264/// readable.
2265/// Returns 0 on successful loading and -1 in case filename does not
2266/// exist or in case of error.
2267
2268Int_t TROOT::LoadMacro(const char *filename, int *error, Bool_t check)
2269{
2270 Int_t err = -1;
2271 Int_t lerr, *terr;
2272 if (error)
2273 terr = error;
2274 else
2275 terr = &lerr;
2276
2277 if (fInterpreter) {
2279 TString arguments;
2280 TString io;
2282
2283 if (arguments.Length()) {
2284 Warning("LoadMacro", "argument(%s) ignored in %s", arguments.Data(), GetMacroPath());
2285 }
2287 if (!mac) {
2288 if (!check)
2289 Error("LoadMacro", "macro %s not found in path %s", fname.Data(), GetMacroPath());
2291 } else {
2292 err = 0;
2293 if (!check) {
2294 fname = mac;
2295 fname += aclicMode;
2296 fname += io;
2297 gInterpreter->LoadMacro(fname.Data(), (TInterpreter::EErrorCode*)terr);
2298 if (*terr)
2299 err = -1;
2300 }
2301 }
2302 delete [] mac;
2303 }
2304 return err;
2305}
2306
2307////////////////////////////////////////////////////////////////////////////////
2308/// Execute a macro in the interpreter. Equivalent to the command line
2309/// command ".x filename". If the filename has "+" or "++" appended
2310/// the macro will be compiled by ACLiC. The filename must have the format:
2311/// [path/]macro.C[+|++[g|O]][(args)].
2312/// The possible error codes are defined by TInterpreter::EErrorCode.
2313/// If padUpdate is true (default) update the current pad.
2314/// Returns the macro return value.
2315
2317{
2318 Longptr_t result = 0;
2319
2320 if (fInterpreter) {
2322 TString arguments;
2323 TString io;
2325
2327 if (!mac) {
2328 Error("Macro", "macro %s not found in path %s", fname.Data(), GetMacroPath());
2329 if (error)
2330 *error = TInterpreter::kFatal;
2331 } else {
2332 fname = mac;
2333 fname += aclicMode;
2334 fname += arguments;
2335 fname += io;
2336 result = gInterpreter->ExecuteMacro(fname, (TInterpreter::EErrorCode*)error);
2337 }
2338 delete [] mac;
2339
2340 if (padUpdate && gPad)
2341 gPad->Update();
2342 }
2343
2344 return result;
2345}
2346
2347////////////////////////////////////////////////////////////////////////////////
2348/// Process message id called by obj.
2349
2350void TROOT::Message(Int_t id, const TObject *obj)
2351{
2352 TIter next(fMessageHandlers);
2354 while ((mh = (TMessageHandler*)next())) {
2355 mh->HandleMessage(id,obj);
2356 }
2357}
2358
2359////////////////////////////////////////////////////////////////////////////////
2360/// Process interpreter command via TApplication::ProcessLine().
2361/// On Win32 the line will be processed asynchronously by sending
2362/// it to the CINT interpreter thread. For explicit synchronous processing
2363/// use ProcessLineSync(). On non-Win32 platforms there is no difference
2364/// between ProcessLine() and ProcessLineSync().
2365/// The possible error codes are defined by TInterpreter::EErrorCode. In
2366/// particular, error will equal to TInterpreter::kProcessing until the
2367/// CINT interpreted thread has finished executing the line.
2368/// Returns the result of the command, cast to a Longptr_t.
2369
2371{
2372 TString sline = line;
2373 sline = sline.Strip(TString::kBoth);
2374
2375 if (!fApplication.load())
2377
2378 return (*fApplication).ProcessLine(sline, kFALSE, error);
2379}
2380
2381////////////////////////////////////////////////////////////////////////////////
2382/// Process interpreter command via TApplication::ProcessLine().
2383/// On Win32 the line will be processed synchronously (i.e. it will
2384/// only return when the CINT interpreter thread has finished executing
2385/// the line). On non-Win32 platforms there is no difference between
2386/// ProcessLine() and ProcessLineSync().
2387/// The possible error codes are defined by TInterpreter::EErrorCode.
2388/// Returns the result of the command, cast to a Longptr_t.
2389
2391{
2392 TString sline = line;
2393 sline = sline.Strip(TString::kBoth);
2394
2395 if (!fApplication.load())
2397
2398 return (*fApplication).ProcessLine(sline, kTRUE, error);
2399}
2400
2401////////////////////////////////////////////////////////////////////////////////
2402/// Process interpreter command directly via CINT interpreter.
2403/// Only executable statements are allowed (no variable declarations),
2404/// In all other cases use TROOT::ProcessLine().
2405/// The possible error codes are defined by TInterpreter::EErrorCode.
2406
2408{
2409 TString sline = line;
2410 sline = sline.Strip(TString::kBoth);
2411
2412 if (!fApplication.load())
2414
2415 Longptr_t result = 0;
2416
2417 if (fInterpreter) {
2419 result = gInterpreter->Calc(sline, code);
2420 }
2421
2422 return result;
2423}
2424
2425////////////////////////////////////////////////////////////////////////////////
2426/// Read Git commit information and branch name from the
2427/// etc/gitinfo.txt file.
2428
2430{
2431 TString filename = "gitinfo.txt";
2433
2434 FILE *fp = fopen(filename, "r");
2435 if (fp) {
2436 TString s;
2437 // read branch name
2438 s.Gets(fp);
2439 fGitBranch = s;
2440 // read commit hash
2441 s.Gets(fp);
2442 fGitCommit = s;
2443 // read date/time make was run
2444 s.Gets(fp);
2445 fGitDate = s;
2446 fclose(fp);
2447 } else {
2448 Error("ReadGitInfo()", "Cannot determine git info: etc/gitinfo.txt not found!");
2449 }
2450}
2451
2456
2457////////////////////////////////////////////////////////////////////////////////
2458/// Deprecated (will be removed in next release).
2459
2461{
2462 return GetReadingObject();
2463}
2464
2469
2470
2471////////////////////////////////////////////////////////////////////////////////
2472/// Return date/time make was run.
2473
2475{
2476 if (fGitDate == "") {
2478 static const char *months[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
2479 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
2480 Int_t idate = gROOT->GetBuiltDate();
2481 Int_t itime = gROOT->GetBuiltTime();
2482 iday = idate%100;
2483 imonth = (idate/100)%100;
2484 iyear = idate/10000;
2485 ihour = itime/100;
2486 imin = itime%100;
2487 fGitDate.Form("%s %02d %4d, %02d:%02d:00", months[imonth-1], iday, iyear, ihour, imin);
2488 }
2489 return fGitDate;
2490}
2491
2492////////////////////////////////////////////////////////////////////////////////
2493/// Recursively remove this object from the list of Cleanups.
2494/// Typically RecursiveRemove is implemented by classes that can contain
2495/// mulitple references to a same object or shared ownership of the object
2496/// with others.
2497
2504
2505////////////////////////////////////////////////////////////////////////////////
2506/// Refresh all browsers. Call this method when some command line
2507/// command or script has changed the browser contents. Not needed
2508/// for objects that have the kMustCleanup bit set. Most useful to
2509/// update browsers that show the file system or other objects external
2510/// to the running ROOT session.
2511
2513{
2514 TIter next(GetListOfBrowsers());
2515 TBrowser *b;
2516 while ((b = (TBrowser*) next()))
2518}
2519////////////////////////////////////////////////////////////////////////////////
2520/// Insure that the files, canvases and sockets are closed.
2521
2522static void CallCloseFiles()
2523{
2525 gROOT->CloseFiles();
2526 }
2527}
2528
2529////////////////////////////////////////////////////////////////////////////////
2530/// Called by static dictionary initialization to register clang modules
2531/// for headers. Calls TCling::RegisterModule() unless gCling
2532/// is NULL, i.e. during startup, where the information is buffered in
2533/// the static GetModuleHeaderInfoBuffer().
2534/// The caller of this function should be holding the ROOT Write lock or be
2535/// single threaded (dlopen)
2536
2538 const char** headers,
2539 const char** includePaths,
2540 const char* payloadCode,
2541 const char* fwdDeclCode,
2542 void (*triggerFunc)(),
2544 const char** classesHeaders,
2545 bool hasCxxModule)
2546{
2547
2548 // First a side track to insure proper end of process behavior.
2549
2550 // Register for each loaded dictionary (and thus for each library),
2551 // that we need to Close the ROOT files as soon as this library
2552 // might start being unloaded after main.
2553 //
2554 // By calling atexit here (rather than directly from within the
2555 // library) we make sure that this is not called if the library is
2556 // 'only' dlclosed.
2557
2558 // On Ubuntu the linker strips the unused libraries. Eventhough
2559 // stressHistogram is explicitly linked against libNet, it is not
2560 // retained and thus is loaded only as needed in the middle part of
2561 // the execution. Concretely this also means that it is loaded
2562 // *after* the construction of the TApplication object and thus
2563 // after the registration (atexit) of the EndOfProcessCleanups
2564 // routine. Consequently, after the end of main, libNet is
2565 // unloaded before EndOfProcessCleanups is called. When
2566 // EndOfProcessCleanups is executed it indirectly needs the TClass
2567 // for TSocket and its search will use resources that have already
2568 // been unloaded (technically the function static in TUnixSystem's
2569 // DynamicPath and the dictionary from libNet).
2570
2571 // Similarly, the ordering (before this commit) was broken in the
2572 // following case:
2573
2574 // TApplication creation (EndOfProcessCleanups registration)
2575 // load UserLibrary
2576 // create TFile
2577 // Append UserObject to TFile
2578
2579 // and after the end of main the order of execution was
2580
2581 // unload UserLibrary
2582 // call EndOfProcessCleanups
2583 // Write the TFile
2584 // attempt to write the user object.
2585 // ....
2586
2587 // where what we need is to have the files closen/written before
2588 // the unloading of the library.
2589
2590 // To solve the problem we now register an atexit function for
2591 // every dictionary thus making sure there is at least one executed
2592 // before the first library tear down after main.
2593
2594 // If atexit is called directly within a library's code, the
2595 // function will called *either* when the library is 'dlclose'd or
2596 // after then end of main (whichever comes first). We do *not*
2597 // want the files to be closed whenever a library is unloaded via
2598 // dlclose. To avoid this, we add the function (CallCloseFiles)
2599 // from the dictionary indirectly (via ROOT::RegisterModule). In
2600 // this case the function will only only be called either when
2601 // libCore is 'dlclose'd or right after the end of main.
2602
2604
2605 // Now register with TCling.
2606 if (TROOT::Initialized()) {
2609 } else {
2610 GetModuleHeaderInfoBuffer().push_back(ModuleHeaderInfo_t(modulename, headers, includePaths, payloadCode,
2613 }
2614}
2615
2616////////////////////////////////////////////////////////////////////////////////
2617/// Remove an object from the in-memory list.
2618/// Since TROOT is global resource, this is lock protected.
2619
2621{
2623 return TDirectory::Remove(obj);
2624}
2625
2626////////////////////////////////////////////////////////////////////////////////
2627/// Remove a class from the list and map of classes.
2628/// This routine is deprecated, use TClass::RemoveClass directly.
2629
2634
2635////////////////////////////////////////////////////////////////////////////////
2636/// Delete all global interpreter objects created since the last call to Reset
2637///
2638/// If option="a" is set reset to startup context (i.e. unload also
2639/// all loaded files, classes, structs, typedefs, etc.).
2640///
2641/// This function is typically used at the beginning (or end) of an unnamed macro
2642/// to clean the environment.
2643///
2644/// IMPORTANT WARNING:
2645/// Do not use this call from within any function (neither compiled nor
2646/// interpreted. This should only be used from a unnamed macro
2647/// (which starts with a { (curly braces) ). For example, using TROOT::Reset
2648/// from within an interpreted function will lead to the unloading of the
2649/// dictionary and source file, including the one defining the function being
2650/// executed.
2651///
2652
2654{
2655 if (IsExecutingMacro()) return; //True when TMacro::Exec runs
2656 if (fInterpreter) {
2657 if (!strncmp(option, "a", 1)) {
2660 } else
2661 gInterpreter->ResetGlobals();
2662
2663 if (fGlobals) fGlobals->Unload();
2665
2666 SaveContext();
2667 }
2668}
2669
2670////////////////////////////////////////////////////////////////////////////////
2671/// Save the current interpreter context.
2672
2674{
2675 if (fInterpreter)
2676 gInterpreter->SaveGlobalsContext();
2677}
2678
2679////////////////////////////////////////////////////////////////////////////////
2680/// Set the default graphical cut class name for the graphics editor
2681/// By default the graphics editor creates an instance of a class TCutG.
2682/// This function may be called to specify a different class that MUST
2683/// derive from TCutG
2684
2686{
2687 if (!name) {
2688 Error("SetCutClassName","Invalid class name");
2689 return;
2690 }
2692 if (!cl) {
2693 Error("SetCutClassName","Unknown class:%s",name);
2694 return;
2695 }
2696 if (!cl->InheritsFrom("TCutG")) {
2697 Error("SetCutClassName","Class:%s does not derive from TCutG",name);
2698 return;
2699 }
2701}
2702
2703////////////////////////////////////////////////////////////////////////////////
2704/// Set editor mode
2705
2707{
2708 fEditorMode = 0;
2709 if (!mode[0]) return;
2710 if (!strcmp(mode,"Arc")) {fEditorMode = kArc; return;}
2711 if (!strcmp(mode,"Line")) {fEditorMode = kLine; return;}
2712 if (!strcmp(mode,"Arrow")) {fEditorMode = kArrow; return;}
2713 if (!strcmp(mode,"Button")) {fEditorMode = kButton; return;}
2714 if (!strcmp(mode,"Diamond")) {fEditorMode = kDiamond; return;}
2715 if (!strcmp(mode,"Ellipse")) {fEditorMode = kEllipse; return;}
2716 if (!strcmp(mode,"Pad")) {fEditorMode = kPad; return;}
2717 if (!strcmp(mode,"Pave")) {fEditorMode = kPave; return;}
2718 if (!strcmp(mode,"PaveLabel")){fEditorMode = kPaveLabel; return;}
2719 if (!strcmp(mode,"PaveText")) {fEditorMode = kPaveText; return;}
2720 if (!strcmp(mode,"PavesText")){fEditorMode = kPavesText; return;}
2721 if (!strcmp(mode,"PolyLine")) {fEditorMode = kPolyLine; return;}
2722 if (!strcmp(mode,"CurlyLine")){fEditorMode = kCurlyLine; return;}
2723 if (!strcmp(mode,"CurlyArc")) {fEditorMode = kCurlyArc; return;}
2724 if (!strcmp(mode,"Text")) {fEditorMode = kText; return;}
2725 if (!strcmp(mode,"Marker")) {fEditorMode = kMarker; return;}
2726 if (!strcmp(mode,"CutG")) {fEditorMode = kCutG; return;}
2727}
2728
2729////////////////////////////////////////////////////////////////////////////////
2730/// Change current style to style with name stylename
2731
2733{
2735
2737 if (style) style->cd();
2738 else Error("SetStyle","Unknown style:%s",style_name.Data());
2739}
2740
2741
2742//-------- Static Member Functions ---------------------------------------------
2743
2744
2745////////////////////////////////////////////////////////////////////////////////
2746/// Decrease the indentation level for ls().
2747
2749{
2750 return --fgDirLevel;
2751}
2752
2753////////////////////////////////////////////////////////////////////////////////
2754///return directory level
2755
2757{
2758 return fgDirLevel;
2759}
2760
2761////////////////////////////////////////////////////////////////////////////////
2762/// Get macro search path. Static utility function.
2763
2765{
2767
2768 if (macroPath.Length() == 0) {
2769 macroPath = gEnv->GetValue("Root.MacroPath", (char*)nullptr);
2770#if defined(R__WIN32)
2771 macroPath.ReplaceAll("; ", ";");
2772#else
2773 macroPath.ReplaceAll(": ", ":");
2774#endif
2775 if (macroPath.Length() == 0)
2776#if !defined(R__WIN32)
2777 macroPath = ".:" + TROOT::GetMacroDir();
2778#else
2779 macroPath = ".;" + TROOT::GetMacroDir();
2780#endif
2781 }
2782
2783 return macroPath;
2784}
2785
2786////////////////////////////////////////////////////////////////////////////////
2787/// Set or extend the macro search path. Static utility function.
2788/// If newpath=0 or "" reset to value specified in the rootrc file.
2789
2791{
2793
2794 if (!newpath || !*newpath)
2795 macroPath = "";
2796 else
2798}
2799
2800////////////////////////////////////////////////////////////////////////////////
2801/// Set batch mode for ROOT
2802/// If the argument evaluates to `true`, the session does not use interactive graphics.
2803/// If web graphics runs in server mode, the web widgets are still available via URL
2804
2811
2812////////////////////////////////////////////////////////////////////////////////
2813/// \brief Specify where web graphics shall be rendered
2814///
2815/// The input parameter `webdisplay` defines where web graphics is rendered.
2816/// `webdisplay` parameter may contain:
2817///
2818/// - "firefox": select Mozilla Firefox browser for interactive web display
2819/// - "chrome": select Google Chrome browser for interactive web display. Can also be set to "chromium"
2820/// - "edge": select Microsoft Edge browser for interactive web display
2821/// - "native": select one of the natively-supported web browsers firefox/chrome/edge for interactive web display
2822/// - "qt6": uses QWebEngine from Qt6, no real http server started (requires `qt6web` component build for ROOT)
2823/// - "cef": uses Chromium Embeded Framework, no real http server started (requires `cefweb` component build for ROOT)
2824/// - "local": select one of available local (without http server) engines like qt6/cef
2825/// - "default": system default web browser, invoked with `xdg-open` on Linux, `start` on Mac or `open` on Windows
2826/// - "on": try "local", then "native", then "default" option
2827/// - "off": turns off the web display and comes back to normal graphics in
2828/// interactive mode.
2829/// - "server:port": turns the web display into server mode with specified port. Web widgets will not be displayed,
2830/// only text message with window URL will be printed on standard output
2831///
2832/// \note See more details related to webdisplay on RWebWindowsManager::ShowWindow
2833
2834void TROOT::SetWebDisplay(const char *webdisplay)
2835{
2836 const char *wd = webdisplay ? webdisplay : "";
2837
2838 // store default values to set them back when needed
2839 static TString canName = gEnv->GetValue("Canvas.Name", "");
2840 static TString brName = gEnv->GetValue("Browser.Name", "");
2841 static TString trName = gEnv->GetValue("TreeViewer.Name", "");
2842 static TString geomName = gEnv->GetValue("GeomPainter.Name", "");
2843
2845
2846 if (!strcmp(wd, "off")) {
2848 fWebDisplay = "off";
2849 } else {
2851
2852 // handle server mode
2853 if (!strncmp(wd, "server", 6)) {
2854 fWebDisplay = "server";
2856 if (wd[6] == ':') {
2857 if ((wd[7] >= '0') && (wd[7] <= '9')) {
2858 auto port = TString(wd+7).Atoi();
2859 if (port > 0)
2860 gEnv->SetValue("WebGui.HttpPort", port);
2861 else
2862 Error("SetWebDisplay", "Wrong port parameter %s for server", wd+7);
2863 } else if (wd[7]) {
2864 gEnv->SetValue("WebGui.UnixSocket", wd+7);
2865 }
2866 }
2867 } else {
2868 fWebDisplay = wd;
2869 }
2870 }
2871
2872 if (fIsWebDisplay) {
2873 // restore canvas and browser classes configured at the moment when gROOT->SetWebDisplay() was called for the first time
2874 // This is necessary when SetWebDisplay() called several times and therefore current settings may differ
2875 gEnv->SetValue("Canvas.Name", canName);
2876 gEnv->SetValue("Browser.Name", brName);
2877 gEnv->SetValue("TreeViewer.Name", trName);
2878 gEnv->SetValue("GeomPainter.Name", geomName);
2879 } else {
2880 gEnv->SetValue("Canvas.Name", "TRootCanvas");
2881 gEnv->SetValue("Browser.Name", "TRootBrowser");
2882 gEnv->SetValue("TreeViewer.Name", "TTreeViewer");
2883 gEnv->SetValue("GeomPainter.Name", "root");
2884 }
2885}
2886
2887////////////////////////////////////////////////////////////////////////////////
2888/// Increase the indentation level for ls().
2889
2891{
2892 return ++fgDirLevel;
2893}
2894
2895////////////////////////////////////////////////////////////////////////////////
2896/// Functions used by ls() to indent an object hierarchy.
2897
2899{
2900 for (int i = 0; i < fgDirLevel; i++) std::cout.put(' ');
2901}
2902
2903////////////////////////////////////////////////////////////////////////////////
2904/// Initialize ROOT explicitly.
2905
2907 (void) gROOT;
2908}
2909
2910////////////////////////////////////////////////////////////////////////////////
2911/// Return kTRUE if the TROOT object has been initialized.
2912
2914{
2915 return fgRootInit;
2916}
2917
2918////////////////////////////////////////////////////////////////////////////////
2919/// Return Indentation level for ls().
2920
2922{
2923 fgDirLevel = level;
2924}
2925
2926////////////////////////////////////////////////////////////////////////////////
2927/// Convert version code to an integer, i.e. 331527 -> 51507.
2928
2930{
2931 return 10000*(code>>16) + 100*((code&65280)>>8) + (code&255);
2932}
2933
2934////////////////////////////////////////////////////////////////////////////////
2935/// Convert version as an integer to version code as used in RVersion.h.
2936
2938{
2939 int a = v/10000;
2940 int b = (v - a*10000)/100;
2941 int c = v - a*10000 - b*100;
2942 return (a << 16) + (b << 8) + c;
2943}
2944
2945////////////////////////////////////////////////////////////////////////////////
2946/// Return ROOT version code as defined in RVersion.h.
2947
2952////////////////////////////////////////////////////////////////////////////////
2953/// Provide command line arguments to the interpreter construction.
2954/// These arguments are added to the existing flags (e.g. `-DNDEBUG`).
2955/// They are evaluated once per process, at the time where TROOT (and thus
2956/// TInterpreter) is constructed.
2957/// Returns the new flags.
2958
2959const std::vector<std::string> &TROOT::AddExtraInterpreterArgs(const std::vector<std::string> &args) {
2960 static std::vector<std::string> sArgs = {};
2961 sArgs.insert(sArgs.begin(), args.begin(), args.end());
2962 return sArgs;
2963}
2964
2965////////////////////////////////////////////////////////////////////////////////
2966/// INTERNAL function!
2967/// Used by rootcling to inject interpreter arguments through a C-interface layer.
2968
2970 static const char** extraInterpArgs = nullptr;
2971 return extraInterpArgs;
2972}
2973
2974////////////////////////////////////////////////////////////////////////////////
2975
2976#ifdef ROOTPREFIX
2977static Bool_t IgnorePrefix() {
2978 static Bool_t ignorePrefix = gSystem->Getenv("ROOTIGNOREPREFIX");
2979 return ignorePrefix;
2980}
2981#endif
2982
2983////////////////////////////////////////////////////////////////////////////////
2984/// Get the rootsys directory in the installation. Static utility function.
2985
2987 // Avoid returning a reference to a temporary because of the conversion
2988 // between std::string and TString.
2990 return rootsys;
2991}
2992
2993////////////////////////////////////////////////////////////////////////////////
2994/// Get the binary directory in the installation. Static utility function.
2995
2997#ifdef ROOTBINDIR
2998 if (IgnorePrefix()) {
2999#endif
3000 static TString rootbindir;
3001 if (rootbindir.IsNull()) {
3002 rootbindir = "bin";
3004 }
3005 return rootbindir;
3006#ifdef ROOTBINDIR
3007 } else {
3008 const static TString rootbindir = ROOTBINDIR;
3009 return rootbindir;
3010 }
3011#endif
3012}
3013
3014////////////////////////////////////////////////////////////////////////////////
3015/// Get the library directory in the installation. Static utility function.
3016///
3017/// This function inspects the libraries currently loaded in the process to
3018/// locate the ROOT Core library. Once found, it extracts and returns the
3019/// directory containing that library. If the ROOT Core library was not found,
3020/// it will return an empty string.
3021///
3022/// The result is cached in a static variable so the lookup is only performed
3023/// once per process, and the implementation is platform-specific.
3024///
3025/// \return The directory path (as a `TString`) containing the ROOT core library.
3026
3028{
3029 static bool haveLooked = false;
3030 static TString rootlibdir;
3031 if (haveLooked)
3032 return rootlibdir;
3033
3034 haveLooked = true;
3035
3036 namespace fs = std::filesystem;
3037
3038#define TO_LITERAL(string) _QUOTE_(string)
3039
3040#if defined(__APPLE__)
3041
3042 uint32_t count = _dyld_image_count();
3043 for (uint32_t i = 0; i < count; i++) {
3044 const char *path = _dyld_get_image_name(i);
3045 if (!path)
3046 continue;
3047
3048 fs::path p(path);
3049 if (p.filename() == TO_LITERAL(LIB_CORE_NAME)) {
3050 rootlibdir = p.parent_path().c_str();
3051 break;
3052 }
3053 }
3054
3055#elif defined(_WIN32)
3056
3057 // Or Windows, the original hardcoded path is kept for now.
3058 rootlibdir = "lib";
3060
3061#else
3062
3063 auto callback = +[](struct dl_phdr_info *info, size_t /*size*/, void *data) -> int {
3064 TString &libdir = *static_cast<TString *>(data);
3065 if (!info->dlpi_name)
3066 return 0;
3067
3068 fs::path p = info->dlpi_name;
3069 if (p.filename() == TO_LITERAL(LIB_CORE_NAME)) {
3070 libdir = p.parent_path().c_str();
3071 return 1; // stop iteration
3072 }
3073 return 0; // continue
3074 };
3075
3076 dl_iterate_phdr(callback, &rootlibdir);
3077
3078#endif
3079
3080 return rootlibdir;
3081}
3082
3083////////////////////////////////////////////////////////////////////////////////
3084/// Get the shared libraries directory in the installation. Static utility function.
3085
3087#if defined(R__WIN32)
3088 return TROOT::GetBinDir();
3089#else
3090 return TROOT::GetLibDir();
3091#endif
3092}
3093
3094////////////////////////////////////////////////////////////////////////////////
3095/// Get the include directory in the installation. Static utility function.
3096
3098 // Avoid returning a reference to a temporary because of the conversion
3099 // between std::string and TString.
3101 return includedir;
3102}
3103
3104////////////////////////////////////////////////////////////////////////////////
3105/// Get the sysconfig directory in the installation. Static utility function.
3106
3108 // Avoid returning a reference to a temporary because of the conversion
3109 // between std::string and TString.
3111 return etcdir;
3112}
3113
3114////////////////////////////////////////////////////////////////////////////////
3115/// Get the data directory in the installation. Static utility function.
3116
3118#ifdef ROOTDATADIR
3119 if (IgnorePrefix()) {
3120#endif
3121 return GetRootSys();
3122#ifdef ROOTDATADIR
3123 } else {
3124 const static TString rootdatadir = ROOTDATADIR;
3125 return rootdatadir;
3126 }
3127#endif
3128}
3129
3130////////////////////////////////////////////////////////////////////////////////
3131/// Get the documentation directory in the installation. Static utility function.
3132
3134#ifdef ROOTDOCDIR
3135 if (IgnorePrefix()) {
3136#endif
3137 return GetRootSys();
3138#ifdef ROOTDOCDIR
3139 } else {
3140 const static TString rootdocdir = ROOTDOCDIR;
3141 return rootdocdir;
3142 }
3143#endif
3144}
3145
3146////////////////////////////////////////////////////////////////////////////////
3147/// Get the macro directory in the installation. Static utility function.
3148
3150#ifdef ROOTMACRODIR
3151 if (IgnorePrefix()) {
3152#endif
3153 static TString rootmacrodir;
3154 if (rootmacrodir.IsNull()) {
3155 rootmacrodir = "macros";
3157 }
3158 return rootmacrodir;
3159#ifdef ROOTMACRODIR
3160 } else {
3161 const static TString rootmacrodir = ROOTMACRODIR;
3162 return rootmacrodir;
3163 }
3164#endif
3165}
3166
3167////////////////////////////////////////////////////////////////////////////////
3168/// Get the tutorials directory in the installation. Static utility function.
3169
3171#ifdef ROOTTUTDIR
3172 if (IgnorePrefix()) {
3173#endif
3174 static TString roottutdir;
3175 if (roottutdir.IsNull()) {
3176 roottutdir = "tutorials";
3178 }
3179 return roottutdir;
3180#ifdef ROOTTUTDIR
3181 } else {
3182 const static TString roottutdir = ROOTTUTDIR;
3183 return roottutdir;
3184 }
3185#endif
3186}
3187
3188////////////////////////////////////////////////////////////////////////////////
3189/// Shut down ROOT.
3190
3192{
3193 if (gROOT)
3194 gROOT->EndOfProcessCleanups();
3195 else if (gInterpreter)
3196 gInterpreter->ShutDown();
3197}
3198
3199////////////////////////////////////////////////////////////////////////////////
3200/// Get the source directory in the installation. Static utility function.
3201
3203#ifdef ROOTSRCDIR
3204 if (IgnorePrefix()) {
3205#endif
3206 static TString rootsrcdir;
3207 if (rootsrcdir.IsNull()) {
3208 rootsrcdir = "src";
3210 }
3211 return rootsrcdir;
3212#ifdef ROOTSRCDIR
3213 } else {
3214 const static TString rootsrcdir = ROOTSRCDIR;
3215 return rootsrcdir;
3216 }
3217#endif
3218}
3219
3220////////////////////////////////////////////////////////////////////////////////
3221/// Get the icon path in the installation. Static utility function.
3222
3224#ifdef ROOTICONPATH
3225 if (IgnorePrefix()) {
3226#endif
3227 static TString rooticonpath;
3228 if (rooticonpath.IsNull()) {
3229 rooticonpath = "icons";
3231 }
3232 return rooticonpath;
3233#ifdef ROOTICONPATH
3234 } else {
3235 const static TString rooticonpath = ROOTICONPATH;
3236 return rooticonpath;
3237 }
3238#endif
3239}
3240
3241////////////////////////////////////////////////////////////////////////////////
3242/// Get the fonts directory in the installation. Static utility function.
3243
3245#ifdef TTFFONTDIR
3246 if (IgnorePrefix()) {
3247#endif
3248 static TString ttffontdir;
3249 if (ttffontdir.IsNull()) {
3250 ttffontdir = "fonts";
3252 }
3253 return ttffontdir;
3254#ifdef TTFFONTDIR
3255 } else {
3256 const static TString ttffontdir = TTFFONTDIR;
3257 return ttffontdir;
3258 }
3259#endif
3260}
3261
3262////////////////////////////////////////////////////////////////////////////////
3263/// Get the tutorials directory in the installation. Static utility function.
3264/// Backward compatibility function - do not use for new code
3265
3267 return GetTutorialDir();
3268}
@ 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
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:2452
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:1906
#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:2522
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:5788
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:4901
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:2973
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:1172
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:490
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:735
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:342
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:181
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:188
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:467
Handle messages that might be generated by the system.
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:173
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition TNamed.cxx:149
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:1161
virtual const char * GetName() const
Returns name of object.
Definition TObject.cxx:457
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition TObject.cxx:226
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition TObject.cxx:1057
virtual TObject * FindObject(const char *name) const
Must be redefined in derived classes.
Definition TObject.cxx:421
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition TObject.cxx:864
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition TObject.cxx:1071
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition TObject.cxx:1099
@ 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:2890
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:1927
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:2350
void RemoveClass(TClass *)
Remove a class from the list and map of classes.
Definition TROOT.cxx:2630
TCollection * fClassGenerators
List of user defined class generators;.
Definition TROOT.h:168
TROOT()
Only used by Dictionary.
Definition TROOT.cxx:634
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:2685
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:1435
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:2834
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:1034
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:1247
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:2996
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:3097
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:1891
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:2250
static const char * GetMacroPath()
Get macro search path. Static utility function.
Definition TROOT.cxx:2764
TCollection * fFunctions
List of analytic functions.
Definition TROOT.h:159
void SaveContext()
Save the current interpreter context.
Definition TROOT.cxx:2673
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:1561
static void Initialize()
Initialize ROOT explicitly.
Definition TROOT.cxx:2906
static void ShutDown()
Shut down ROOT.
Definition TROOT.cxx:3191
TObject * GetFunction(const char *name) const
Return pointer to function with name.
Definition TROOT.cxx:1586
static Int_t ConvertVersionCode2Int(Int_t code)
Convert version code to an integer, i.e. 331527 -> 51507.
Definition TROOT.cxx:2929
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:2732
AListOfEnums_t fEnums
List of enum types.
Definition TROOT.h:172
void ReadGitInfo()
Read Git commit SHA1 and branch name.
Definition TROOT.cxx:2429
static Bool_t fgRootInit
Singleton initialization flag.
Definition TROOT.h:111
void RefreshBrowsers()
Refresh all browsers.
Definition TROOT.cxx:2512
void CloseFiles()
Close any files and sockets that gROOT knows about.
Definition TROOT.cxx:1167
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:1472
static Int_t ConvertVersionInt2Code(Int_t v)
Convert version as an integer to version code as used in RVersion.h.
Definition TROOT.cxx:2937
void ResetClassSaved()
Reset the ClassSaved status of all classes.
Definition TROOT.cxx:1095
static const TString & GetTTFFontDir()
Get the fonts directory in the installation. Static utility function.
Definition TROOT.cxx:3244
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:1553
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:1535
TGlobal * GetGlobal(const char *name, Bool_t load=kFALSE) const
Return pointer to global variable by name.
Definition TROOT.cxx:1630
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:1483
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:1046
static const TString & GetIconPath()
Get the icon path in the installation. Static utility function.
Definition TROOT.cxx:3223
TCollection * GetListOfGlobalFunctions(Bool_t load=kFALSE)
Return list containing the TFunctions currently defined.
Definition TROOT.cxx:1825
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:1770
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:2537
TObject * FindObject(const char *name) const override
Returns address of a ROOT object if it exists.
Definition TROOT.cxx:1312
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:1578
TCollection * GetListOfEnums(Bool_t load=kFALSE)
Definition TROOT.cxx:1753
Longptr_t ProcessLineSync(const char *line, Int_t *error=nullptr)
Process interpreter command via TApplication::ProcessLine().
Definition TROOT.cxx:2390
void InitInterpreter()
Initialize interpreter (cling)
Definition TROOT.cxx:2064
TCollection * GetListOfGlobals(Bool_t load=kFALSE)
Return list containing the TGlobals currently defined.
Definition TROOT.cxx:1787
static void SetDirLevel(Int_t level=0)
Return Indentation level for ls().
Definition TROOT.cxx:2921
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:3266
TCollection * GetListOfFunctionOverloads(const char *name) const
Return the collection of functions named "name".
Definition TROOT.cxx:1671
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:2913
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:2805
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:3202
static const TString & GetMacroDir()
Get the macro directory in the installation. Static utility function.
Definition TROOT.cxx:3149
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:2370
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:2474
void SetEditorMode(const char *mode="")
Set editor mode.
Definition TROOT.cxx:2706
static const TString & GetTutorialDir()
Get the tutorials directory in the installation. Static utility function.
Definition TROOT.cxx:3170
virtual ~TROOT()
Clean up and free resources used by ROOT (files, network sockets, shared memory segments,...
Definition TROOT.cxx:868
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:1717
TSeqCollection * GetListOfBrowsers() const
Definition TROOT.h:252
Bool_t ReadingObject() const
Deprecated (will be removed in next release).
Definition TROOT.cxx:2460
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:2316
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:2959
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:1517
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:1055
static const TString & GetRootSys()
Get the rootsys directory in the installation. Static utility function.
Definition TROOT.cxx:2986
TListOfFunctions * GetGlobalFunctions()
Internal routine returning, and creating if necessary, the list of global function.
Definition TROOT.cxx:1662
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:2183
TFunction * GetGlobalFunction(const char *name, const char *params=nullptr, Bool_t load=kFALSE)
Return pointer to global function by name.
Definition TROOT.cxx:1684
void AddClass(TClass *cl)
Add a class to the list and map of classes.
Definition TROOT.cxx:1024
static Int_t RootVersionCode()
Return ROOT version code as defined in RVersion.h.
Definition TROOT.cxx:2948
TObject * FindSpecialObject(const char *name, void *&where)
Returns address and folder of a ROOT object if it exists.
Definition TROOT.cxx:1366
TObject * Remove(TObject *) override
Remove an object from the in-memory list.
Definition TROOT.cxx:2620
void InitSystem()
Operating System interface.
Definition TROOT.cxx:1977
Longptr_t ProcessLineFast(const char *line, Int_t *error=nullptr)
Process interpreter command directly via CINT interpreter.
Definition TROOT.cxx:2407
Bool_t ClassSaved(TClass *cl)
return class status 'ClassSaved' for class cl This function is called by the SavePrimitive functions ...
Definition TROOT.cxx:1082
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:1864
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:2230
static void IndentLevel()
Functions used by ls() to indent an object hierarchy.
Definition TROOT.cxx:2898
static const TString & GetDocDir()
Get the documentation directory in the installation. Static utility function.
Definition TROOT.cxx:3133
static const TString & GetEtcDir()
Get the sysconfig directory in the installation. Static utility function.
Definition TROOT.cxx:3107
Int_t GetNclasses() const
Get number of classes.
Definition TROOT.cxx:1875
static const char **& GetExtraInterpreterArgs()
INTERNAL function! Used by rootcling to inject interpreter arguments through a C-interface layer.
Definition TROOT.cxx:2969
static void SetMacroPath(const char *newpath)
Set or extend the macro search path.
Definition TROOT.cxx:2790
void InitThreads()
Initialize threads library.
Definition TROOT.cxx:2052
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:1617
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:1746
void RecursiveRemove(TObject *obj) override
Recursively remove this object from the list of Cleanups.
Definition TROOT.cxx:2498
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:3086
TSeqCollection * fMappedFiles
List of memory mapped files.
Definition TROOT.h:155
Int_t GetNtypes() const
Get number of types.
Definition TROOT.cxx:1883
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:2268
TFile * GetFile() const override
Definition TROOT.h:266
static const TString & GetLibDir()
Get the library directory in the installation.
Definition TROOT.cxx:3027
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:1425
static Int_t DecreaseDirLevel()
Decrease the indentation level for ls().
Definition TROOT.cxx:2748
void Reset(Option_t *option="")
Delete all global interpreter objects created since the last call to Reset.
Definition TROOT.cxx:2653
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:1452
static const TString & GetDataDir()
Get the data directory in the installation. Static utility function.
Definition TROOT.cxx:3117
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:2756
void SetReadingObject(Bool_t flag=kTRUE)
Definition TROOT.cxx:2465
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:365
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:1994
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:2362
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:524
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:2055
virtual const char * Getenv(const char *env)
Get environment variable.
Definition TSystem.cxx:1676
virtual TString SplitAclicMode(const char *filename, TString &mode, TString &args, TString &io) const
This method split a filename of the form:
Definition TSystem.cxx:4282
virtual void CleanCompiledMacros()
Remove the shared libs produced by the CompileMacro() function, together with their rootmaps,...
Definition TSystem.cxx:4396
virtual int Load(const char *module, const char *entry="", Bool_t system=kFALSE)
Load a shared library.
Definition TSystem.cxx:1868
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:1409
virtual const char * PrependPathName(const char *dir, TString &name)
Concatenate a directory and a file name.
Definition TSystem.cxx:1092
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:1307
virtual Bool_t Init()
Initialize the OS interface.
Definition TSystem.cxx:181
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
Definition TSystem.cxx:944
virtual const char * WorkingDirectory()
Return working directory.
Definition TSystem.cxx:881
virtual char * Which(const char *search, const char *file, EAccessMode mode=kFileExists)
Find location of file in a search path.
Definition TSystem.cxx:1559
virtual const char * HomeDirectory(const char *userName=nullptr)
Return the user's home directory.
Definition TSystem.cxx:897
virtual const char * GetError()
Return system error string.
Definition TSystem.cxx:252
virtual void ResetSignals()
Reset signals handlers to previous behaviour.
Definition TSystem.cxx:582
char * DynamicPathName(const char *lib, Bool_t quiet=kFALSE)
Find a dynamic library called lib using the system search paths.
Definition TSystem.cxx:2031
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:56
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.
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