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