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