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 <string>
75#include <map>
76#include <set>
77#include <cstdlib>
78#ifdef WIN32
79#include <io.h>
80#include "Windows4Root.h"
81#include <Psapi.h>
82#define RTLD_DEFAULT ((void *)::GetModuleHandle(NULL))
83//#define dlsym(library, function_name) ::GetProcAddress((HMODULE)library, function_name)
84#define dlopen(library_name, flags) ::LoadLibrary(library_name)
85#define dlclose(library) ::FreeLibrary((HMODULE)library)
86char *dlerror() {
87 static char Msg[1000];
90 sizeof(Msg), NULL);
91 return Msg;
92}
93FARPROC dlsym(void *library, const char *function_name)
94{
95 HMODULE hMods[1024];
96 DWORD cbNeeded;
97 FARPROC address = NULL;
98 unsigned int i;
99 if (library == RTLD_DEFAULT) {
101 for (i = 0; i < (cbNeeded / sizeof(HMODULE)); i++) {
103 if (address)
104 return address;
105 }
106 }
107 return address;
108 } else {
109 return ::GetProcAddress((HMODULE)library, function_name);
110 }
111}
112#else
113#include <dlfcn.h>
114#endif
115
116#include <iostream>
118#include "TROOT.h"
119#include "TClass.h"
120#include "TClassEdit.h"
121#include "TClassGenerator.h"
122#include "TDataType.h"
123#include "TStyle.h"
124#include "TObjectTable.h"
125#include "TClassTable.h"
126#include "TSystem.h"
127#include "THashList.h"
128#include "TObjArray.h"
129#include "TEnv.h"
130#include "TError.h"
131#include "TColor.h"
132#include "TGlobal.h"
133#include "TFunction.h"
134#include "TVirtualPad.h"
135#include "TBrowser.h"
136#include "TSystemDirectory.h"
137#include "TApplication.h"
138#include "TInterpreter.h"
139#include "TGuiFactory.h"
140#include "TMessageHandler.h"
141#include "TFolder.h"
142#include "TQObject.h"
143#include "TProcessUUID.h"
144#include "TPluginManager.h"
145#include "TVirtualMutex.h"
146#include "TListOfTypes.h"
147#include "TListOfDataMembers.h"
148#include "TListOfEnumsWithLock.h"
149#include "TListOfFunctions.h"
151#include "TFunctionTemplate.h"
152#include "ThreadLocalStorage.h"
153#include "TVirtualMapFile.h"
154#include "TVirtualRWMutex.h"
155#include "TVirtualX.h"
156
157#if defined(R__UNIX)
158#if defined(R__HAS_COCOA)
159#include "TMacOSXSystem.h"
160#include "TUrl.h"
161#else
162#include "TUnixSystem.h"
163#endif
164#elif defined(R__WIN32)
165#include "TWinNTSystem.h"
166#endif
167
168extern "C" void R__SetZipMode(int);
169
171static void *gInterpreterLib = nullptr;
172
173// Mutex for protection of concurrent gROOT access
176
177// For accessing TThread::Tsd indirectly.
178void **(*gThreadTsd)(void*,Int_t) = nullptr;
179
180//-------- Names of next three routines are a small homage to CMZ --------------
181////////////////////////////////////////////////////////////////////////////////
182/// Return version id as an integer, i.e. "2.22/04" -> 22204.
183
184static Int_t IVERSQ()
185{
186 Int_t maj, min, cycle;
187 sscanf(ROOT_RELEASE, "%d.%d.%d", &maj, &min, &cycle);
188 return 10000*maj + 100*min + cycle;
189}
190
191////////////////////////////////////////////////////////////////////////////////
192/// Return built date as integer, i.e. "Apr 28 2000" -> 20000428.
193
194static Int_t IDATQQ(const char *date)
195{
196 if (!date) {
197 Error("TSystem::IDATQQ", "nullptr date string, expected e.g. 'Dec 21 2022'");
198 return -1;
199 }
200
201 static const char *months[] = {"Jan","Feb","Mar","Apr","May",
202 "Jun","Jul","Aug","Sep","Oct",
203 "Nov","Dec"};
204 char sm[12];
205 Int_t yy, mm=0, dd;
206 if (sscanf(date, "%s %d %d", sm, &dd, &yy) != 3) {
207 Error("TSystem::IDATQQ", "Cannot parse date string '%s', expected e.g. 'Dec 21 2022'", date);
208 return -1;
209 }
210 for (int i = 0; i < 12; i++)
211 if (!strncmp(sm, months[i], 3)) {
212 mm = i+1;
213 break;
214 }
215 return 10000*yy + 100*mm + dd;
216}
217
218////////////////////////////////////////////////////////////////////////////////
219/// Return built time as integer (with min precision), i.e.
220/// "17:32:37" -> 1732.
221
222static Int_t ITIMQQ(const char *time)
223{
224 Int_t hh, mm, ss;
225 sscanf(time, "%d:%d:%d", &hh, &mm, &ss);
226 return 100*hh + mm;
227}
228
229////////////////////////////////////////////////////////////////////////////////
230/// Clean up at program termination before global objects go out of scope.
231
232static void CleanUpROOTAtExit()
233{
234 if (gROOT) {
236
237 if (gROOT->GetListOfFiles())
238 gROOT->GetListOfFiles()->Delete("slow");
239 if (gROOT->GetListOfSockets())
240 gROOT->GetListOfSockets()->Delete();
241 if (gROOT->GetListOfMappedFiles())
242 gROOT->GetListOfMappedFiles()->Delete("slow");
243 if (gROOT->GetListOfClosedObjects())
244 gROOT->GetListOfClosedObjects()->Delete("slow");
245 }
246}
247
248////////////////////////////////////////////////////////////////////////////////
249/// A module and its headers. Intentionally not a copy:
250/// If these strings end up in this struct they are
251/// long lived by definition because they get passed in
252/// before initialization of TCling.
253
254namespace {
255 struct ModuleHeaderInfo_t {
256 ModuleHeaderInfo_t(const char* moduleName,
257 const char** headers,
258 const char** includePaths,
259 const char* payloadCode,
260 const char* fwdDeclCode,
261 void (*triggerFunc)(),
263 const char **classesHeaders,
264 bool hasCxxModule):
265 fModuleName(moduleName),
266 fHeaders(headers),
267 fPayloadCode(payloadCode),
268 fFwdDeclCode(fwdDeclCode),
269 fIncludePaths(includePaths),
270 fTriggerFunc(triggerFunc),
271 fClassesHeaders(classesHeaders),
272 fFwdNargsToKeepColl(fwdDeclsArgToSkip),
273 fHasCxxModule(hasCxxModule) {}
274
275 const char* fModuleName; // module name
276 const char** fHeaders; // 0-terminated array of header files
277 const char* fPayloadCode; // Additional code to be given to cling at library load
278 const char* fFwdDeclCode; // Additional code to let cling know about selected classes and functions
279 const char** fIncludePaths; // 0-terminated array of header files
280 void (*fTriggerFunc)(); // Pointer to the dict initialization used to find the library name
281 const char** fClassesHeaders; // 0-terminated list of classes and related header files
282 const TROOT::FwdDeclArgsToKeepCollection_t fFwdNargsToKeepColl; // Collection of
283 // pairs of template fwd decls and number of
284 bool fHasCxxModule; // Whether this module has a C++ module alongside it.
285 };
286
287 std::vector<ModuleHeaderInfo_t>& GetModuleHeaderInfoBuffer() {
288 static std::vector<ModuleHeaderInfo_t> moduleHeaderInfoBuffer;
290 }
291}
292
295
300
301// This local static object initializes the ROOT system
302namespace ROOT {
303namespace Internal {
305 // Simple wrapper to separate, time-wise, the call to the
306 // TROOT destructor and the actual free-ing of the memory.
307 //
308 // Since the interpreter implementation (currently TCling) is
309 // loaded via dlopen by libCore, the destruction of its global
310 // variable (i.e. in particular clang's) is scheduled before
311 // those in libCore so we need to schedule the call to the TROOT
312 // destructor before that *but* we want to make sure the memory
313 // stay around until libCore itself is unloaded so that code
314 // using gROOT can 'properly' check for validity.
315 //
316 // The order of loading for is:
317 // libCore.so
318 // libRint.so
319 // ... anything other library hard linked to the executable ...
320 // ... for example libEvent
321 // libCling.so
322 // ... other libraries like libTree for example ....
323 // and the destruction order is (of course) the reverse.
324 // By default the unloading of the dictionary, does use
325 // the service of the interpreter ... which of course
326 // fails if libCling is already unloaded by that information
327 // has not been registered per se.
328 //
329 // To solve this problem, we now schedule the destruction
330 // of the TROOT object to happen _just_ before the
331 // unloading/destruction of libCling so that we can
332 // maximize the amount of clean-up we can do correctly
333 // and we can still allocate the TROOT object's memory
334 // statically.
335 //
336 union {
338 char fHolder[sizeof(TROOT)];
339 };
340 public:
341 TROOTAllocator(): fObj("root", "The ROOT of EVERYTHING")
342 {}
343
345 if (gROOTLocal) {
347 }
348 }
349 };
350
351 // The global gROOT is defined to be a function (ROOT::GetROOT())
352 // which itself is dereferencing a function pointer.
353
354 // Initially this function pointer's value is & GetROOT1 whose role is to
355 // create and initialize the TROOT object itself.
356 // At the very end of the TROOT constructor the value of the function pointer
357 // is switch to & GetROOT2 whose role is to initialize the interpreter.
358
359 // This mechanism was primarily intended to fix the issues with order in which
360 // global TROOT and LLVM globals are initialized. TROOT was initializing
361 // Cling, but Cling could not be used yet due to LLVM globals not being
362 // Initialized yet. The solution is to delay initializing the interpreter in
363 // TROOT till after main() when all LLVM globals are initialized.
364
365 // Technically, the mechanism used actually delay the interpreter
366 // initialization until the first use of gROOT *after* the end of the
367 // TROOT constructor.
368
369 // So to delay until after the start of main, we also made sure that none
370 // of the ROOT code (mostly the dictionary code) used during library loading
371 // is using gROOT (directly or indirectly).
372
373 // In practice, the initialization of the interpreter is now delayed until
374 // the first use gROOT (or gInterpreter) after the start of main (but user
375 // could easily break this by using gROOT in their library initialization
376 // code).
377
378 extern TROOT *gROOTLocal;
379
381 if (gROOTLocal)
382 return gROOTLocal;
383 static TROOTAllocator alloc;
384 return gROOTLocal;
385 }
386
389 if (!initInterpreter) {
392 // Load and init threads library
394 }
395 return gROOTLocal;
396 }
397 typedef TROOT *(*GetROOTFun_t)();
398
400
401 static Func_t GetSymInLibImt(const char *funcname)
402 {
403 const static bool loadSuccess = dlsym(RTLD_DEFAULT, "usedToIdentifyRootClingByDlSym")? false : 0 <= gSystem->Load("libImt");
404 if (loadSuccess) {
405 if (auto sym = gSystem->DynFindSymbol(nullptr, funcname)) {
406 return sym;
407 } else {
408 Error("GetSymInLibImt", "Cannot get symbol %s.", funcname);
409 }
410 }
411 return nullptr;
412 }
413
414 //////////////////////////////////////////////////////////////////////////////
415 /// Globally enables the parallel branch processing, which is a case of
416 /// implicit multi-threading (IMT) in ROOT, activating the required locks.
417 /// This IMT use case, implemented in TTree::GetEntry, spawns a task for
418 /// each branch of the tree. Therefore, a task takes care of the reading,
419 /// decompression and deserialisation of a given branch.
421 {
422#ifdef R__USE_IMT
423 static void (*sym)() = (void(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_EnableParBranchProcessing");
424 if (sym)
425 sym();
426#else
427 ::Warning("EnableParBranchProcessing", "Cannot enable parallel branch processing, please build ROOT with -Dimt=ON");
428#endif
429 }
430
431 //////////////////////////////////////////////////////////////////////////////
432 /// Globally disables the IMT use case of parallel branch processing,
433 /// deactivating the corresponding locks.
435 {
436#ifdef R__USE_IMT
437 static void (*sym)() = (void(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_DisableParBranchProcessing");
438 if (sym)
439 sym();
440#else
441 ::Warning("DisableParBranchProcessing", "Cannot disable parallel branch processing, please build ROOT with -Dimt=ON");
442#endif
443 }
444
445 //////////////////////////////////////////////////////////////////////////////
446 /// Returns true if parallel branch processing is enabled.
448 {
449#ifdef R__USE_IMT
450 static Bool_t (*sym)() = (Bool_t(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_IsParBranchProcessingEnabled");
451 if (sym)
452 return sym();
453 else
454 return kFALSE;
455#else
456 return kFALSE;
457#endif
458 }
459
460 ////////////////////////////////////////////////////////////////////////////////
461 /// Keeps track of the status of ImplicitMT w/o resorting to the load of
462 /// libImt
468
469} // end of Internal sub namespace
470// back to ROOT namespace
471
473 return (*Internal::gGetROOT)();
474 }
475
477 static TString macroPath;
478 return macroPath;
479 }
480
481 // clang-format off
482 ////////////////////////////////////////////////////////////////////////////////
483 /// Enables the global mutex to make ROOT thread safe/aware.
484 ///
485 /// The following becomes safe:
486 /// - concurrent construction and destruction of TObjects, including the ones registered in ROOT's global lists (e.g. gROOT->GetListOfCleanups(), gROOT->GetListOfFiles())
487 /// - 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)
488 /// - concurrent calls to ROOT's type system classes, e.g. TClass and TEnum
489 /// - concurrent calls to the interpreter through gInterpreter
490 /// - concurrent loading of ROOT plug-ins
491 ///
492 /// In addition, gDirectory, gFile and gPad become a thread-local variable.
493 /// In all threads, gDirectory defaults to gROOT, a singleton which supports thread-safe insertion and deletion of contents.
494 /// gFile and gPad default to nullptr, as it is for single-thread programs.
495 ///
496 /// The ROOT graphics subsystem is not made thread-safe by this method. In particular drawing or printing different
497 /// canvases from different threads (and analogous operations such as invoking `Draw` on a `TObject`) is not thread-safe.
498 ///
499 /// Note that there is no `DisableThreadSafety()`. ROOT's thread-safety features cannot be disabled once activated.
500 // clang-format on
502 {
503 static void (*sym)() = (void(*)())Internal::GetSymInLibImt("ROOT_TThread_Initialize");
504 if (sym)
505 sym();
506 }
507
508 ////////////////////////////////////////////////////////////////////////////////
509 /// @param[in] numthreads Number of threads to use. If not specified or
510 /// set to zero, the number of threads is automatically
511 /// decided by the implementation. Any other value is
512 /// used as a hint.
513 ///
514 /// ROOT must be built with the compilation flag `imt=ON` for this feature to be available.
515 /// The following objects and methods automatically take advantage of
516 /// multi-threading if a call to `EnableImplicitMT` has been made before usage:
517 ///
518 /// - RDataFrame internally runs the event-loop by parallelizing over clusters of entries
519 /// - TTree::GetEntry reads multiple branches in parallel
520 /// - TTree::FlushBaskets writes multiple baskets to disk in parallel
521 /// - TTreeCacheUnzip decompresses the baskets contained in a TTreeCache in parallel
522 /// - THx::Fit performs in parallel the evaluation of the objective function over the data
523 /// - TMVA::DNN trains the deep neural networks in parallel
524 /// - TMVA::BDT trains the classifier in parallel and multiclass BDTs are evaluated in parallel
525 ///
526 /// EnableImplicitMT calls in turn EnableThreadSafety.
527 /// The 'numthreads' parameter allows to control the number of threads to
528 /// be used by the implicit multi-threading. However, this parameter is just
529 /// a hint for ROOT: it will try to satisfy the request if the execution
530 /// scenario allows it. For example, if ROOT is configured to use an external
531 /// scheduler, setting a value for 'numthreads' might not have any effect.
532 /// The maximum number of threads can be influenced by the environment
533 /// variable `ROOT_MAX_THREADS`: `export ROOT_MAX_THREADS=2` will try to set
534 /// the maximum number of active threads to 2, if the scheduling library
535 /// (such as tbb) "permits".
536 ///
537 /// \note Use `DisableImplicitMT()` to disable multi-threading (some locks will remain in place as
538 /// described in EnableThreadSafety()). `EnableImplicitMT(1)` creates a thread-pool of size 1.
540 {
541#ifdef R__USE_IMT
543 return;
545 static void (*sym)(UInt_t) = (void(*)(UInt_t))Internal::GetSymInLibImt("ROOT_TImplicitMT_EnableImplicitMT");
546 if (sym)
547 sym(numthreads);
549#else
550 ::Warning("EnableImplicitMT", "Cannot enable implicit multi-threading with %d threads, please build ROOT with -Dimt=ON", numthreads);
551#endif
552 }
553
554 ////////////////////////////////////////////////////////////////////////////////
555 /// @param[in] config Configuration to use. The default is kWholeMachine, which
556 /// will create a thread pool that spans the whole machine.
557 ///
558 /// EnableImplicitMT calls in turn EnableThreadSafety.
559 /// If ImplicitMT is already enabled, this function does nothing.
560
562 {
563#ifdef R__USE_IMT
565 return;
567 static void (*sym)(ROOT::EIMTConfig) =
568 (void (*)(ROOT::EIMTConfig))Internal::GetSymInLibImt("ROOT_TImplicitMT_EnableImplicitMT_Config");
569 if (sym)
570 sym(config);
572#else
573 ::Warning("EnableImplicitMT",
574 "Cannot enable implicit multi-threading with config %d, please build ROOT with -Dimt=ON",
575 static_cast<int>(config));
576#endif
577 }
578
579 ////////////////////////////////////////////////////////////////////////////////
580 /// Disables the implicit multi-threading in ROOT (see EnableImplicitMT).
582 {
583#ifdef R__USE_IMT
584 static void (*sym)() = (void(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_DisableImplicitMT");
585 if (sym)
586 sym();
588#else
589 ::Warning("DisableImplicitMT", "Cannot disable implicit multi-threading, please build ROOT with -Dimt=ON");
590#endif
591 }
592
593 ////////////////////////////////////////////////////////////////////////////////
594 /// Returns true if the implicit multi-threading in ROOT is enabled.
599
600 ////////////////////////////////////////////////////////////////////////////////
601 /// Returns the size of ROOT's thread pool
603 {
604#ifdef R__USE_IMT
605 static UInt_t (*sym)() = (UInt_t(*)())Internal::GetSymInLibImt("ROOT_MT_GetThreadPoolSize");
606 if (sym)
607 return sym();
608 else
609 return 0;
610#else
611 return 0;
612#endif
613 }
614} // end of ROOT namespace
615
617
618// Global debug flag (set to > 0 to get debug output).
619// Can be set either via the interpreter (gDebug is exported to CINT),
620// via the rootrc resource "Root.Debug", via the shell environment variable
621// ROOTDEBUG, or via the debugger.
623
624
626
627////////////////////////////////////////////////////////////////////////////////
628/// Default ctor.
629
631
632////////////////////////////////////////////////////////////////////////////////
633/// Initialize the ROOT system. The creation of the TROOT object initializes
634/// the ROOT system. It must be the first ROOT related action that is
635/// performed by a program. The TROOT object must be created on the stack
636/// (can not be called via new since "operator new" is protected). The
637/// TROOT object is either created as a global object (outside the main()
638/// program), or it is one of the first objects created in main().
639/// Make sure that the TROOT object stays in scope for as long as ROOT
640/// related actions are performed. TROOT is a so called singleton so
641/// only one instance of it can be created. The single TROOT object can
642/// always be accessed via the global pointer gROOT.
643/// The name and title arguments can be used to identify the running
644/// application. The initfunc argument can contain an array of
645/// function pointers (last element must be 0). These functions are
646/// executed at the end of the constructor. This way one can easily
647/// extend the ROOT system without adding permanent dependencies
648/// (e.g. the graphics system is initialized via such a function).
649
650TROOT::TROOT(const char *name, const char *title, VoidFuncPtr_t *initfunc) : TDirectory()
651{
653 //Warning("TROOT", "only one instance of TROOT allowed");
654 return;
655 }
656
658
660 gDirectory = nullptr;
661
662 SetName(name);
663 SetTitle(title);
664
665 // will be used by global "operator delete" so make sure it is set
666 // before anything is deleted
667 fMappedFiles = nullptr;
668
669 // create already here, but only initialize it after gEnv has been created
671
672 // Initialize Operating System interface
673 InitSystem();
674
675 // Initialize static directory functions
676 GetRootSys();
677 GetBinDir();
678 GetLibDir();
680 GetEtcDir();
681 GetDataDir();
682 GetDocDir();
683 GetMacroDir();
685 GetSourceDir();
686 GetIconPath();
688
689 gRootDir = GetRootSys().Data();
690
691 TDirectory::BuildDirectory(nullptr, nullptr);
692
693 // Initialize interface to CINT C++ interpreter
694 fVersionInt = 0; // check in TROOT dtor in case TCling fails
695 fClasses = nullptr; // might be checked via TCling ctor
696 fEnums = nullptr;
697
707
708 ReadGitInfo();
709
710 fClasses = new THashTable(800,3); fClasses->UseRWLock();
711 //fIdMap = new IdMap_t;
714
715 // usedToIdentifyRootClingByDlSym is available when TROOT is part of
716 // rootcling.
717 if (!dlsym(RTLD_DEFAULT, "usedToIdentifyRootClingByDlSym")) {
718 // initialize plugin manager early
720 }
721
723
724 auto setNameLocked = [](TSeqCollection *l, const char *collection_name) {
725 l->SetName(collection_name);
726 l->UseRWLock();
727 return l;
728 };
729
730 fTimer = 0;
731 fApplication = nullptr;
732 fColors = setNameLocked(new TObjArray(1000), "ListOfColors");
733 fColors->SetOwner();
734 fTypes = nullptr;
735 fGlobals = nullptr;
736 fGlobalFunctions = nullptr;
737 // fList was created in TDirectory::Build but with different sizing.
738 delete fList;
739 fList = new THashList(1000,3); fList->UseRWLock();
740 fClosedObjects = setNameLocked(new TList, "ClosedFiles");
741 fFiles = setNameLocked(new TList, "Files");
742 fMappedFiles = setNameLocked(new TList, "MappedFiles");
743 fSockets = setNameLocked(new TList, "Sockets");
744 fCanvases = setNameLocked(new TList, "Canvases");
745 fStyles = setNameLocked(new TList, "Styles");
746 fFunctions = setNameLocked(new TList, "Functions");
747 fTasks = setNameLocked(new TList, "Tasks");
748 fGeometries = setNameLocked(new TList, "Geometries");
749 fBrowsers = setNameLocked(new TList, "Browsers");
750 fSpecials = setNameLocked(new TList, "Specials");
751 fBrowsables = (TList*)setNameLocked(new TList, "Browsables");
752 fCleanups = setNameLocked(new THashList, "Cleanups");
753 fMessageHandlers = setNameLocked(new TList, "MessageHandlers");
754 fSecContexts = setNameLocked(new TList, "SecContexts");
755 fProofs = setNameLocked(new TList, "Proofs");
756 fClipboard = setNameLocked(new TList, "Clipboard");
757 fDataSets = setNameLocked(new TList, "DataSets");
759
761 fUUIDs = new TProcessUUID();
762
763 fRootFolder = new TFolder();
764 fRootFolder->SetName("root");
765 fRootFolder->SetTitle("root of all folders");
766 fRootFolder->AddFolder("Classes", "List of Active Classes",fClasses);
767 fRootFolder->AddFolder("Colors", "List of Active Colors",fColors);
768 fRootFolder->AddFolder("MapFiles", "List of MapFiles",fMappedFiles);
769 fRootFolder->AddFolder("Sockets", "List of Socket Connections",fSockets);
770 fRootFolder->AddFolder("Canvases", "List of Canvases",fCanvases);
771 fRootFolder->AddFolder("Styles", "List of Styles",fStyles);
772 fRootFolder->AddFolder("Functions", "List of Functions",fFunctions);
773 fRootFolder->AddFolder("Tasks", "List of Tasks",fTasks);
774 fRootFolder->AddFolder("Geometries","List of Geometries",fGeometries);
775 fRootFolder->AddFolder("Browsers", "List of Browsers",fBrowsers);
776 fRootFolder->AddFolder("Specials", "List of Special Objects",fSpecials);
777 fRootFolder->AddFolder("Handlers", "List of Message Handlers",fMessageHandlers);
778 fRootFolder->AddFolder("Cleanups", "List of RecursiveRemove Collections",fCleanups);
779 fRootFolder->AddFolder("StreamerInfo","List of Active StreamerInfo Classes",fStreamerInfo);
780 fRootFolder->AddFolder("SecContexts","List of Security Contexts",fSecContexts);
781 fRootFolder->AddFolder("PROOF Sessions", "List of PROOF sessions",fProofs);
782 fRootFolder->AddFolder("ROOT Memory","List of Objects in the gROOT Directory",fList);
783 fRootFolder->AddFolder("ROOT Files","List of Connected ROOT Files",fFiles);
784
785 // by default, add the list of files, tasks, canvases and browsers in the Cleanups list
791 // And add TROOT's TDirectory personality
793
798 fEscape = kFALSE;
800 fPrimitive = nullptr;
801 fSelectPad = nullptr;
802 fEditorMode = 0;
803 fDefCanvasName = "c1";
805 fLineIsProcessing = 1; // This prevents WIN32 "Windows" thread to pick ROOT objects with mouse
806 gDirectory = this;
807 gPad = nullptr;
808
809 //set name of graphical cut class for the graphics editor
810 //cannot call SetCutClassName at this point because the TClass of TCutG
811 //is not yet build
812 fCutClassName = "TCutG";
813
814 // Create a default MessageHandler
815 new TMessageHandler((TClass*)nullptr);
816
817 // Create some styles
818 gStyle = nullptr;
820 SetStyle(gEnv->GetValue("Canvas.Style", "Modern"));
821
822 // Setup default (batch) graphics and GUI environment
825 gGXBatch = new TVirtualX("Batch", "ROOT Interface to batch graphics");
827
828#if defined(R__WIN32)
829 fBatch = kFALSE;
830#elif defined(R__HAS_COCOA)
831 fBatch = kFALSE;
832#else
833 if (gSystem->Getenv("DISPLAY"))
834 fBatch = kFALSE;
835 else
836 fBatch = kTRUE;
837#endif
838
839 const char *webdisplay = gSystem->Getenv("ROOT_WEBDISPLAY");
840 if (!webdisplay || !*webdisplay)
841 webdisplay = gEnv->GetValue("WebGui.Display", "");
842 if (webdisplay && *webdisplay)
843 SetWebDisplay(webdisplay);
844
845 int i = 0;
846 while (initfunc && initfunc[i]) {
847 (initfunc[i])();
848 fBatch = kFALSE; // put system in graphics mode (backward compatible)
849 i++;
850 }
851
852 // Set initial/default list of browsable objects
853 fBrowsables->Add(fRootFolder, "root");
854 fBrowsables->Add(fProofs, "PROOF Sessions");
856 fBrowsables->Add(fFiles, "ROOT Files");
857
859
861}
862
863////////////////////////////////////////////////////////////////////////////////
864/// Clean up and free resources used by ROOT (files, network sockets,
865/// shared memory segments, etc.).
866
868{
869 using namespace ROOT::Internal;
870
871 if (gROOTLocal == this) {
872
873 // TMapFile must be closed before they are deleted, so run CloseFiles
874 // (possibly a second time if the application has an explicit TApplication
875 // object, but in that this is a no-op). TMapFile needs the slow close
876 // so that the custome operator delete can properly find out whether the
877 // memory being 'freed' is part of a memory mapped file or not.
878 CloseFiles();
879
880 // If the interpreter has not yet been initialized, don't bother
881 gGetROOT = &GetROOT1;
882
883 // Mark the object as invalid, so that we can veto some actions
884 // (like autoloading) while we are in the destructor.
886
887 // Turn-off the global mutex to avoid recreating mutexes that have
888 // already been deleted during the destruction phase
889 if (gGlobalMutex) {
891 gGlobalMutex = nullptr;
892 delete m;
893 }
894
895 // Return when error occurred in TCling, i.e. when setup file(s) are
896 // out of date
897 if (!fVersionInt) return;
898
899 // ATTENTION!!! Order is important!
900
902
903 // FIXME: Causes rootcling to deadlock, debug and uncomment
904 // SafeDelete(fRootFolder);
905
906#ifdef R__COMPLETE_MEM_TERMINATION
907 fSpecials->Delete(); SafeDelete(fSpecials); // delete special objects : PostScript, Minuit, Html
908#endif
909
910 fClosedObjects->Delete("slow"); // and closed files
911 fFiles->Delete("slow"); // and files
913 fSecContexts->Delete("slow"); SafeDelete(fSecContexts); // and security contexts
914 fSockets->Delete(); SafeDelete(fSockets); // and sockets
915 fMappedFiles->Delete("slow"); // and mapped files
916 TSeqCollection *tl = fMappedFiles; fMappedFiles = nullptr; delete tl;
917
919
920 delete fUUIDs;
921 TProcessID::Cleanup(); // and list of ProcessIDs
922
929
930#ifdef R__COMPLETE_MEM_TERMINATION
935#endif
936
937 // Stop emitting signals
939
941
942#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, likely Proof or something, 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
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
2832void TROOT::SetWebDisplay(const char *webdisplay)
2833{
2834 const char *wd = webdisplay ? webdisplay : "";
2835
2836 // store default values to set them back when needed
2837 static TString canName = gEnv->GetValue("Canvas.Name", "");
2838 static TString brName = gEnv->GetValue("Browser.Name", "");
2839 static TString trName = gEnv->GetValue("TreeViewer.Name", "");
2840 static TString geomName = gEnv->GetValue("GeomPainter.Name", "");
2841
2843
2844 if (!strcmp(wd, "off")) {
2846 fWebDisplay = "off";
2847 } else {
2849
2850 // handle server mode
2851 if (!strncmp(wd, "server", 6)) {
2852 fWebDisplay = "server";
2854 if (wd[6] == ':') {
2855 if ((wd[7] >= '0') && (wd[7] <= '9')) {
2856 auto port = TString(wd+7).Atoi();
2857 if (port > 0)
2858 gEnv->SetValue("WebGui.HttpPort", port);
2859 else
2860 Error("SetWebDisplay", "Wrong port parameter %s for server", wd+7);
2861 } else if (wd[7]) {
2862 gEnv->SetValue("WebGui.UnixSocket", wd+7);
2863 }
2864 }
2865 } else {
2866 fWebDisplay = wd;
2867 }
2868 }
2869
2870 if (fIsWebDisplay) {
2871 // restore canvas and browser classes configured at the moment when gROOT->SetWebDisplay() was called for the first time
2872 // This is necessary when SetWebDisplay() called several times and therefore current settings may differ
2873 gEnv->SetValue("Canvas.Name", canName);
2874 gEnv->SetValue("Browser.Name", brName);
2875 gEnv->SetValue("TreeViewer.Name", trName);
2876 gEnv->SetValue("GeomPainter.Name", geomName);
2877 } else {
2878 gEnv->SetValue("Canvas.Name", "TRootCanvas");
2879 gEnv->SetValue("Browser.Name", "TRootBrowser");
2880 gEnv->SetValue("TreeViewer.Name", "TTreeViewer");
2881 gEnv->SetValue("GeomPainter.Name", "root");
2882 }
2883}
2884
2885////////////////////////////////////////////////////////////////////////////////
2886/// Increase the indentation level for ls().
2887
2889{
2890 return ++fgDirLevel;
2891}
2892
2893////////////////////////////////////////////////////////////////////////////////
2894/// Functions used by ls() to indent an object hierarchy.
2895
2897{
2898 for (int i = 0; i < fgDirLevel; i++) std::cout.put(' ');
2899}
2900
2901////////////////////////////////////////////////////////////////////////////////
2902/// Initialize ROOT explicitly.
2903
2905 (void) gROOT;
2906}
2907
2908////////////////////////////////////////////////////////////////////////////////
2909/// Return kTRUE if the TROOT object has been initialized.
2910
2912{
2913 return fgRootInit;
2914}
2915
2916////////////////////////////////////////////////////////////////////////////////
2917/// Return Indentation level for ls().
2918
2920{
2921 fgDirLevel = level;
2922}
2923
2924////////////////////////////////////////////////////////////////////////////////
2925/// Convert version code to an integer, i.e. 331527 -> 51507.
2926
2928{
2929 return 10000*(code>>16) + 100*((code&65280)>>8) + (code&255);
2930}
2931
2932////////////////////////////////////////////////////////////////////////////////
2933/// Convert version as an integer to version code as used in RVersion.h.
2934
2936{
2937 int a = v/10000;
2938 int b = (v - a*10000)/100;
2939 int c = v - a*10000 - b*100;
2940 return (a << 16) + (b << 8) + c;
2941}
2942
2943////////////////////////////////////////////////////////////////////////////////
2944/// Return ROOT version code as defined in RVersion.h.
2945
2950////////////////////////////////////////////////////////////////////////////////
2951/// Provide command line arguments to the interpreter construction.
2952/// These arguments are added to the existing flags (e.g. `-DNDEBUG`).
2953/// They are evaluated once per process, at the time where TROOT (and thus
2954/// TInterpreter) is constructed.
2955/// Returns the new flags.
2956
2957const std::vector<std::string> &TROOT::AddExtraInterpreterArgs(const std::vector<std::string> &args) {
2958 static std::vector<std::string> sArgs = {};
2959 sArgs.insert(sArgs.begin(), args.begin(), args.end());
2960 return sArgs;
2961}
2962
2963////////////////////////////////////////////////////////////////////////////////
2964/// INTERNAL function!
2965/// Used by rootcling to inject interpreter arguments through a C-interface layer.
2966
2968 static const char** extraInterpArgs = nullptr;
2969 return extraInterpArgs;
2970}
2971
2972////////////////////////////////////////////////////////////////////////////////
2973
2974#ifdef ROOTPREFIX
2975static Bool_t IgnorePrefix() {
2976 static Bool_t ignorePrefix = gSystem->Getenv("ROOTIGNOREPREFIX");
2977 return ignorePrefix;
2978}
2979#endif
2980
2981////////////////////////////////////////////////////////////////////////////////
2982/// Get the rootsys directory in the installation. Static utility function.
2983
2985 // Avoid returning a reference to a temporary because of the conversion
2986 // between std::string and TString.
2988 return rootsys;
2989}
2990
2991////////////////////////////////////////////////////////////////////////////////
2992/// Get the binary directory in the installation. Static utility function.
2993
2995#ifdef ROOTBINDIR
2996 if (IgnorePrefix()) {
2997#endif
2998 static TString rootbindir;
2999 if (rootbindir.IsNull()) {
3000 rootbindir = "bin";
3002 }
3003 return rootbindir;
3004#ifdef ROOTBINDIR
3005 } else {
3006 const static TString rootbindir = ROOTBINDIR;
3007 return rootbindir;
3008 }
3009#endif
3010}
3011
3012////////////////////////////////////////////////////////////////////////////////
3013/// Get the library directory in the installation. Static utility function.
3014
3016#ifdef ROOTLIBDIR
3017 if (IgnorePrefix()) {
3018#endif
3019 static TString rootlibdir;
3020 if (rootlibdir.IsNull()) {
3021 rootlibdir = "lib";
3023 }
3024 return rootlibdir;
3025#ifdef ROOTLIBDIR
3026 } else {
3027 const static TString rootlibdir = ROOTLIBDIR;
3028 return rootlibdir;
3029 }
3030#endif
3031}
3032
3033////////////////////////////////////////////////////////////////////////////////
3034/// Get the shared libraries directory in the installation. Static utility function.
3035
3037#if defined(R__WIN32)
3038 return TROOT::GetBinDir();
3039#else
3040 return TROOT::GetLibDir();
3041#endif
3042}
3043
3044////////////////////////////////////////////////////////////////////////////////
3045/// Get the include directory in the installation. Static utility function.
3046
3048 // Avoid returning a reference to a temporary because of the conversion
3049 // between std::string and TString.
3051 return includedir;
3052}
3053
3054////////////////////////////////////////////////////////////////////////////////
3055/// Get the sysconfig directory in the installation. Static utility function.
3056
3058 // Avoid returning a reference to a temporary because of the conversion
3059 // between std::string and TString.
3061 return etcdir;
3062}
3063
3064////////////////////////////////////////////////////////////////////////////////
3065/// Get the data directory in the installation. Static utility function.
3066
3068#ifdef ROOTDATADIR
3069 if (IgnorePrefix()) {
3070#endif
3071 return GetRootSys();
3072#ifdef ROOTDATADIR
3073 } else {
3074 const static TString rootdatadir = ROOTDATADIR;
3075 return rootdatadir;
3076 }
3077#endif
3078}
3079
3080////////////////////////////////////////////////////////////////////////////////
3081/// Get the documentation directory in the installation. Static utility function.
3082
3084#ifdef ROOTDOCDIR
3085 if (IgnorePrefix()) {
3086#endif
3087 return GetRootSys();
3088#ifdef ROOTDOCDIR
3089 } else {
3090 const static TString rootdocdir = ROOTDOCDIR;
3091 return rootdocdir;
3092 }
3093#endif
3094}
3095
3096////////////////////////////////////////////////////////////////////////////////
3097/// Get the macro directory in the installation. Static utility function.
3098
3100#ifdef ROOTMACRODIR
3101 if (IgnorePrefix()) {
3102#endif
3103 static TString rootmacrodir;
3104 if (rootmacrodir.IsNull()) {
3105 rootmacrodir = "macros";
3107 }
3108 return rootmacrodir;
3109#ifdef ROOTMACRODIR
3110 } else {
3111 const static TString rootmacrodir = ROOTMACRODIR;
3112 return rootmacrodir;
3113 }
3114#endif
3115}
3116
3117////////////////////////////////////////////////////////////////////////////////
3118/// Get the tutorials directory in the installation. Static utility function.
3119
3121#ifdef ROOTTUTDIR
3122 if (IgnorePrefix()) {
3123#endif
3124 static TString roottutdir;
3125 if (roottutdir.IsNull()) {
3126 roottutdir = "tutorials";
3128 }
3129 return roottutdir;
3130#ifdef ROOTTUTDIR
3131 } else {
3132 const static TString roottutdir = ROOTTUTDIR;
3133 return roottutdir;
3134 }
3135#endif
3136}
3137
3138////////////////////////////////////////////////////////////////////////////////
3139/// Shut down ROOT.
3140
3142{
3143 if (gROOT)
3144 gROOT->EndOfProcessCleanups();
3145 else if (gInterpreter)
3146 gInterpreter->ShutDown();
3147}
3148
3149////////////////////////////////////////////////////////////////////////////////
3150/// Get the source directory in the installation. Static utility function.
3151
3153#ifdef ROOTSRCDIR
3154 if (IgnorePrefix()) {
3155#endif
3156 static TString rootsrcdir;
3157 if (rootsrcdir.IsNull()) {
3158 rootsrcdir = "src";
3160 }
3161 return rootsrcdir;
3162#ifdef ROOTSRCDIR
3163 } else {
3164 const static TString rootsrcdir = ROOTSRCDIR;
3165 return rootsrcdir;
3166 }
3167#endif
3168}
3169
3170////////////////////////////////////////////////////////////////////////////////
3171/// Get the icon path in the installation. Static utility function.
3172
3174#ifdef ROOTICONPATH
3175 if (IgnorePrefix()) {
3176#endif
3177 static TString rooticonpath;
3178 if (rooticonpath.IsNull()) {
3179 rooticonpath = "icons";
3181 }
3182 return rooticonpath;
3183#ifdef ROOTICONPATH
3184 } else {
3185 const static TString rooticonpath = ROOTICONPATH;
3186 return rooticonpath;
3187 }
3188#endif
3189}
3190
3191////////////////////////////////////////////////////////////////////////////////
3192/// Get the fonts directory in the installation. Static utility function.
3193
3195#ifdef TTFFONTDIR
3196 if (IgnorePrefix()) {
3197#endif
3198 static TString ttffontdir;
3199 if (ttffontdir.IsNull()) {
3200 ttffontdir = "fonts";
3202 }
3203 return ttffontdir;
3204#ifdef TTFFONTDIR
3205 } else {
3206 const static TString ttffontdir = TTFFONTDIR;
3207 return ttffontdir;
3208 }
3209#endif
3210}
3211
3212////////////////////////////////////////////////////////////////////////////////
3213/// Get the tutorials directory in the installation. Static utility function.
3214/// Backward compatibility function - do not use for new code
3215
3217 return GetTutorialDir();
3218}
@ 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
Definition RtypesCore.h:63
int Int_t
Definition RtypesCore.h:45
long Longptr_t
Definition RtypesCore.h:75
unsigned int UInt_t
Definition RtypesCore.h:46
constexpr Bool_t kFALSE
Definition RtypesCore.h:94
constexpr Ssiz_t kNPOS
Definition RtypesCore.h:117
constexpr Bool_t kTRUE
Definition RtypesCore.h:93
const char Option_t
Definition RtypesCore.h:66
#define ClassImp(name)
Definition Rtypes.h:374
void(* VoidFuncPtr_t)()
Definition Rtypes.h:84
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:384
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:185
void Warning(const char *location, const char *msgfmt,...)
Use this function in warning situations.
Definition TError.cxx:229
ErrorHandlerFunc_t SetErrorHandler(ErrorHandlerFunc_t newhandler)
Set an errorhandler function. Returns the old handler.
Definition TError.cxx:90
Option_t Option_t option
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 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:184
static Int_t IDATQQ(const char *date)
Return built date as integer, i.e. "Apr 28 2000" -> 20000428.
Definition TROOT.cxx:194
static TClass * R__GetClassIfKnown(const char *className)
Check whether className is a known class, and only autoload if we can.
Definition TROOT.cxx:1906
static DestroyInterpreter_t * gDestroyInterpreter
Definition TROOT.cxx:170
Int_t gDebug
Definition TROOT.cxx:622
static void * gInterpreterLib
Definition TROOT.cxx:171
static Int_t ITIMQQ(const char *time)
Return built time as integer (with min precision), i.e.
Definition TROOT.cxx:222
static void at_exit_of_TROOT()
Definition TROOT.cxx:296
TVirtualMutex * gROOTMutex
Definition TROOT.cxx:174
static void CleanUpROOTAtExit()
Clean up at program termination before global objects go out of scope.
Definition TROOT.cxx:232
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:414
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:17535
char fHolder[sizeof(TROOT)]
Definition TROOT.cxx:338
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:37
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:5889
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:5002
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:3074
Collection abstract base class.
Definition TCollection.h:65
void RecursiveRemove(TObject *obj) override
Remove object from this collection and recursively remove the object from all other objects (and coll...
virtual bool UseRWLock(Bool_t enable=true)
Set this collection to use a RW lock upon access, making it thread safe.
virtual void AddAll(const TCollection *col)
Add all objects from collection col to this collection.
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
virtual void Add(TObject *obj)=0
TObject * FindObject(const char *name) const override
Find an object in this collection using its name.
void Delete(Option_t *option="") override=0
Delete this object.
void Clear(Option_t *option="") override=0
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
The color creation and management class.
Definition TColor.h:22
static void InitializeColors()
Initialize colors used by the TCanvas based graphics (via TColor objects).
Definition TColor.cxx:1173
Int_t GetNumber() const
Definition TColor.h:59
Basic data type descriptor (datatype information is obtained from CINT).
Definition TDataType.h:44
Describe directory structure in memory.
Definition TDirectory.h:45
virtual void Close(Option_t *option="")
Delete all objects from memory and directory structure itself.
virtual TList * GetList() const
Definition TDirectory.h:222
void ls(Option_t *option="") const override
List Directory contents.
virtual void Append(TObject *obj, Bool_t replace=kFALSE)
Append object to this directory.
void SetName(const char *newname) override
Set the name for directory If the directory name is changed after the directory was written once,...
void BuildDirectory(TFile *motherFile, TDirectory *motherDir)
Initialise directory to defaults.
static std::atomic< TDirectory * > & CurrentDirectory()
Return the current directory for the current thread.
virtual TObject * Remove(TObject *)
Remove an object from the in-memory list.
TList * fList
Definition TDirectory.h:142
The TEnv class reads config files, by default named .rootrc.
Definition TEnv.h:124
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
Definition TEnv.cxx:491
virtual void SetValue(const char *name, const char *value, EEnvLevel level=kEnvChange, const char *type=nullptr)
Set the value of a resource or create a new resource.
Definition TEnv.cxx:736
A ROOT file is an on-disk file, usually with extension .root, that stores objects in a file-system-li...
Definition TFile.h:131
<div class="legacybox"><h2>Legacy Code</h2> TFolder is a legacy interface: there will be no bug fixes...
Definition TFolder.h:30
virtual TObject * FindObjectAny(const char *name) const
Return a pointer to the first object with name starting at this folder.
Definition TFolder.cxx:343
TFolder * AddFolder(const char *name, const char *title, TCollection *collection=nullptr)
Create a new folder and add it to the list of folders of this folder, return a pointer to the created...
Definition TFolder.cxx:182
Dictionary for function template This class describes one single function template.
Global functions class (global functions are obtained from CINT).
Definition TFunction.h:30
static void MakeFunctor(const char *name, const char *type, GlobFunc &func)
Definition TGlobal.h:73
static TList & GetEarlyRegisteredGlobals()
Returns list collected globals Used to storeTGlobalMappedFunctions from other libs,...
Definition TGlobal.cxx:189
Global variables class (global variables are obtained from CINT).
Definition TGlobal.h:28
This ABC is a factory for GUI components.
Definition TGuiFactory.h:42
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
Definition THashList.h:34
THashTable implements a hash table to store TObject's.
Definition THashTable.h:35
virtual void RegisterModule(const char *, const char **, const char **, const char *, const char *, void(*)(), const FwdDeclArgsToKeepCollection_t &fwdDeclArgsToKeep, const char **classesHeaders, Bool_t lateRegistration=false, Bool_t hasCxxModule=false)=0
virtual void Reset()=0
virtual void Initialize()=0
std::vector< std::pair< std::string, int > > FwdDeclArgsToKeepCollection_t
virtual void SaveContext()=0
TDictionary::DeclId_t DeclId_t
Option_t * GetOption() const
A collection of TDataMember objects designed for fast access given a DeclId_t and for keep track of T...
void Delete(Option_t *option="") override
Delete all TDataMember object files.
void Unload()
Mark 'all func' as being unloaded.
void Load()
Load all the DataMembers known to the interpreter for the scope 'fClass' into this collection.
A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum t...
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
TObject * FindObject(const char *name) const override
Specialize FindObject to do search for the a function just by name or create it if its not already in...
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
TFunction * Get(DeclId_t id)
Return (after creating it if necessary) the TMethod or TFunction describing the function correspondin...
void Delete(Option_t *option="") override
Delete all TFunction object files.
void Load()
Load all the functions known to the interpreter for the scope 'fClass' into this collection.
void Unload()
Mark 'all func' as being unloaded.
A collection of TDataType designed to hold the typedef information and numerical type information.
A doubly linked list.
Definition TList.h:38
void Add(TObject *obj) override
Definition TList.h:81
void Delete(Option_t *option="") override
Remove all objects from the list AND delete all heap based objects.
Definition TList.cxx:468
Handle messages that might be generated by the system.
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition TNamed.cxx:174
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition TNamed.cxx:150
An array of TObjects.
Definition TObjArray.h:31
Mother of all ROOT objects.
Definition TObject.h:41
static void SetObjectStat(Bool_t stat)
Turn on/off tracking of objects in the TObjectTable.
Definition TObject.cxx: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:2888
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
TSeqCollection * fProofs
List of proof sessions.
Definition TROOT.h:170
TCollection * fClassGenerators
List of user defined class generators;.
Definition TROOT.h:168
TROOT()
Only used by Dictionary.
Definition TROOT.cxx:630
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:2832
Bool_t fIsWebDisplay
True if session uses web widgets.
Definition TROOT.h:136
TFolder * fRootFolder
top level folder //root
Definition TROOT.h:175
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:178
TInterpreter * fInterpreter
Command interpreter.
Definition TROOT.h:133
std::vector< std::pair< std::string, int > > FwdDeclArgsToKeepCollection_t
Definition TROOT.h:195
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:245
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:2994
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:3047
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:288
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:2904
static void ShutDown()
Shut down ROOT.
Definition TROOT.cxx:3141
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:2927
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:173
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:2935
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:3194
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:3173
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:172
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:2919
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:3216
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:2911
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:3152
static const TString & GetMacroDir()
Get the macro directory in the installation. Static utility function.
Definition TROOT.cxx:3099
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:171
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:3120
virtual ~TROOT()
Clean up and free resources used by ROOT (files, network sockets, shared memory segments,...
Definition TROOT.cxx:867
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:253
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:240
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:2957
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:2984
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:2946
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:2896
static const TString & GetDocDir()
Get the documentation directory in the installation. Static utility function.
Definition TROOT.cxx:3083
static const TString & GetEtcDir()
Get the sysconfig directory in the installation. Static utility function.
Definition TROOT.cxx:3057
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:2967
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:174
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:177
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:3036
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:268
static const TString & GetLibDir()
Get the library directory in the installation. Static utility function.
Definition TROOT.cxx:3015
TSeqCollection * fBrowsers
List of browsers.
Definition TROOT.h:163
TString fDefCanvasName
Name of default canvas.
Definition TROOT.h:179
TListOfFunctions * fGlobalFunctions
List of global functions.
Definition TROOT.h:152
TList * fBrowsables
List of browsables.
Definition TROOT.h:176
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:3067
TSeqCollection * GetListOfGeometries() const
Definition TROOT.h:252
TSeqCollection * GetListOfStyles() const
Definition TROOT.h:249
TString fVersion
ROOT version (from CMZ VERSQQ) ex 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:368
Basic string class.
Definition TString.h:139
Ssiz_t Length() const
Definition TString.h:417
Int_t Atoi() const
Return integer value of string.
Definition TString.cxx:1988
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:376
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition TString.h:704
@ kBoth
Definition TString.h:276
@ kIgnoreCase
Definition TString.h:277
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
Definition TString.h:623
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition TString.cxx:2356
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition TString.h:632
TStyle objects may be created to define special styles.
Definition TStyle.h:29
static void BuildStyles()
Create some standard styles.
Definition TStyle.cxx:525
Describes an Operating System directory for the browser.
Abstract base class defining a generic interface to the underlying Operating System.
Definition TSystem.h:276
virtual Func_t DynFindSymbol(const char *module, const char *entry)
Find specific entry point in specified library.
Definition TSystem.cxx:2057
virtual const char * Getenv(const char *env)
Get environment variable.
Definition TSystem.cxx:1678
virtual TString SplitAclicMode(const char *filename, TString &mode, TString &args, TString &io) const
This method split a filename of the form:
Definition TSystem.cxx:4272
virtual void CleanCompiledMacros()
Remove the shared libs produced by the CompileMacro() function, together with their rootmaps,...
Definition TSystem.cxx:4386
virtual int Load(const char *module, const char *entry="", Bool_t system=kFALSE)
Load a shared library.
Definition TSystem.cxx:1870
int GetPathInfo(const char *path, Long_t *id, Long_t *size, Long_t *flags, Long_t *modtime)
Get info about a file: id, size, flags, modification time.
Definition TSystem.cxx:1411
virtual const char * PrependPathName(const char *dir, TString &name)
Concatenate a directory and a file name.
Definition TSystem.cxx:1094
virtual Bool_t AccessPathName(const char *path, EAccessMode mode=kFileExists)
Returns FALSE if one can access a file using the specified access mode.
Definition TSystem.cxx:1309
virtual Bool_t Init()
Initialize the OS interface.
Definition TSystem.cxx:183
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
Definition TSystem.cxx:946
virtual const char * WorkingDirectory()
Return working directory.
Definition TSystem.cxx:883
virtual char * Which(const char *search, const char *file, EAccessMode mode=kFileExists)
Find location of file in a search path.
Definition TSystem.cxx:1561
virtual const char * HomeDirectory(const char *userName=nullptr)
Return the user's home directory.
Definition TSystem.cxx:899
virtual const char * GetError()
Return system error string.
Definition TSystem.cxx:254
virtual void ResetSignals()
Reset signals handlers to previous behaviour.
Definition TSystem.cxx:584
char * DynamicPathName(const char *lib, Bool_t quiet=kFALSE)
Find a dynamic library called lib using the system search paths.
Definition TSystem.cxx:2033
This class represents a WWW compatible URL.
Definition TUrl.h:33
This class implements a mutex interface.
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition TVirtualPad.h:51
static TVirtualPad *& Pad()
Return the current pad for the current thread.
virtual TVirtualPad * GetVirtCanvas() const =0
Semi-Abstract base class defining a generic interface to the underlying, low level,...
Definition TVirtualX.h:46
static TVirtualX *& Instance()
Returns gVirtualX global.
Definition TVirtualX.cxx:57
Class providing an interface to the Windows NT Operating System.
TLine * line
TF1 * f1
Definition legend1.C:11
R__ALWAYS_INLINE bool HasBeenDeleted(const TObject *obj)
Check if the TObject's memory has been deleted.
Definition TObject.h:408
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:401
static GetROOTFun_t gGetROOT
Definition TROOT.cxx:399
R__EXTERN TROOT * gROOTLocal
Definition TROOT.h:387
void DisableParBranchProcessing()
Globally disables the IMT use case of parallel branch processing, deactivating the corresponding lock...
Definition TROOT.cxx:434
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:463
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:67
TROOT *(* GetROOTFun_t)()
Definition TROOT.cxx:397
ErrorSystemMsgHandlerFunc_t SetErrorSystemMsgHandler(ErrorSystemMsgHandlerFunc_t h)
Returns the previous system error message handler.
Definition TError.cxx:56
void EnableParBranchProcessing()
Globally enables the parallel branch processing, which is a case of implicit multi-threading (IMT) in...
Definition TROOT.cxx:420
Bool_t IsParBranchProcessingEnabled()
Returns true if parallel branch processing is enabled.
Definition TROOT.cxx:447
TROOT * GetROOT2()
Definition TROOT.cxx:387
TROOT * GetROOT1()
Definition TROOT.cxx:380
void ReleaseDefaultErrorHandler()
Destructs resources that are taken by using the default error handler.
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
TString & GetMacroPath()
Definition TROOT.cxx:476
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:539
Bool_t IsImplicitMTEnabled()
Returns true if the implicit multi-threading in ROOT is enabled.
Definition TROOT.cxx:595
UInt_t GetThreadPoolSize()
Returns the size of ROOT's thread pool.
Definition TROOT.cxx:602
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:501
EIMTConfig
Definition TROOT.h:83
TROOT * GetROOT()
Definition TROOT.cxx:472
void DisableImplicitMT()
Disables the implicit multi-threading in ROOT (see EnableImplicitMT).
Definition TROOT.cxx:581
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