Logo ROOT   master
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 
15 ROOT top level object description.
16 
17 The TROOT object is the entry point to the ROOT system.
18 The single instance of TROOT is accessible via the global gROOT.
19 Using the gROOT pointer one has access to basically every object
20 created in a ROOT based program. The TROOT object is essentially a
21 container of several lists pointing to the main ROOT objects.
22 
23 The 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 
45 The 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 
49 The ROOT object must be created as a static object. An example
50 of 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 #include <string>
75 #include <map>
76 #include <stdlib.h>
77 #ifdef WIN32
78 #include <io.h>
79 #include "Windows4Root.h"
80 #include <Psapi.h>
81 #define RTLD_DEFAULT ((void *)::GetModuleHandle(NULL))
82 //#define dlsym(library, function_name) ::GetProcAddress((HMODULE)library, function_name)
83 #define dlopen(library_name, flags) ::LoadLibrary(library_name)
84 #define dlclose(library) ::FreeLibrary((HMODULE)library)
85 char *dlerror() {
86  static char Msg[1000];
87  FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
88  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), Msg,
89  sizeof(Msg), NULL);
90  return Msg;
91 }
92 FARPROC dlsym(void *library, const char *function_name)
93 {
94  HMODULE hMods[1024];
95  DWORD cbNeeded;
96  FARPROC address = NULL;
97  unsigned int i;
98  if (library == RTLD_DEFAULT) {
99  if (EnumProcessModules(::GetCurrentProcess(), hMods, sizeof(hMods), &cbNeeded)) {
100  for (i = 0; i < (cbNeeded / sizeof(HMODULE)); i++) {
101  address = ::GetProcAddress((HMODULE)hMods[i], function_name);
102  if (address)
103  return address;
104  }
105  }
106  return address;
107  } else {
108  return ::GetProcAddress((HMODULE)library, function_name);
109  }
110 }
111 #else
112 #include <dlfcn.h>
113 #endif
114 
115 #include "Riostream.h"
116 #include "ROOT/FoundationUtils.hxx"
117 #include "TROOT.h"
118 #include "TClass.h"
119 #include "TClassEdit.h"
120 #include "TClassGenerator.h"
121 #include "TDataType.h"
122 #include "TDatime.h"
123 #include "TStyle.h"
124 #include "TObjectTable.h"
125 #include "TClassTable.h"
126 #include "TSystem.h"
127 #include "THashList.h"
128 #include "TObjArray.h"
129 #include "TEnv.h"
130 #include "TError.h"
131 #include "TColor.h"
132 #include "TGlobal.h"
133 #include "TFunction.h"
134 #include "TVirtualPad.h"
135 #include "TBrowser.h"
136 #include "TSystemDirectory.h"
137 #include "TApplication.h"
138 #include "TInterpreter.h"
139 #include "TGuiFactory.h"
140 #include "TMessageHandler.h"
141 #include "TFolder.h"
142 #include "TQObject.h"
143 #include "TProcessUUID.h"
144 #include "TPluginManager.h"
145 #include "TMap.h"
146 #include "TVirtualMutex.h"
147 #include "TInterpreter.h"
148 #include "TListOfTypes.h"
149 #include "TListOfDataMembers.h"
150 #include "TListOfEnumsWithLock.h"
151 #include "TListOfFunctions.h"
153 #include "TFunctionTemplate.h"
154 #include "ThreadLocalStorage.h"
155 #include "TVirtualRWMutex.h"
156 #include "TVirtualX.h"
157 
158 #include <string>
159 namespace std {} using namespace std;
160 
161 #if defined(R__UNIX)
162 #if defined(R__HAS_COCOA)
163 #include "TMacOSXSystem.h"
164 #include "TUrl.h"
165 #else
166 #include "TUnixSystem.h"
167 #endif
168 #elif defined(R__WIN32)
169 #include "TWinNTSystem.h"
170 #endif
171 
172 extern "C" void R__SetZipMode(int);
173 
175 static void *gInterpreterLib = 0;
176 
177 // Mutex for protection of concurrent gROOT access
180 
181 // For accessing TThread::Tsd indirectly.
182 void **(*gThreadTsd)(void*,Int_t) = 0;
183 
184 //-------- Names of next three routines are a small homage to CMZ --------------
185 ////////////////////////////////////////////////////////////////////////////////
186 /// Return version id as an integer, i.e. "2.22/04" -> 22204.
187 
188 static Int_t IVERSQ()
189 {
190  Int_t maj, min, cycle;
191  sscanf(ROOT_RELEASE, "%d.%d/%d", &maj, &min, &cycle);
192  return 10000*maj + 100*min + cycle;
193 }
194 
195 ////////////////////////////////////////////////////////////////////////////////
196 /// Return built date as integer, i.e. "Apr 28 2000" -> 20000428.
197 
198 static Int_t IDATQQ(const char *date)
199 {
200  static const char *months[] = {"Jan","Feb","Mar","Apr","May",
201  "Jun","Jul","Aug","Sep","Oct",
202  "Nov","Dec"};
203 
204  char sm[12];
205  Int_t yy, mm=0, dd;
206  sscanf(date, "%s %d %d", sm, &dd, &yy);
207  for (int i = 0; i < 12; i++)
208  if (!strncmp(sm, months[i], 3)) {
209  mm = i+1;
210  break;
211  }
212  return 10000*yy + 100*mm + dd;
213 }
214 
215 ////////////////////////////////////////////////////////////////////////////////
216 /// Return built time as integer (with min precision), i.e.
217 /// "17:32:37" -> 1732.
218 
219 static Int_t ITIMQQ(const char *time)
220 {
221  Int_t hh, mm, ss;
222  sscanf(time, "%d:%d:%d", &hh, &mm, &ss);
223  return 100*hh + mm;
224 }
225 
226 ////////////////////////////////////////////////////////////////////////////////
227 /// Clean up at program termination before global objects go out of scope.
228 
229 static void CleanUpROOTAtExit()
230 {
231  if (gROOT) {
233 
234  if (gROOT->GetListOfFiles())
235  gROOT->GetListOfFiles()->Delete("slow");
236  if (gROOT->GetListOfSockets())
237  gROOT->GetListOfSockets()->Delete();
238  if (gROOT->GetListOfMappedFiles())
239  gROOT->GetListOfMappedFiles()->Delete("slow");
240  if (gROOT->GetListOfClosedObjects())
241  gROOT->GetListOfClosedObjects()->Delete("slow");
242  }
243 }
244 
245 ////////////////////////////////////////////////////////////////////////////////
246 /// A module and its headers. Intentionally not a copy:
247 /// If these strings end up in this struct they are
248 /// long lived by definition because they get passed in
249 /// before initialization of TCling.
250 
251 namespace {
252  struct ModuleHeaderInfo_t {
253  ModuleHeaderInfo_t(const char* moduleName,
254  const char** headers,
255  const char** includePaths,
256  const char* payloadCode,
257  const char* fwdDeclCode,
258  void (*triggerFunc)(),
259  const TROOT::FwdDeclArgsToKeepCollection_t& fwdDeclsArgToSkip,
260  const char **classesHeaders,
261  bool hasCxxModule):
262  fModuleName(moduleName),
263  fHeaders(headers),
264  fPayloadCode(payloadCode),
265  fFwdDeclCode(fwdDeclCode),
266  fIncludePaths(includePaths),
267  fTriggerFunc(triggerFunc),
268  fClassesHeaders(classesHeaders),
269  fFwdNargsToKeepColl(fwdDeclsArgToSkip),
270  fHasCxxModule(hasCxxModule) {}
271 
272  const char* fModuleName; // module name
273  const char** fHeaders; // 0-terminated array of header files
274  const char* fPayloadCode; // Additional code to be given to cling at library load
275  const char* fFwdDeclCode; // Additional code to let cling know about selected classes and functions
276  const char** fIncludePaths; // 0-terminated array of header files
277  void (*fTriggerFunc)(); // Pointer to the dict initialization used to find the library name
278  const char** fClassesHeaders; // 0-terminated list of classes and related header files
279  const TROOT::FwdDeclArgsToKeepCollection_t fFwdNargsToKeepColl; // Collection of
280  // pairs of template fwd decls and number of
281  bool fHasCxxModule; // Whether this module has a C++ module alongside it.
282  };
283 
284  std::vector<ModuleHeaderInfo_t>& GetModuleHeaderInfoBuffer() {
285  static std::vector<ModuleHeaderInfo_t> moduleHeaderInfoBuffer;
286  return moduleHeaderInfoBuffer;
287  }
288 }
289 
293 
294 static void at_exit_of_TROOT() {
297 }
298 
299 // This local static object initializes the ROOT system
300 namespace ROOT {
301 namespace Internal {
302  class TROOTAllocator {
303  // Simple wrapper to separate, time-wise, the call to the
304  // TROOT destructor and the actual free-ing of the memory.
305  //
306  // Since the interpreter implementation (currently TCling) is
307  // loaded via dlopen by libCore, the destruction of its global
308  // variable (i.e. in particular clang's) is scheduled before
309  // those in libCore so we need to schedule the call to the TROOT
310  // destructor before that *but* we want to make sure the memory
311  // stay around until libCore itself is unloaded so that code
312  // using gROOT can 'properly' check for validity.
313  //
314  // The order of loading for is:
315  // libCore.so
316  // libRint.so
317  // ... anything other library hard linked to the executable ...
318  // ... for example libEvent
319  // libCling.so
320  // ... other libraries like libTree for example ....
321  // and the destruction order is (of course) the reverse.
322  // By default the unloading of the dictionary, does use
323  // the service of the interpreter ... which of course
324  // fails if libCling is already unloaded by that information
325  // has not been registered per se.
326  //
327  // To solve this problem, we now schedule the destruction
328  // of the TROOT object to happen _just_ before the
329  // unloading/destruction of libCling so that we can
330  // maximize the amount of clean-up we can do correctly
331  // and we can still allocate the TROOT object's memory
332  // statically.
333  //
334  char fHolder[sizeof(TROOT)];
335  public:
336  TROOTAllocator() {
337  new(&(fHolder[0])) TROOT("root", "The ROOT of EVERYTHING");
338  }
339 
340  ~TROOTAllocator() {
341  if (gROOTLocal) {
342  gROOTLocal->~TROOT();
343  }
344  }
345  };
346 
347  // The global gROOT is defined to be a function (ROOT::GetROOT())
348  // which itself is dereferencing a function pointer.
349 
350  // Initially this function pointer's value is & GetROOT1 whose role is to
351  // create and initialize the TROOT object itself.
352  // At the very end of the TROOT constructor the value of the function pointer
353  // is switch to & GetROOT2 whose role is to initialize the interpreter.
354 
355  // This mechanism was primarily intended to fix the issues with order in which
356  // global TROOT and LLVM globals are initialized. TROOT was initializing
357  // Cling, but Cling could not be used yet due to LLVM globals not being
358  // Initialized yet. The solution is to delay initializing the interpreter in
359  // TROOT till after main() when all LLVM globals are initialized.
360 
361  // Technically, the mechanism used actually delay the interpreter
362  // initialization until the first use of gROOT *after* the end of the
363  // TROOT constructor.
364 
365  // So to delay until after the start of main, we also made sure that none
366  // of the ROOT code (mostly the dictionary code) used during library loading
367  // is using gROOT (directly or indirectly).
368 
369  // In practice, the initialization of the interpreter is now delayed until
370  // the first use gROOT (or gInterpreter) after the start of main (but user
371  // could easily break this by using gROOT in their library initialization
372  // code).
373 
374  extern TROOT *gROOTLocal;
375 
377  if (gROOTLocal)
378  return gROOTLocal;
379  static TROOTAllocator alloc;
380  return gROOTLocal;
381  }
382 
384  static Bool_t initInterpreter = kFALSE;
385  if (!initInterpreter) {
386  initInterpreter = kTRUE;
388  // Load and init threads library
390  }
391  return gROOTLocal;
392  }
393  typedef TROOT *(*GetROOTFun_t)();
394 
396 
397  static Func_t GetSymInLibImt(const char *funcname)
398  {
399  const static bool loadSuccess = dlsym(RTLD_DEFAULT, "usedToIdentifyRootClingByDlSym")? false : 0 <= gSystem->Load("libImt");
400  if (loadSuccess) {
401  if (auto sym = gSystem->DynFindSymbol(nullptr, funcname)) {
402  return sym;
403  } else {
404  Error("GetSymInLibImt", "Cannot get symbol %s.", funcname);
405  }
406  }
407  return nullptr;
408  }
409 
410  //////////////////////////////////////////////////////////////////////////////
411  /// Globally enables the parallel branch processing, which is a case of
412  /// implicit multi-threading (IMT) in ROOT, activating the required locks.
413  /// This IMT use case, implemented in TTree::GetEntry, spawns a task for
414  /// each branch of the tree. Therefore, a task takes care of the reading,
415  /// decompression and deserialisation of a given branch.
417  {
418 #ifdef R__USE_IMT
419  if (!IsImplicitMTEnabled())
421  static void (*sym)() = (void(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_EnableParBranchProcessing");
422  if (sym)
423  sym();
424 #else
425  ::Warning("EnableParBranchProcessing", "Cannot enable parallel branch processing, please build ROOT with -Dimt=ON");
426 #endif
427  }
428 
429  //////////////////////////////////////////////////////////////////////////////
430  /// Globally disables the IMT use case of parallel branch processing,
431  /// deactivating the corresponding locks.
433  {
434 #ifdef R__USE_IMT
435  static void (*sym)() = (void(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_DisableParBranchProcessing");
436  if (sym)
437  sym();
438 #else
439  ::Warning("DisableParBranchProcessing", "Cannot disable parallel branch processing, please build ROOT with -Dimt=ON");
440 #endif
441  }
442 
443  //////////////////////////////////////////////////////////////////////////////
444  /// Returns true if parallel branch processing is enabled.
446  {
447 #ifdef R__USE_IMT
448  static Bool_t (*sym)() = (Bool_t(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_IsParBranchProcessingEnabled");
449  if (sym)
450  return sym();
451  else
452  return kFALSE;
453 #else
454  return kFALSE;
455 #endif
456  }
457 
458  ////////////////////////////////////////////////////////////////////////////////
459  /// Globally enables the parallel tree processing, which is a case of
460  /// implicit multi-threading in ROOT, activating the required locks.
461  /// This IMT use case, implemented in TTreeProcessor::Process, receives a user
462  /// function and applies it to subranges of the tree, which correspond to its
463  /// clusters. Hence, for every cluster, a task is spawned to potentially
464  /// process it in parallel with the other clusters.
466  {
467 #ifdef R__USE_IMT
468  if (!IsImplicitMTEnabled())
470  static void (*sym)() = (void(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_EnableParTreeProcessing");
471  if (sym)
472  sym();
473 #else
474  ::Warning("EnableParTreeProcessing", "Cannot enable parallel tree processing, please build ROOT with -Dimt=ON");
475 #endif
476  }
477 
478  //////////////////////////////////////////////////////////////////////////////
479  /// Globally disables the IMT use case of parallel branch processing,
480  /// deactivating the corresponding locks.
482  {
483 #ifdef R__USE_IMT
484  static void (*sym)() = (void(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_DisableParTreeProcessing");
485  if (sym)
486  sym();
487 #else
488  ::Warning("DisableParTreeProcessing", "Cannot disable parallel tree processing, please build ROOT with -Dimt=ON");
489 #endif
490  }
491 
492  ////////////////////////////////////////////////////////////////////////////////
493  /// Returns true if parallel tree processing is enabled.
495  {
496 #ifdef R__USE_IMT
497  static Bool_t (*sym)() = (Bool_t(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_IsParTreeProcessingEnabled");
498  if (sym)
499  return sym();
500  else
501  return kFALSE;
502 #else
503  return kFALSE;
504 #endif
505  }
506 
507  ////////////////////////////////////////////////////////////////////////////////
508  /// Keeps track of the status of ImplicitMT w/o resorting to the load of
509  /// libImt
511  {
512  static Bool_t isImplicitMTEnabled = kFALSE;
513  return isImplicitMTEnabled;
514  }
515 
516 } // end of Internal sub namespace
517 // back to ROOT namespace
518 
520  return (*Internal::gGetROOT)();
521  }
522 
524  static TString macroPath;
525  return macroPath;
526  }
527 
528  // clang-format off
529  ////////////////////////////////////////////////////////////////////////////////
530  /// Enables the global mutex to make ROOT thread safe/aware.
531  ///
532  /// The following becomes safe:
533  /// - concurrent construction and destruction of TObjects, including the ones registered in ROOT's global lists (e.g. gROOT->GetListOfCleanups(), gROOT->GetListOfFiles())
534  /// - 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)
535  /// - concurrent calls to ROOT's type system classes, e.g. TClass and TEnum
536  /// - concurrent calls to the interpreter through gInterpreter
537  /// - concurrent loading of ROOT plug-ins
538  ///
539  /// In addition, gDirectory, gFile and gPad become a thread-local variable.
540  /// In all threads, gDirectory defaults to gROOT, a singleton which supports thread-safe insertion and deletion of contents.
541  /// gFile and gPad default to nullptr, as it is for single-thread programs.
542  ///
543  /// The ROOT graphics subsystem is not made thread-safe by this method. In particular drawing or printing different
544  /// canvases from different threads (and analogous operations such as invoking `Draw` on a `TObject`) is not thread-safe.
545  ///
546  /// Note that there is no `DisableThreadSafety()`. ROOT's thread-safety features cannot be disabled once activated.
547  // clang-format on
549  {
550  static void (*sym)() = (void(*)())Internal::GetSymInLibImt("ROOT_TThread_Initialize");
551  if (sym)
552  sym();
553  }
554 
555  ////////////////////////////////////////////////////////////////////////////////
556  /// @param[in] numthreads Number of threads to use. If not specified or
557  /// set to zero, the number of threads is automatically
558  /// decided by the implementation. Any other value is
559  /// used as a hint.
560  ///
561  /// ROOT must be built with the compilation flag `imt=ON` for this feature to be available.
562  /// The following objects and methods automatically take advantage of
563  /// multi-threading if a call to `EnableImplicitMT` has been made before usage:
564  ///
565  /// - RDataFrame internally runs the event-loop by parallelizing over clusters of entries
566  /// - TTree::GetEntry reads multiple branches in parallel
567  /// - TTree::FlushBaskets writes multiple baskets to disk in parallel
568  /// - TTreeCacheUnzip decompresses the baskets contained in a TTreeCache in parallel
569  /// - THx::Fit performs in parallel the evaluation of the objective function over the data
570  /// - TMVA::DNN trains the deep neural networks in parallel
571  /// - TMVA::BDT trains the classifier in parallel and multiclass BDTs are evaluated in parallel
572  ///
573  /// EnableImplicitMT calls in turn EnableThreadSafety.
574  /// The 'numthreads' parameter allows to control the number of threads to
575  /// be used by the implicit multi-threading. However, this parameter is just
576  /// a hint for ROOT: it will try to satisfy the request if the execution
577  /// scenario allows it. For example, if ROOT is configured to use an external
578  /// scheduler, setting a value for 'numthreads' might not have any effect.
579  void EnableImplicitMT(UInt_t numthreads)
580  {
581 #ifdef R__USE_IMT
583  return;
585  static void (*sym)(UInt_t) = (void(*)(UInt_t))Internal::GetSymInLibImt("ROOT_TImplicitMT_EnableImplicitMT");
586  if (sym)
587  sym(numthreads);
589 #else
590  ::Warning("EnableImplicitMT", "Cannot enable implicit multi-threading with %d threads, please build ROOT with -Dimt=ON", numthreads);
591 #endif
592  }
593 
594  ////////////////////////////////////////////////////////////////////////////////
595  /// Disables the implicit multi-threading in ROOT (see EnableImplicitMT).
597  {
598 #ifdef R__USE_IMT
599  static void (*sym)() = (void(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_DisableImplicitMT");
600  if (sym)
601  sym();
603 #else
604  ::Warning("DisableImplicitMT", "Cannot disable implicit multi-threading, please build ROOT with -Dimt=ON");
605 #endif
606  }
607 
608  ////////////////////////////////////////////////////////////////////////////////
609  /// Returns true if the implicit multi-threading in ROOT is enabled.
611  {
613  }
614 
615  ////////////////////////////////////////////////////////////////////////////////
616  /// Returns the size of the pool used for implicit multi-threading.
618  {
619 #ifdef R__USE_IMT
620  static UInt_t (*sym)() = (UInt_t(*)())Internal::GetSymInLibImt("ROOT_TImplicitMT_GetImplicitMTPoolSize");
621  if (sym)
622  return sym();
623  else
624  return 0;
625 #else
626  return 0;
627 #endif
628  }
629 
630 
631 } // end of ROOT namespace
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 
642 ClassImp(TROOT);
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 
681 TROOT::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();
722  GetIncludeDir();
723  GetEtcDir();
724  GetDataDir();
725  GetDocDir();
726  GetMacroDir();
727  GetTutorialDir();
728  GetSourceDir();
729  GetIconPath();
730  GetTTFFontDir();
731 
732  gRootDir = GetRootSys().Data();
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;
745  fVersionInt = IVERSQ();
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;
756  fClassGenerators = new TList;
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;
778  fGlobalFunctions = 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
834  fCleanups->Add(fList);
835 
838  fFromPopUp = kFALSE;
840  fInterrupt = kFALSE;
841  fEscape = kFALSE;
842  fMustClean = kTRUE;
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");
892  fBrowsables->Add(workdir, gSystem->WorkingDirectory());
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
911  gGetROOT = &GetROOT1;
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 
949  fFunctions->Delete(); SafeDelete(fFunctions); // etc..
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;
1034  fgRootInit = kFALSE;
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 
1064 void 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 
1100 namespace {
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.
1256  if (fClosedObjects && fClosedObjects->First()) {
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();
1263  fGeometries->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 
1306 TObject *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 
1360 TObject *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 
1419 TObject *TROOT::FindObjectAny(const char *name) const
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 
1446 const 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 
1466 const 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 
1477 TClass *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;
1495  TClassEdit::GetNormalizedName(normalized, name);
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 
1511 TClass *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 
1521 TClass *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 
1555 TDataType *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 
1563 TFile *TROOT::GetFile(const char *name) const
1564 {
1566  return (TFile*)GetListOfFiles()->FindObject(name);
1567 }
1568 
1569 ////////////////////////////////////////////////////////////////////////////////
1570 /// Return pointer to style with name
1571 
1572 TStyle *TROOT::GetStyle(const char *name) const
1573 {
1574  return (TStyle*)GetListOfStyles()->FindObject(name);
1575 }
1576 
1577 ////////////////////////////////////////////////////////////////////////////////
1578 /// Return pointer to function with name.
1579 
1580 TObject *TROOT::GetFunction(const char *name) const
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 
1613 TGlobal *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 
1621 TGlobal *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 
1667 TFunction *TROOT::GetGlobalFunction(const char *function, const char *params,
1668  Bool_t load)
1669 {
1670  if (!params) {
1672  return (TFunction *)GetListOfGlobalFunctions(load)->FindObject(function);
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) {
1705  return (TFunction *)GetListOfGlobalFunctions(load)->FindObject(function);
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 
1729 TObject *TROOT::GetGeometry(const char *name) const
1730 {
1731  return GetListOfGeometries()->FindObject(name);
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) {
1773  fGlobals = new TListOfDataMembers(0);
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 
1782  TGlobalMappedFunction::MakeFunctor("gPad", "TVirtualPad*", TVirtualPad::Pad);
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 
1859 void 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 
1874 static 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 
1895 Int_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))
1974  gSystem->ResetSignals();
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 
2140 TClass *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 
2156 Int_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) &&
2184  !gSystem->AccessPathName(libname, kReadPermission)))
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 
2203 Bool_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 
2223 void 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 
2241 Int_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 
2289 Long_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 
2323 void 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 
2343 Long_t TROOT::ProcessLine(const char *line, Int_t *error)
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 
2453 const char *TROOT::GetGitDate()
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 
2481  fCleanups->RecursiveRemove(obj);
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 
2501 static 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 
2514 void 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 
2630 void TROOT::Reset(Option_t *option)
2631 {
2632  if (IsExecutingMacro()) return; //True when TMacro::Exec runs
2633  if (fInterpreter) {
2634  if (!strncmp(option, "a", 1)) {
2635  fInterpreter->Reset();
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 
2662 void TROOT::SetCutClassName(const char *name)
2663 {
2664  if (!name) {
2665  Error("SetCutClassName","Invalid class name");
2666  return;
2667  }
2668  TClass *cl = TClass::GetClass(name);
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  }
2677  fCutClassName = name;
2678 }
2679 
2680 ////////////////////////////////////////////////////////////////////////////////
2681 /// Set editor mode
2682 
2683 void 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 
2709 void 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 
2741 const char *TROOT::GetMacroPath()
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 
2767 void 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 
2793 void 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 {
2804  fIsWebDisplay = kTRUE;
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 
2898 const 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
2916 static 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 
3146 const char *TROOT::GetTutorialsDir() {
3147  return GetTutorialDir();
3148 }
TSeqCollection * fStreamerInfo
Definition: TROOT.h:169
const char * FindObjectPathName(const TObject *obj) const
Return path name of obj somewhere in the //root/...
Definition: TROOT.cxx:1466
virtual const char * BaseName(const char *pathname)
Base name of a file name. Base name of /user/root is root.
Definition: TSystem.cxx:926
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
Bool_t fExecutingMacro
Definition: TROOT.h:146
void AddClass(TClass *cl)
Add a class to the list and map of classes.
Definition: TROOT.cxx:1042
virtual void Add(TObject *obj)
TListOfFunctionTemplates * fFuncTemplate
Definition: TROOT.h:152
UInt_t GetImplicitMTPoolSize()
Returns the size of the pool used for implicit multi-threading.
Definition: TROOT.cxx:617
static const TString & GetTTFFontDir()
Get the fonts directory in the installation. Static utility function.
Definition: TROOT.cxx:3124
A TFolder object is a collection of objects and folders.
Definition: TFolder.h:30
TCanvas * MakeDefCanvas() const
Return a default canvas.
Definition: TROOT.cxx:1547
R__EXTERN TGuiFactory * gBatchGuiFactory
Definition: TGuiFactory.h:67
A collection of TDataMember objects designed for fast access given a DeclId_t and for keep track of T...
Semi-Abstract base class defining a generic interface to the underlying, low level, native graphics backend (X11, Win32, MacOS, OpenGL...).
Definition: TVirtualX.h:46
An array of TObjects.
Definition: TObjArray.h:37
virtual void Clear(Option_t *option="")=0
static Int_t DecreaseDirLevel()
Decrease the indentation level for ls().
Definition: TROOT.cxx:2725
const std::string & GetIncludeDir()
\ returns the include directory in the installation.
static Bool_t BlockAllSignals(Bool_t b)
Block or unblock all signals. Returns the previous block status.
Definition: TQObject.cxx:1055
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
Definition: TList.cxx:467
TFolder * fRootFolder
Definition: TROOT.h:177
TCollection * GetListOfEnums(Bool_t load=kFALSE)
Definition: TROOT.cxx:1736
ROOT top level object description.
Definition: TROOT.h:102
static const TString & GetMacroDir()
Get the macro directory in the installation. Static utility function.
Definition: TROOT.cxx:3029
void * DestroyInterpreter_t(TInterpreter *)
Definition: TInterpreter.h:552
This class is a specialized TProcessID managing the list of UUIDs.
Definition: TProcessUUID.h:32
TSeqCollection * fProofs
Definition: TROOT.h:172
static const TString & GetTutorialDir()
Get the tutorials directory in the installation. Static utility function.
Definition: TROOT.cxx:3050
static constexpr double mm
void RemoveClass(TClass *)
Remove a class from the list and map of classes.
Definition: TROOT.cxx:2607
TCollection * GetListOfGlobalFunctions(Bool_t load=kFALSE)
Return list containing the TFunctions currently defined.
Definition: TROOT.cxx:1808
virtual const char * WorkingDirectory()
Return working directory.
Definition: TSystem.cxx:863
Int_t LoadMacro(const char *filename, Int_t *error=0, Bool_t check=kFALSE)
Load a macro in the interpreter&#39;s memory.
Definition: TROOT.cxx:2241
Returns the available number of logical cores.
Definition: StringConv.hxx:21
static const char **& GetExtraInterpreterArgs()
INTERNAL function! Used by rootcling to inject interpreter arguments through a C-interface layer...
Definition: TROOT.cxx:2908
TLine * line
TSeqCollection * fGeometries
Definition: TROOT.h:164
R__EXTERN TClassTable * gClassTable
Definition: TClassTable.h:95
Handle messages that might be generated by the system.
TDictionary::DeclId_t DeclId_t
Definition: TInterpreter.h:283
const char Option_t
Definition: RtypesCore.h:62
Dictionary for function template This class describes one single function template.
virtual TString SplitAclicMode(const char *filename, TString &mode, TString &args, TString &io) const
This method split a filename of the form: ~~~ {.cpp} [path/]macro.C[+|++[k|f|g|O|c|s|d|v|-]][(args)]...
Definition: TSystem.cxx:4228
void DisableImplicitMT()
Disables the implicit multi-threading in ROOT (see EnableImplicitMT).
Definition: TROOT.cxx:596
static TVirtualX *& Instance()
Returns gVirtualX global.
Definition: TVirtualX.cxx:57
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
Short_t GetDeclFileLine() const
Definition: TClass.h:396
#define ROOT_RELEASE_TIME
Definition: RVersion.h:19
TList * fList
Definition: TDirectory.h:90
#define g(i)
Definition: RSha256.hxx:105
static const TString & GetIconPath()
Get the icon path in the installation. Static utility function.
Definition: TROOT.cxx:3103
R__EXTERN TVirtualMutex * gInterpreterMutex
Definition: TInterpreter.h:40
const Ssiz_t kNPOS
Definition: RtypesCore.h:111
This class represents a WWW compatible URL.
Definition: TUrl.h:35
Int_t fVersionDate
Definition: TROOT.h:125
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition: TString.h:687
Definition: Buttons.h:33
R__EXTERN TStyle * gStyle
Definition: TStyle.h:410
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
Bool_t fForceStyle
Definition: TROOT.h:143
virtual void HandleMessage(Int_t id, const TObject *obj)
Store message origin, keep statistics and call Notify().
Bool_t ReadingObject() const
Deprecated (will be removed in next release).
Definition: TROOT.cxx:2439
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition: TNamed.cxx:140
static Int_t RootVersionCode()
Return ROOT version code as defined in RVersion.h.
Definition: TROOT.cxx:2887
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
TInterpreter * CreateInterpreter_t(void *shlibHandle, const char *argv[])
Definition: TInterpreter.h:551
static Bool_t MemCheck()
Return kTRUE if the memory leak checker is on.
Definition: TROOT.cxx:2852
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format...
Definition: TFile.h:48
TString fVersion
Definition: TROOT.h:122
TVirtualPad * cd(Int_t subpadnumber=0)
Set current canvas & pad.
Definition: TCanvas.cxx:697
void R__SetZipMode(int)
#define ROOT_RELEASE_DATE
Definition: RVersion.h:18
virtual void AddAll(const TCollection *col)
Add all objects from collection col to this collection.
static void SetObjectStat(Bool_t stat)
Turn on/off tracking of objects in the TObjectTable.
Definition: TObject.cxx:968
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
This class implements a mutex interface.
Definition: TVirtualMutex.h:34
void DisableParTreeProcessing()
Globally disables the IMT use case of parallel branch processing, deactivating the corresponding lock...
Definition: TROOT.cxx:481
void InitInterpreter()
Initialize the interpreter.
Definition: TROOT.cxx:2037
Bool_t IsImplicitMTEnabled()
Returns true if the implicit multi-threading in ROOT is enabled.
Definition: TROOT.cxx:610
#define gROOT
Definition: TROOT.h:415
static void Initialize()
Initialize ROOT explicitly.
Definition: TROOT.cxx:2837
void LoadHandlersFromEnv(TEnv *env)
Load plugin handlers specified in config file, like: Plugin.TSQLServer: ^mysql: TMySQLServer MyS...
TROOT * GetROOT2()
Definition: TROOT.cxx:383
R__ALWAYS_INLINE Bool_t TestBit(UInt_t f) const
Definition: TObject.h:172
virtual int Load(const char *module, const char *entry="", Bool_t system=kFALSE)
Load a shared library.
Definition: TSystem.cxx:1845
The TEnv class reads config files, by default named .rootrc.
Definition: TEnv.h:125
Basic string class.
Definition: TString.h:131
void RefreshBrowsers()
Refresh all browsers.
Definition: TROOT.cxx:2491
static Func_t GetSymInLibImt(const char *funcname)
Definition: TROOT.cxx:397
#define f(i)
Definition: RSha256.hxx:104
TString & GetMacroPath()
Definition: TROOT.cxx:523
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
std::vector< std::pair< std::string, int > > FwdDeclArgsToKeepCollection_t
Definition: TInterpreter.h:133
static const TString & GetRootSys()
Get the rootsys directory in the installation. Static utility function.
Definition: TROOT.cxx:2925
#define gInterpreter
Definition: TInterpreter.h:555
virtual char * Which(const char *search, const char *file, EAccessMode mode=kFileExists)
Find location of file in a search path.
Definition: TSystem.cxx:1537
Int_t fVersionCode
Definition: TROOT.h:124
Option_t * GetOption() const
Definition: TCollection.h:251
void Reset(Option_t *option="")
Delete all global interpreter objects created since the last call to Reset.
Definition: TROOT.cxx:2630
Definition: Buttons.h:30
void Load()
Load all the DataMembers known to the interpreter for the scope &#39;fClass&#39; into this collection...
void SetName(const char *newname) override
Set the name for directory If the directory name is changed after the directory was written once...
TFunction * Get(DeclId_t id)
Return (after creating it if necessary) the TMethod or TFunction describing the function correspondin...
This class registers for all classes their name, id and dictionary function in a hash table...
Definition: TClassTable.h:36
STL namespace.
#define ROOT_VERSION_CODE
Definition: RVersion.h:21
static Bool_t & IsImplicitMTEnabledImpl()
Keeps track of the status of ImplicitMT w/o resorting to the load of libImt.
Definition: TROOT.cxx:510
virtual TObject * FindObjectAny(const char *name) const
Return a pointer to the first object with name starting at this folder.
Definition: TFolder.cxx:352
TObject * At(Int_t idx) const
Definition: TObjArray.h:166
virtual void ResetSignals()
Reset signals handlers to previous behaviour.
Definition: TSystem.cxx:578
std::atomic< TApplication * > fApplication
Definition: TROOT.h:133
void SetStyle(const char *stylename="Default")
Change current style to style with name stylename.
Definition: TROOT.cxx:2709
TDataType * GetType(const char *name, Bool_t load=kFALSE) const
Return pointer to type with name.
Definition: TROOT.cxx:1555
TCollection * GetListOfGlobals(Bool_t load=kFALSE)
Return list containing the TGlobals currently defined.
Definition: TROOT.cxx:1770
TString fGitCommit
Definition: TROOT.h:129
TStyle * GetStyle(const char *name) const
Return pointer to style with name.
Definition: TROOT.cxx:1572
void ls(Option_t *option="") const
To list all objects of the application.
Definition: TROOT.cxx:2223
void BuildDirectory(TFile *motherFile, TDirectory *motherDir)
Initialise directory to defaults.
Definition: TDirectory.cxx:237
static const TString & GetIncludeDir()
Get the include directory in the installation. Static utility function.
Definition: TROOT.cxx:2977
TROOT * GetROOT1()
Definition: TROOT.cxx:376
TObject * Remove(TObject *)
Remove an object from the in-memory list.
Definition: TROOT.cxx:2597
Bool_t R_ISREG(Int_t mode)
Definition: TSystem.h:118
virtual void AddLast(TObject *obj)
Add object at the end of the list.
Definition: TList.cxx:149
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:693
TString fCutClassName
Definition: TROOT.h:180
Bool_t & GetReadingObject()
Definition: TROOT.cxx:2431
static const char * GetTutorialsDir()
Get the tutorials directory in the installation.
Definition: TROOT.cxx:3146
TListOfFunctions * GetGlobalFunctions()
Internal routine returning, and creating if necessary, the list of global function.
Definition: TROOT.cxx:1645
static Int_t fgDirLevel
Definition: TROOT.h:110
Definition: Buttons.h:30
static const char * GetMacroPath()
Get macro search path. Static utility function.
Definition: TROOT.cxx:2741
TInterpreter * fInterpreter
Definition: TROOT.h:134
Int_t fMode
Definition: TSystem.h:127
static TList & GetEarlyRegisteredGlobals()
Returns list collected globals Used to storeTGlobalMappedFunctions from other libs, before gROOT was initialized.
Definition: TGlobal.cxx:185
const char * GetGitDate()
Return date/time make was run.
Definition: TROOT.cxx:2453
AListOfEnums_t fEnums
Definition: TROOT.h:175
TObject * GetFunction(const char *name) const
Return pointer to function with name.
Definition: TROOT.cxx:1580
TSeqCollection * fMappedFiles
Definition: TROOT.h:157
virtual void Delete(Option_t *option="")=0
Delete this object.
void ls(Option_t *option="") const override
List Directory contents.
Sequenceable collection abstract base class.
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition: TObject.cxx:127
static void * gInterpreterLib
Definition: TROOT.cxx:175
TVirtualMutex * gROOTMutex
Definition: TROOT.cxx:178
THashTable implements a hash table to store TObject&#39;s.
Definition: THashTable.h:35
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
static TVirtualPad *& Pad()
Return the current pad for the current thread.
Definition: TVirtualPad.cxx:28
Int_t fVersionInt
Definition: TROOT.h:123
THashList implements a hybrid collection class consisting of a hash table and a list to store TObject...
Definition: THashList.h:34
Bool_t IsParTreeProcessingEnabled()
Returns true if parallel tree processing is enabled.
Definition: TROOT.cxx:494
void SetEditorMode(const char *mode="")
Set editor mode.
Definition: TROOT.cxx:2683
TSeqCollection * fCleanups
Definition: TROOT.h:167
Int_t fEditorMode
Definition: TROOT.h:147
Bool_t fMustClean
Definition: TROOT.h:141
static Bool_t Initialized()
Return kTRUE if the TROOT object has been initialized.
Definition: TROOT.cxx:2844
void EndOfProcessCleanups()
Execute the cleanups necessary at the end of the process, in particular those that must be executed b...
Definition: TROOT.cxx:1244
R__DLLEXPORT TInterpreter * CreateInterpreter(void *interpLibHandle, const char *argv[])
Definition: TCling.cxx:604
static Bool_t fgRootInit
Definition: TROOT.h:111
virtual TObject * FindObjectAny(const char *name) const
Return a pointer to the first object with name starting at //root.
Definition: TROOT.cxx:1419
Long_t ProcessLineSync(const char *line, Int_t *error=0)
Process interpreter command via TApplication::ProcessLine().
Definition: TROOT.cxx:2363
void Message(Int_t id, const TObject *obj)
Process message id called by obj.
Definition: TROOT.cxx:2323
void EnableParTreeProcessing()
Globally enables the parallel tree processing, which is a case of implicit multi-threading in ROOT...
Definition: TROOT.cxx:465
virtual const char * Getenv(const char *env)
Get environment variable.
Definition: TSystem.cxx:1654
static const TString & GetDocDir()
Get the documentation directory in the installation. Static utility function.
Definition: TROOT.cxx:3013
TCollection * GetListOfFunctionTemplates()
Definition: TROOT.cxx:1753
static void CreateApplication()
virtual const char * PrependPathName(const char *dir, TString &name)
Concatenate a directory and a file name.
Definition: TSystem.cxx:1072
Bool_t EndsWith(const char *pat, ECaseCompare cmp=kExact) const
Return true if string ends with the specified string.
Definition: TString.cxx:2177
static Int_t ITIMQQ(const char *time)
Return built time as integer (with min precision), i.e.
Definition: TROOT.cxx:219
void SaveContext()
Save the current interpreter context.
Definition: TROOT.cxx:2650
virtual void Close(Option_t *option="")
Delete all objects from memory and directory structure itself.
Definition: TDirectory.cxx:584
ClassInfo_t * GetClassInfo() const
Definition: TClass.h:400
virtual void Delete(Option_t *option="")
Delete all TFunction object files.
R__EXTERN TVirtualRWMutex * gCoreMutex
virtual bool UseRWLock()
Set this collection to use a RW lock upon access, making it thread safe.
virtual TList * GetList() const
Definition: TDirectory.h:159
static constexpr double s
TCollection * GetListOfFunctionOverloads(const char *name) const
Return the collection of functions named "name".
Definition: TROOT.cxx:1654
TString fWebDisplay
Definition: TROOT.h:136
static void at_exit_of_TROOT()
Definition: TROOT.cxx:294
TSeqCollection * fClipboard
Definition: TROOT.h:173
virtual void Initialize()=0
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
TVirtualPad is an abstract base class for the Pad and Canvas classes.
Definition: TVirtualPad.h:50
R__EXTERN TGuiFactory * gGuiFactory
Definition: TGuiFactory.h:66
static void Cleanup()
static function (called by TROOT destructor) to delete all TProcessIDs
Definition: TProcessID.cxx:202
void Error(const char *location, const char *msgfmt,...)
R__EXTERN TPluginManager * gPluginMgr
Definition: Buttons.h:38
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
Bool_t fEscape
Definition: TROOT.h:145
TSeqCollection * fFiles
Definition: TROOT.h:156
TSeqCollection * GetListOfGeometries() const
Definition: TROOT.h:254
Describes an Operating System directory for the browser.
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...
void EnableImplicitMT(UInt_t numthreads=0)
Enable ROOT&#39;s implicit multi-threading for all objects and methods that provide an internal paralleli...
Definition: TROOT.cxx:579
TCollection * fClasses
Definition: TROOT.h:150
A doubly linked list.
Definition: TList.h:44
Long_t Macro(const char *filename, Int_t *error=0, Bool_t padUpdate=kTRUE)
Execute a macro in the interpreter.
Definition: TROOT.cxx:2289
R__EXTERN TVirtualMutex * gGlobalMutex
Definition: TVirtualMutex.h:29
TStyle objects may be created to define special styles.
Definition: TStyle.h:27
R__EXTERN TROOT * gROOTLocal
Definition: TROOT.h:388
Bool_t fEditHistograms
Definition: TROOT.h:139
#define R__READ_LOCKGUARD(mutex)
Using a TBrowser one can browse all ROOT objects.
Definition: TBrowser.h:37
virtual void AddLast(TObject *obj)=0
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
Int_t fVersionTime
Definition: TROOT.h:126
virtual void RecursiveRemove(TObject *obj)
Remove object from this collection and recursively remove the object from all other objects (and coll...
R__EXTERN TVirtualX * gGXBatch
Definition: TVirtualX.h:341
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
static Bool_t fgMemCheck
Definition: TROOT.h:112
Bool_t IsParBranchProcessingEnabled()
Returns true if parallel branch processing is enabled.
Definition: TROOT.cxx:445
TSeqCollection * fDataSets
Definition: TROOT.h:174
Definition: Buttons.h:33
virtual TObject * FindObject(const char *name) const
Must be redefined in derived classes.
Definition: TObject.cxx:320
TSeqCollection * fMessageHandlers
Definition: TROOT.h:168
void Browse(TBrowser *b)
Add browsable objects to TBrowser.
Definition: TROOT.cxx:1073
virtual Bool_t Init()
Initialize the OS interface.
Definition: TSystem.cxx:175
void AddClassGenerator(TClassGenerator *gen)
Add a class generator.
Definition: TROOT.cxx:1052
TString fDefCanvasName
Definition: TROOT.h:181
R__EXTERN TSystem * gSystem
Definition: TSystem.h:557
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
TGlobal * GetGlobal(const char *name, Bool_t load=kFALSE) const
Return pointer to global variable by name.
Definition: TROOT.cxx:1613
Definition: Buttons.h:33
if object ctor succeeded but object should not be used
Definition: TObject.h:68
void GetNormalizedName(std::string &norm_name, std::string_view name)
Return the normalized name.
Definition: TClassEdit.cxx:832
Basic data type descriptor (datatype information is obtained from CINT).
Definition: TDataType.h:44
auto * a
Definition: textangle.C:12
Int_t gDebug
Definition: TROOT.cxx:639
TPluginManager * fPluginManager
Definition: TROOT.h:179
TString fGitBranch
Definition: TROOT.h:130
virtual Bool_t InheritsFrom(const char *classname) const
Returns kTRUE if object inherits from class "classname".
Definition: TObject.cxx:442
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
Definition: TString.h:610
TSeqCollection * fSecContexts
Definition: TROOT.h:171
Collection abstract base class.
Definition: TCollection.h:63
void(* VoidFuncPtr_t)()
Definition: Rtypes.h:77
static Int_t ConvertVersionCode2Int(Int_t code)
Convert version code to an integer, i.e. 331527 -> 51507.
Definition: TROOT.cxx:2868
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition: TString.cxx:2289
unsigned int UInt_t
Definition: RtypesCore.h:42
void ReadGitInfo()
Read Git commit information and branch name from the etc/gitinfo.txt file.
Definition: TROOT.cxx:2402
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:887
void SetWebDisplay(const char *webdisplay)
Specify where web graphics shall be rendered.
Definition: TROOT.cxx:2793
virtual TObject * FindObject(const char *name) const
Returns address of a ROOT object if it exists.
Definition: TROOT.cxx:1306
Ssiz_t Length() const
Definition: TString.h:405
TObject * GetGeometry(const char *name) const
Return pointer to Geometry with name.
Definition: TROOT.cxx:1729
virtual void Append(TObject *obj, Bool_t replace=kFALSE)
Append object to this directory.
Definition: TDirectory.cxx:190
static void EnableStatistics(int size=-1, int ix=-1)
Enable memory usage statistics gathering.
Definition: TStorage.cxx:450
This class implements a plugin library manager.
static const TString & GetSourceDir()
Get the source directory in the installation. Static utility function.
Definition: TROOT.cxx:3082
TSubString Strip(EStripType s=kTrailing, char c=' ') const
Return a substring of self stripped at beginning and/or end.
Definition: TString.cxx:1106
virtual const char * HomeDirectory(const char *userName=nullptr)
Return the user&#39;s home directory.
Definition: TSystem.cxx:879
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
Objects following this interface can be passed onto the TROOT object to implement a user customized w...
static void IndentLevel()
Functions used by ls() to indent an object hierarchy.
Definition: TROOT.cxx:2829
static TProcessID * AddProcessID()
Static function to add a new TProcessID to the list of PIDs.
Definition: TProcessID.cxx:114
TClass instances represent classes, structs and namespaces in the ROOT type system.
Definition: TClass.h:75
virtual void Append(TObject *obj, Bool_t replace=kFALSE)
Append object to this directory.
Definition: TROOT.cxx:1064
TFile * GetFile() const
Definition: TROOT.h:270
virtual void SaveContext()=0
Global variables class (global variables are obtained from CINT).
Definition: TGlobal.h:28
Bool_t InheritsFrom(const char *cl) const
Return kTRUE if this class inherits from a class with name "classname".
Definition: TClass.cxx:4753
A collection of TDataType designed to hold the typedef information and numerical type information...
Definition: TListOfTypes.h:30
TROOT * GetROOT()
Definition: TROOT.cxx:519
void Warning(const char *location, const char *msgfmt,...)
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
void InitSystem()
Initialize operating system interface.
Definition: TROOT.cxx:1945
if object destructor must call RecursiveRemove()
Definition: TObject.h:60
#define gVirtualX
Definition: TVirtualX.h:338
TSeqCollection * fSpecials
Definition: TROOT.h:166
virtual TObjLink * FirstLink() const
Definition: TList.h:108
const Bool_t kFALSE
Definition: RtypesCore.h:88
static void RemoveClass(TClass *cl)
static: Remove a class from the list and map of classes
Definition: TClass.cxx:476
TString fGitDate
Definition: TROOT.h:131
static void SetDirLevel(Int_t level=0)
Return Indentation level for ls().
Definition: TROOT.cxx:2860
#define SafeDelete(p)
Definition: RConfig.hxx:543
TString & Remove(Ssiz_t pos)
Definition: TString.h:668
long Long_t
Definition: RtypesCore.h:50
The Canvas class.
Definition: TCanvas.h:27
const std::string & GetRootSys()
Bool_t IsExecutingMacro() const
Definition: TROOT.h:290
TSeqCollection * GetListOfColors() const
Definition: TROOT.h:242
TListOfFunctions * fGlobalFunctions
Definition: TROOT.h:154
#define d(i)
Definition: RSha256.hxx:102
Long_t ProcessLine(const char *line, Int_t *error=0)
Process interpreter command via TApplication::ProcessLine().
Definition: TROOT.cxx:2343
A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum t...
The file contains utilities which are foundational and could be used across the core component of ROO...
TSeqCollection * fCanvases
Definition: TROOT.h:159
static void BuildStyles()
Create some standard styles.
Definition: TStyle.cxx:427
virtual TObject * Remove(TObject *)
Remove an object from the in-memory list.
#define ClassImp(name)
Definition: Rtypes.h:365
void EnableThreadSafety()
Enables the global mutex to make ROOT thread safe/aware.
Definition: TROOT.cxx:548
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 DestroyInterpreter_t * gDestroyInterpreter
Definition: TROOT.cxx:174
void SetReadingObject(Bool_t flag=kTRUE)
Definition: TROOT.cxx:2444
virtual Func_t DynFindSymbol(const char *module, const char *entry)
Find specific entry point in specified library.
Definition: TSystem.cxx:2046
Ssiz_t Last(char c) const
Find last occurrence of a character c.
Definition: TString.cxx:892
char * DynamicPathName(const char *lib, Bool_t quiet=kFALSE)
Find a dynamic library called lib using the system search paths.
Definition: TSystem.cxx:2022
TString fConfigOptions
Definition: TROOT.h:120
void InitThreads()
Load and initialize thread library.
Definition: TROOT.cxx:2026
void RecursiveRemove(TObject *obj)
Recursively remove this object from the list of Cleanups.
Definition: TROOT.cxx:2477
void Unload()
Mark &#39;all func&#39; as being unloaded.
Describe directory structure in memory.
Definition: TDirectory.h:34
static TDirectory *& CurrentDirectory()
Return the current directory for the current thread.
Definition: TDirectory.cxx:380
R__EXTERN TEnv * gEnv
Definition: TEnv.h:171
TSeqCollection * GetListOfStyles() const
Definition: TROOT.h:251
static void AddClass(TClass *cl)
static: Add a class to the list and map of classes.
Definition: TClass.cxx:450
TSeqCollection * GetListOfFiles() const
Definition: TROOT.h:247
static const TString & GetEtcDir()
Get the sysconfig directory in the installation. Static utility function.
Definition: TROOT.cxx:2987
Definition: Buttons.h:31
Bool_t fFromPopUp
Definition: TROOT.h:140
static RooMathCoreReg dummy
Int_t fTimer
Definition: TROOT.h:132
TCanvas * style()
Definition: style.C:1
static void CallCloseFiles()
Insure that the files, canvases and sockets are closed.
Definition: TROOT.cxx:2501
void EnableParBranchProcessing()
Globally enables the parallel branch processing, which is a case of implicit multi-threading (IMT) in...
Definition: TROOT.cxx:416
Bool_t fBatch
Definition: TROOT.h:135
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:619
Long_t ProcessLineFast(const char *line, Int_t *error=0)
Process interpreter command directly via CINT interpreter.
Definition: TROOT.cxx:2380
void CloseFiles()
Close any files and sockets that gROOT knows about.
Definition: TROOT.cxx:1166
virtual ~TROOT()
Clean up and free resources used by ROOT (files, network sockets, shared memory segments, etc.).
Definition: TROOT.cxx:904
#define R__LOCKGUARD(mutex)
The color creation and management class.
Definition: TColor.h:19
TSeqCollection * fStyles
Definition: TROOT.h:160
virtual void Add(TObject *obj)=0
virtual void CleanCompiledMacros()
Remove the shared libs produced by the CompileMacro() function.
Definition: TSystem.cxx:4338
Bool_t fReadingObject
Definition: TROOT.h:142
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
virtual void Clear(Option_t *option="")
Remove all objects from the list.
Definition: TList.cxx:399
TCollection * fClassGenerators
Definition: TROOT.h:170
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
static TClass * LoadClass(const char *requestedname, Bool_t silent)
Helper function used by TClass::GetClass().
Definition: TClass.cxx:5544
virtual void Reset()=0
Bool_t IsNull() const
Definition: TString.h:402
const char * GetDeclFileName() const
Return name of the file containing the declaration of this class.
Definition: TClass.cxx:3323
virtual void Delete(Option_t *option="")
Delete all TDataMember object files.
static Int_t GetDirLevel()
return directory level
Definition: TROOT.cxx:2733
Int_t fBuiltTime
Definition: TROOT.h:128
Mother of all ROOT objects.
Definition: TObject.h:37
Global functions class (global functions are obtained from CINT).
Definition: TFunction.h:28
Bool_t fIsWebDisplay
Definition: TROOT.h:137
This ABC is a factory for GUI components.
Definition: TGuiFactory.h:42
TFunction * GetGlobalFunction(const char *name, const char *params=0, Bool_t load=kFALSE)
Return pointer to global function by name.
Definition: TROOT.cxx:1667
std::vector< std::pair< std::string, int > > FwdDeclArgsToKeepCollection_t
Definition: TROOT.h:197
static Int_t ConvertVersionInt2Code(Int_t v)
Convert version as an integer to version code as used in RVersion.h.
Definition: TROOT.cxx:2876
static Int_t IncreaseDirLevel()
Increase the indentation level for ls().
Definition: TROOT.cxx:2821
typedef void((*Func_t)())
TCollection * GetListOfTypes(Bool_t load=kFALSE)
Return a dynamic list giving access to all TDataTypes (typedefs) currently defined.
Definition: TROOT.cxx:1847
static const TString & GetDataDir()
Get the data directory in the installation. Static utility function.
Definition: TROOT.cxx:2997
Int_t fBuiltDate
Definition: TROOT.h:127
void Unload()
Mark &#39;all func&#39; as being unloaded.
TFunctionTemplate * GetFunctionTemplate(const char *name)
Definition: TROOT.cxx:1600
TColor * GetColor(Int_t color) const
Return address of color with index color.
Definition: TROOT.cxx:1529
void Load()
Load all the functions known to the interpreter for the scope &#39;fClass&#39; into this collection.
Bool_t fIsWebDisplayBatch
Definition: TROOT.h:138
TCollection * fFunctions
Definition: TROOT.h:161
const char * FindObjectClassName(const char *name) const
Returns class name of a ROOT object including CINT globals.
Definition: TROOT.cxx:1446
static void SetMacroPath(const char *newpath)
Set or extend the macro search path.
Definition: TROOT.cxx:2767
TROOT *(* GetROOTFun_t)()
Definition: TROOT.cxx:393
static Int_t IDATQQ(const char *date)
Return built date as integer, i.e. "Apr 28 2000" -> 20000428.
Definition: TROOT.cxx:198
virtual void Add(TObject *obj)
Definition: TList.h:87
auto * l
Definition: textangle.C:4
TListOfDataMembers * fGlobals
Definition: TROOT.h:153
static const TString & GetLibDir()
Get the library directory in the installation. Static utility function.
Definition: TROOT.cxx:2956
R__EXTERN const char * gRootDir
Definition: TSystem.h:241
TSeqCollection * fClosedObjects
Definition: TROOT.h:155
TClass * FindSTLClass(const char *name, Bool_t load, Bool_t silent=kFALSE) const
return a TClass object corresponding to &#39;name&#39; assuming it is an STL container.
Definition: TROOT.cxx:1477
#define ROOT_RELEASE
Definition: RVersion.h:17
TF1 * f1
Definition: legend1.C:11
static Int_t IVERSQ()
Return version id as an integer, i.e. "2.22/04" -> 22204.
Definition: TROOT.cxx:188
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
Int_t fLineIsProcessing
Definition: TROOT.h:108
TSeqCollection * fTasks
Definition: TROOT.h:162
static void CleanUpROOTAtExit()
Clean up at program termination before global objects go out of scope.
Definition: TROOT.cxx:229
TSeqCollection * fColors
Definition: TROOT.h:163
Int_t GetNumber() const
Definition: TColor.h:55
TCollection * fTypes
Definition: TROOT.h:151
#define gPad
Definition: TVirtualPad.h:287
virtual TObject * FindObject(const char *name) const
Find an object in this collection using its name.
const char * proto
Definition: civetweb.c:16604
object has not been deleted
Definition: TObject.h:78
#define c(i)
Definition: RSha256.hxx:101
TSeqCollection * fBrowsers
Definition: TROOT.h:165
static GetROOTFun_t gGetROOT
Definition: TROOT.cxx:395
static void ShutDown()
Shut down ROOT.
Definition: TROOT.cxx:3071
static void MakeFunctor(const char *name, const char *type, GlobFunc &func)
Definition: TGlobal.h:73
#define gDirectory
Definition: TDirectory.h:223
static void InitializeColors()
Initialize colors used by the TCanvas based graphics (via TColor objects).
Definition: TColor.cxx:1083
virtual TObject * FindObjectAnyFile(const char *name) const
Scan the memory lists of all files for an object with name.
Definition: TROOT.cxx:1429
static const TString & GetBinDir()
Get the binary directory in the installation. Static utility function.
Definition: TROOT.cxx:2935
TList * fBrowsables
Definition: TROOT.h:178
A collection of TFunction objects designed for fast access given a DeclId_t and for keep track of TFu...
TSeqCollection * fSockets
Definition: TROOT.h:158
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
Definition: TObject.cxx:915
TObject * FindSpecialObject(const char *name, void *&where)
Returns address and folder of a ROOT object if it exists.
Definition: TROOT.cxx:1360
R__EXTERN TInterpreter * gCling
Definition: TInterpreter.h:556
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:356
virtual Int_t GetSize() const
Return the capacity of the collection, i.e.
Definition: TCollection.h:182
Bool_t fInterrupt
Definition: TROOT.h:144
Abstract base class defining a generic interface to the underlying Operating System.
Definition: TSystem.h:266
virtual void SetTitle(const char *title="")
Set the title of the TNamed.
Definition: TNamed.cxx:164
void Idle(UInt_t idleTimeInSec, const char *command=0)
Execute command when system has been idle for idleTimeInSec seconds.
Definition: TROOT.cxx:1859
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
Definition: TEnv.cxx:491
TSeqCollection * GetListOfBrowsers() const
Definition: TROOT.h:255
const Bool_t kTRUE
Definition: RtypesCore.h:87
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
#define sym(otri1, otri2)
Definition: triangle.c:932
const std::string & GetEtcDir()
static TClass * R__GetClassIfKnown(const char *className)
Check whether className is a known class, and only autoload if we can.
Definition: TROOT.cxx:1874
char name[80]
Definition: TGX11.cxx:109
TString fConfigFeatures
Definition: TROOT.h:121
TProcessUUID * fUUIDs
Definition: TROOT.h:176
void DisableParBranchProcessing()
Globally disables the IMT use case of parallel branch processing, deactivating the corresponding lock...
Definition: TROOT.cxx:432
static void PrintStatistics()
Print memory usage statistics.
Definition: TStorage.cxx:406
const TObject * fPrimitive
Definition: TROOT.h:148
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:873
TVirtualPad * fSelectPad
Definition: TROOT.h:149
virtual TObject * First() const =0
virtual TObject * Last() const =0
TDictionary * Get(DeclId_t id)
Return (after creating it if necessary) the TDataMember describing the data member corresponding to t...
const char * Data() const
Definition: TString.h:364
TROOT()
Default ctor.
Definition: TROOT.cxx:647