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