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