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