Logo ROOT   6.08/07
Reference Guide
TCling.h
Go to the documentation of this file.
1 // @(#)root/meta:$Id$
2 // Author: Axel Naumann, 2011-10-19
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2012, 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 
13 #ifndef ROOT_TCling
14 #define ROOT_TCling
15 
16 //////////////////////////////////////////////////////////////////////////
17 // //
18 // TCling //
19 // //
20 // This class defines an interface to the cling C++ interpreter. //
21 // //
22 // Cling is a full ANSI compliant C++-11 interpreter based on //
23 // clang/LLVM technology. //
24 // //
25 //////////////////////////////////////////////////////////////////////////
26 
27 #ifndef ROOT_TInterpreter
28 #include "TInterpreter.h"
29 #endif
30 #ifndef ROOT_Rtypeinfo
31 #include "Rtypeinfo.h"
32 #endif
33 
34 #include <set>
35 #include <unordered_set>
36 #include <unordered_map>
37 #include <map>
38 #include <vector>
39 
40 #ifndef WIN32
41 #define TWin32SendClass char
42 #endif
43 
44 namespace llvm {
45  class GlobalValue;
46 }
47 
48 namespace clang {
49  class CXXRecordDecl;
50  class Decl;
51  class DeclContext;
52  class EnumDecl;
53  class FunctionDecl;
54  class NamespaceDecl;
55  class Type;
56  class QualType;
57 }
58 namespace cling {
59  class Interpreter;
60  class MetaProcessor;
61  class Transaction;
62  class Value;
63 }
64 
65 class TClingCallbacks;
66 class TEnv;
67 class THashTable;
68 class TInterpreterValue;
69 class TMethod;
70 class TObjArray;
71 
72 namespace ROOT {
73  namespace TMetaUtils {
74  class TNormalizedCtxt;
75  class TClingLookupHelper;
76  }
77 }
78 
79 extern "C" {
80  void TCling__UpdateListsOnCommitted(const cling::Transaction&,
81  cling::Interpreter*);
82  void TCling__UpdateListsOnUnloaded(const cling::Transaction&);
83  void TCling__TransactionRollback(const cling::Transaction&);
84  TObject* TCling__GetObjectAddress(const char *Name, void *&LookupCtx);
85  const clang::Decl* TCling__GetObjectDecl(TObject *obj);
86  void TCling__LibraryLoaded(const void* dyLibHandle,
87  const char* canonicalName);
88  void TCling__LibraryUnloaded(const void* dyLibHandle,
89  const char* canonicalName);
90 }
91 
92 class TCling : public TInterpreter {
93 private: // Static Data Members
94 
95  static void* fgSetOfSpecials; // set of TObjects used in CINT variables
96 
97 private: // Data Members
98 
99  Int_t fMore; // The brace indent level for the cint command line processor.
100  Int_t fExitCode; // Value passed to exit() in interpreter.
101  char fPrompt[64]; // Command line prompt string.
102  //cling::DictPosition fDictPos; // dictionary context after initialization is complete.
103  //cling::DictPosition fDictPosGlobals; // dictionary context after ResetGlobals().
104  TString fSharedLibs; // Shared libraries loaded by G__loadfile().
105  Int_t fGlobalsListSerial;// Last time we refreshed the ROOT list of globals.
106  TString fIncludePath; // Interpreter include path.
107  TString fRootmapLoadPath; // Dynamic load path for rootmap files.
108  TEnv* fMapfile; // Association of classes to libraries.
109  std::map<size_t,std::vector<const char*>> fClassesHeadersMap; // Map of classes hashes and headers associated
110  std::map<const cling::Transaction*,size_t> fTransactionHeadersMap; // Map which transaction contains which autoparse.
111  std::set<size_t> fLookedUpClasses; // Set of classes for which headers were looked up already
112  std::set<size_t> fPayloads; // Set of payloads
113  std::set<const char*> fParsedPayloadsAddresses; // Set of payloads which were parsed
114  std::hash<std::string> fStringHashFunction; // A simple hashing function
115  std::unordered_set<const clang::NamespaceDecl*> fNSFromRootmaps; // Collection of namespaces fwd declared in the rootmaps
116  TObjArray* fRootmapFiles; // Loaded rootmap files.
117  Bool_t fLockProcessLine; // True if ProcessLine should lock gInterpreterMutex.
118  Bool_t fAllowLibLoad; // True if library load is allowed (i.e. not in rootcling)
119 
120  cling::Interpreter* fInterpreter; // The interpreter.
121  cling::MetaProcessor* fMetaProcessor; // The metaprocessor.
122 
123  std::vector<cling::Value> *fTemporaries; // Stack of temporaries
124  ROOT::TMetaUtils::TNormalizedCtxt *fNormalizedCtxt; // Which typedef to avoid stripping.
125  ROOT::TMetaUtils::TClingLookupHelper *fLookupHelper; // lookup helper used by TClassEdit
126 
127  void* fPrevLoadedDynLibInfo; // Internal info to mark the last loaded libray.
128  std::vector<void*> fRegisterModuleDyLibs; // Stack of libraries currently running RegisterModule
129  TClingCallbacks* fClingCallbacks; // cling::Interpreter owns it.
130  struct CharPtrCmp_t {
131  bool operator()(const char* a, const char *b) const {
132  return strcmp(a, b) < 0;
133  }
134  };
135  std::set<TClass*> fModTClasses;
136  std::vector<std::pair<TClass*,DictFuncPtr_t> > fClassesToUpdate;
137  void* fAutoLoadCallBack;
138  ULong64_t fTransactionCount; // Cling counter for commited or unloaded transactions which changed the AST.
139  std::vector<const char*> fCurExecutingMacros;
140 
141  typedef void* SpecialObjectLookupCtx_t;
142  typedef std::unordered_map<std::string, TObject*> SpecialObjectMap_t;
143  std::map<SpecialObjectLookupCtx_t, SpecialObjectMap_t> fSpecialObjectMaps;
144 
145  DeclId_t GetDeclId(const llvm::GlobalValue *gv) const;
146 
147  Bool_t fHeaderParsingOnDemand;
148  Bool_t fIsAutoParsingSuspended;
149 
150  UInt_t AutoParseImplRecurse(const char *cls, bool topLevel);
151 
152 protected:
153  Bool_t SetSuspendAutoParsing(Bool_t value);
154 
155 public: // Public Interface
156 
157  virtual ~TCling();
158  TCling(const char* name, const char* title);
159 
160  cling::Interpreter *GetInterpreter() { return fInterpreter; }
161 
162  void AddIncludePath(const char* path);
163  void *GetAutoLoadCallBack() const { return fAutoLoadCallBack; }
164  void *SetAutoLoadCallBack(void* cb) { void* prev = fAutoLoadCallBack; fAutoLoadCallBack = cb; return prev; }
165  Int_t AutoLoad(const char *classname, Bool_t knowDictNotLoaded = kFALSE);
166  Int_t AutoLoad(const std::type_info& typeinfo, Bool_t knowDictNotLoaded = kFALSE);
167  Int_t AutoParse(const char* cls);
168  void* LazyFunctionCreatorAutoload(const std::string& mangled_name);
169  Bool_t IsAutoLoadNamespaceCandidate(const char* name);
170  Bool_t IsAutoLoadNamespaceCandidate(const clang::NamespaceDecl* nsDecl);
171  void ClearFileBusy();
172  void ClearStack(); // Delete existing temporary values
173  Bool_t Declare(const char* code);
174  void EnableAutoLoading();
175  void EndOfLineAction();
176  TClass *GetClass(const std::type_info& typeinfo, Bool_t load) const;
177  Int_t GetExitCode() const { return fExitCode; }
178  TEnv* GetMapfile() const { return fMapfile; }
179  Int_t GetMore() const { return fMore; }
180  TClass *GenerateTClass(const char *classname, Bool_t emulation, Bool_t silent = kFALSE);
181  TClass *GenerateTClass(ClassInfo_t *classinfo, Bool_t silent = kFALSE);
182  Int_t GenerateDictionary(const char* classes, const char* includes = 0, const char* options = 0);
183  char* GetPrompt() { return fPrompt; }
184  const char* GetSharedLibs();
185  const char* GetClassSharedLibs(const char* cls);
186  const char* GetSharedLibDeps(const char* lib);
187  const char* GetIncludePath();
188  virtual const char* GetSTLIncludePath() const;
189  TObjArray* GetRootMapFiles() const { return fRootmapFiles; }
190  unsigned long long GetInterpreterStateMarker() const { return fTransactionCount;}
191  virtual void Initialize();
192  void InspectMembers(TMemberInspector&, const void* obj, const TClass* cl, Bool_t isTransient);
193  Bool_t IsLoaded(const char* filename) const;
194  Int_t Load(const char* filenam, Bool_t system = kFALSE);
195  void LoadMacro(const char* filename, EErrorCode* error = 0);
196  Int_t LoadLibraryMap(const char* rootmapfile = 0);
197  Int_t RescanLibraryMap();
198  Int_t ReloadAllSharedLibraryMaps();
199  Int_t UnloadAllSharedLibraryMaps();
200  Int_t UnloadLibraryMap(const char* library);
201  Long_t ProcessLine(const char* line, EErrorCode* error = 0);
202  Long_t ProcessLineAsynch(const char* line, EErrorCode* error = 0);
203  Long_t ProcessLineSynch(const char* line, EErrorCode* error = 0);
204  void PrintIntro();
205  void RegisterModule(const char* modulename,
206  const char** headers,
207  const char** includePaths,
208  const char* payloadCode,
209  const char* fwdDeclsCode,
210  void (*triggerFunc)(),
211  const FwdDeclArgsToKeepCollection_t& fwdDeclsArgToSkip,
212  const char** classesHeaders,
213  Bool_t lateRegistration = false);
214  void RegisterTClassUpdate(TClass *oldcl,DictFuncPtr_t dict);
215  void UnRegisterTClassUpdate(const TClass *oldcl);
216 
217  Int_t SetClassSharedLibs(const char *cls, const char *libs);
218  void SetGetline(const char * (*getlineFunc)(const char* prompt),
219  void (*histaddFunc)(const char* line));
220  void Reset();
221  void ResetAll();
222  void ResetGlobals();
223  void ResetGlobalVar(void* obj);
224  void RewindDictionary();
225  Int_t DeleteGlobal(void* obj);
226  Int_t DeleteVariable(const char *name);
227  void SaveContext();
228  void SaveGlobalsContext();
229  void UpdateListOfGlobals();
230  void UpdateListOfGlobalFunctions();
231  void UpdateListOfTypes();
232  void SetClassInfo(TClass* cl, Bool_t reload = kFALSE);
233  Bool_t CheckClassInfo(const char* name, Bool_t autoload, Bool_t isClassOrNamespaceOnly = kFALSE);
234  Bool_t CheckClassTemplate(const char *name);
235  Long_t Calc(const char* line, EErrorCode* error = 0);
236  void CreateListOfBaseClasses(TClass* cl) const;
237  void CreateListOfDataMembers(TClass* cl) const;
238  void CreateListOfMethods(TClass* cl) const;
239  void CreateListOfMethodArgs(TFunction* m) const;
240  void UpdateListOfMethods(TClass* cl) const;
241  void UpdateListOfDataMembers(TClass* cl) const;
242 
243  virtual DeclId_t GetDataMember(ClassInfo_t *cl, const char *name) const;
244  virtual DeclId_t GetDataMemberAtAddr(const void *addr) const;
245  virtual DeclId_t GetDataMemberWithValue(const void *ptrvalue) const;
246  virtual DeclId_t GetEnum(TClass *cl, const char *name) const;
247  virtual TEnum* CreateEnum(void *VD, TClass *cl) const;
248  virtual void UpdateEnumConstants(TEnum* enumObj, TClass* cl) const;
249  virtual void LoadEnums(TListOfEnums& cl) const;
250  TString GetMangledName(TClass* cl, const char* method, const char* params, Bool_t objectIsConst = kFALSE);
251  TString GetMangledNameWithPrototype(TClass* cl, const char* method, const char* proto, Bool_t objectIsConst = kFALSE, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch);
252  void* GetInterfaceMethod(TClass* cl, const char* method, const char* params, Bool_t objectIsConst = kFALSE);
253  void* GetInterfaceMethodWithPrototype(TClass* cl, const char* method, const char* proto, Bool_t objectIsConst = kFALSE, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch);
254  DeclId_t GetFunction(ClassInfo_t *cl, const char *funcname);
255  DeclId_t GetFunctionWithPrototype(ClassInfo_t *cl, const char* method, const char* proto, Bool_t objectIsConst = kFALSE, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch);
256  DeclId_t GetFunctionWithValues(ClassInfo_t *cl, const char* method, const char* params, Bool_t objectIsConst = kFALSE);
257  DeclId_t GetFunctionTemplate(ClassInfo_t *cl, const char *funcname);
258  void GetFunctionOverloads(ClassInfo_t *cl, const char *funcname, std::vector<DeclId_t>& res) const;
259  virtual void LoadFunctionTemplates(TClass* cl) const;
260 
261  void GetInterpreterTypeName(const char* name, std::string &output, Bool_t full = kFALSE);
262  void Execute(const char* function, const char* params, int* error = 0);
263  void Execute(TObject* obj, TClass* cl, const char* method, const char* params, int* error = 0);
264  void Execute(TObject* obj, TClass* cl, const char* method, const char* params, Bool_t objectIsConst, int* error = 0);
265  void Execute(TObject* obj, TClass* cl, TMethod* method, TObjArray* params, int* error = 0);
266  void ExecuteWithArgsAndReturn(TMethod* method, void* address, const void* args[] = 0, int nargs = 0, void* ret= 0) const;
267  Long_t ExecuteMacro(const char* filename, EErrorCode* error = 0);
268  void RecursiveRemove(TObject* obj);
269  Bool_t IsErrorMessagesEnabled() const;
270  Bool_t SetErrorMessages(Bool_t enable = kTRUE);
271  Bool_t IsProcessLineLocked() const {
272  return fLockProcessLine;
273  }
274  void SetProcessLineLock(Bool_t lock = kTRUE) {
275  fLockProcessLine = lock;
276  }
277  const char* TypeName(const char* typeDesc);
278 
279  static void UpdateClassInfo(char* name, Long_t tagnum);
280  static void UpdateClassInfoWork(const char* name);
281  void UpdateClassInfoWithDecl(const void* vTD);
282  static void UpdateAllCanvases();
283 
284  // Misc
285  virtual int DisplayClass(FILE* fout, const char* name, int base, int start) const;
286  virtual int DisplayIncludePath(FILE* fout) const;
287  virtual void* FindSym(const char* entry) const;
288  virtual void GenericError(const char* error) const;
289  virtual Long_t GetExecByteCode() const;
290  virtual Long_t Getgvp() const;
291  virtual const char* Getp2f2funcname(void* receiver) const;
292  virtual const char* GetTopLevelMacroName() const;
293  virtual const char* GetCurrentMacroName() const;
294  virtual int GetSecurityError() const;
295  virtual int LoadFile(const char* path) const;
296  virtual Bool_t LoadText(const char* text) const;
297  virtual const char* MapCppName(const char*) const;
298  virtual void SetAlloclockfunc(void (*)()) const;
299  virtual void SetAllocunlockfunc(void (*)()) const;
300  virtual int SetClassAutoloading(int) const;
301  virtual int SetClassAutoparsing(int) ;
302  Bool_t IsAutoParsingSuspended() const { return fIsAutoParsingSuspended; }
303  virtual void SetErrmsgcallback(void* p) const;
304  virtual void Setgvp(Long_t) const;
305  virtual void SetRTLD_NOW() const;
306  virtual void SetRTLD_LAZY() const;
307  virtual void SetTempLevel(int val) const;
308  virtual int UnloadFile(const char* path) const;
309 
310  void CodeComplete(const std::string&, size_t&,
311  std::vector<std::string>&);
312  virtual int Evaluate(const char*, TInterpreterValue&);
313  TInterpreterValue *CreateTemporary();
314  void RegisterTemporary(const TInterpreterValue& value);
315  void RegisterTemporary(const cling::Value& value);
316  const ROOT::TMetaUtils::TNormalizedCtxt& GetNormalizedContext() const {return *fNormalizedCtxt;};
317  TObject* GetObjectAddress(const char *Name, void *&LookupCtx);
318 
319 
320  // core/meta helper functions.
321  virtual EReturnType MethodCallReturnType(TFunction *func) const;
322  virtual void GetFunctionName(const clang::FunctionDecl *decl, std::string &name) const;
323  virtual bool DiagnoseIfInterpreterException(const std::exception &e) const;
324 
325  // CallFunc interface
326  virtual DeclId_t GetDeclId(CallFunc_t *info) const;
327  virtual void CallFunc_Delete(CallFunc_t* func) const;
328  virtual void CallFunc_Exec(CallFunc_t* func, void* address) const;
329  virtual void CallFunc_Exec(CallFunc_t* func, void* address, TInterpreterValue& val) const;
330  virtual void CallFunc_ExecWithReturn(CallFunc_t* func, void* address, void* ret) const;
331  virtual void CallFunc_ExecWithArgsAndReturn(CallFunc_t* func, void* address, const void* args[] = 0, int nargs = 0, void* ret = 0) const;
332  virtual Long_t CallFunc_ExecInt(CallFunc_t* func, void* address) const;
333  virtual Long64_t CallFunc_ExecInt64(CallFunc_t* func, void* address) const;
334  virtual Double_t CallFunc_ExecDouble(CallFunc_t* func, void* address) const;
335  virtual CallFunc_t* CallFunc_Factory() const;
336  virtual CallFunc_t* CallFunc_FactoryCopy(CallFunc_t* func) const;
337  virtual MethodInfo_t* CallFunc_FactoryMethod(CallFunc_t* func) const;
338  virtual void CallFunc_IgnoreExtraArgs(CallFunc_t* func, bool ignore) const;
339  virtual void CallFunc_Init(CallFunc_t* func) const;
340  virtual bool CallFunc_IsValid(CallFunc_t* func) const;
341  virtual CallFuncIFacePtr_t CallFunc_IFacePtr(CallFunc_t * func) const;
342  virtual void CallFunc_ResetArg(CallFunc_t* func) const;
343  virtual void CallFunc_SetArg(CallFunc_t* func, Long_t param) const;
344  virtual void CallFunc_SetArg(CallFunc_t* func, ULong_t param) const;
345  virtual void CallFunc_SetArg(CallFunc_t* func, Float_t param) const;
346  virtual void CallFunc_SetArg(CallFunc_t* func, Double_t param) const;
347  virtual void CallFunc_SetArg(CallFunc_t* func, Long64_t param) const;
348  virtual void CallFunc_SetArg(CallFunc_t* func, ULong64_t param) const;
349  virtual void CallFunc_SetArgArray(CallFunc_t* func, Long_t* paramArr, Int_t nparam) const;
350  virtual void CallFunc_SetArgs(CallFunc_t* func, const char* param) const;
351  virtual void CallFunc_SetFunc(CallFunc_t* func, ClassInfo_t* info, const char* method, const char* params, Long_t* Offset) const;
352  virtual void CallFunc_SetFunc(CallFunc_t* func, ClassInfo_t* info, const char* method, const char* params, bool objectIsConst, Long_t* Offset) const;
353  virtual void CallFunc_SetFunc(CallFunc_t* func, MethodInfo_t* info) const;
354  virtual void CallFunc_SetFuncProto(CallFunc_t* func, ClassInfo_t* info, const char* method, const char* proto, Long_t* Offset, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch) const;
355  virtual void CallFunc_SetFuncProto(CallFunc_t* func, ClassInfo_t* info, const char* method, const char* proto, bool objectIsConst, Long_t* Offset, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch) const;
356  virtual void CallFunc_SetFuncProto(CallFunc_t* func, ClassInfo_t* info, const char* method, const std::vector<TypeInfo_t*> &proto, Long_t* Offset, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch) const;
357  virtual void CallFunc_SetFuncProto(CallFunc_t* func, ClassInfo_t* info, const char* method, const std::vector<TypeInfo_t*> &proto, bool objectIsConst, Long_t* Offset, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch) const;
358 
359  // ClassInfo interface
360  virtual DeclId_t GetDeclId(ClassInfo_t *info) const;
361  virtual Bool_t ClassInfo_Contains(ClassInfo_t *info, DeclId_t declid) const;
362  virtual Long_t ClassInfo_ClassProperty(ClassInfo_t* info) const;
363  virtual void ClassInfo_Delete(ClassInfo_t* info) const;
364  virtual void ClassInfo_Delete(ClassInfo_t* info, void* arena) const;
365  virtual void ClassInfo_DeleteArray(ClassInfo_t* info, void* arena, bool dtorOnly) const;
366  virtual void ClassInfo_Destruct(ClassInfo_t* info, void* arena) const;
367  virtual ClassInfo_t* ClassInfo_Factory(Bool_t all = kTRUE) const;
368  virtual ClassInfo_t* ClassInfo_Factory(ClassInfo_t* cl) const;
369  virtual ClassInfo_t* ClassInfo_Factory(const char* name) const;
370  virtual Long_t ClassInfo_GetBaseOffset(ClassInfo_t* fromDerived, ClassInfo_t* toBase, void * address, bool isDerivedObject) const;
371  virtual int ClassInfo_GetMethodNArg(ClassInfo_t* info, const char* method, const char* proto, Bool_t objectIsConst = false, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch) const;
372  virtual bool ClassInfo_HasDefaultConstructor(ClassInfo_t* info) const;
373  virtual bool ClassInfo_HasMethod(ClassInfo_t* info, const char* name) const;
374  virtual void ClassInfo_Init(ClassInfo_t* info, const char* funcname) const;
375  virtual void ClassInfo_Init(ClassInfo_t* info, int tagnum) const;
376  virtual bool ClassInfo_IsBase(ClassInfo_t* info, const char* name) const;
377  virtual bool ClassInfo_IsEnum(const char* name) const;
378  virtual bool ClassInfo_IsLoaded(ClassInfo_t* info) const;
379  virtual bool ClassInfo_IsValid(ClassInfo_t* info) const;
380  virtual bool ClassInfo_IsValidMethod(ClassInfo_t* info, const char* method, const char* proto, Long_t* offset, ROOT::EFunctionMatchMode /* mode */ = ROOT::kConversionMatch) const;
381  virtual bool ClassInfo_IsValidMethod(ClassInfo_t* info, const char* method, const char* proto, Bool_t objectIsConst, Long_t* offset, ROOT::EFunctionMatchMode /* mode */ = ROOT::kConversionMatch) const;
382  virtual int ClassInfo_Next(ClassInfo_t* info) const;
383  virtual void* ClassInfo_New(ClassInfo_t* info) const;
384  virtual void* ClassInfo_New(ClassInfo_t* info, int n) const;
385  virtual void* ClassInfo_New(ClassInfo_t* info, int n, void* arena) const;
386  virtual void* ClassInfo_New(ClassInfo_t* info, void* arena) const;
387  virtual Long_t ClassInfo_Property(ClassInfo_t* info) const;
388  virtual int ClassInfo_Size(ClassInfo_t* info) const;
389  virtual Long_t ClassInfo_Tagnum(ClassInfo_t* info) const;
390  virtual const char* ClassInfo_FileName(ClassInfo_t* info) const;
391  virtual const char* ClassInfo_FullName(ClassInfo_t* info) const;
392  virtual const char* ClassInfo_Name(ClassInfo_t* info) const;
393  virtual const char* ClassInfo_Title(ClassInfo_t* info) const;
394  virtual const char* ClassInfo_TmpltName(ClassInfo_t* info) const;
395 
396  // BaseClassInfo interface
397  virtual void BaseClassInfo_Delete(BaseClassInfo_t* bcinfo) const;
398  virtual BaseClassInfo_t* BaseClassInfo_Factory(ClassInfo_t* info) const;
399  virtual BaseClassInfo_t* BaseClassInfo_Factory(ClassInfo_t* derived,
400  ClassInfo_t* base) const;
401  virtual int BaseClassInfo_Next(BaseClassInfo_t* bcinfo) const;
402  virtual int BaseClassInfo_Next(BaseClassInfo_t* bcinfo, int onlyDirect) const;
403  virtual Long_t BaseClassInfo_Offset(BaseClassInfo_t* toBaseClassInfo, void * address, bool isDerivedObject) const;
404  virtual Long_t BaseClassInfo_Property(BaseClassInfo_t* bcinfo) const;
405  virtual Long_t BaseClassInfo_Tagnum(BaseClassInfo_t* bcinfo) const;
406  virtual ClassInfo_t*BaseClassInfo_ClassInfo(BaseClassInfo_t * /* bcinfo */) const;
407  virtual const char* BaseClassInfo_FullName(BaseClassInfo_t* bcinfo) const;
408  virtual const char* BaseClassInfo_Name(BaseClassInfo_t* bcinfo) const;
409  virtual const char* BaseClassInfo_TmpltName(BaseClassInfo_t* bcinfo) const;
410 
411  // DataMemberInfo interface
412  virtual DeclId_t GetDeclId(DataMemberInfo_t *info) const;
413  virtual int DataMemberInfo_ArrayDim(DataMemberInfo_t* dminfo) const;
414  virtual void DataMemberInfo_Delete(DataMemberInfo_t* dminfo) const;
415  virtual DataMemberInfo_t* DataMemberInfo_Factory(ClassInfo_t* clinfo = 0) const;
416  virtual DataMemberInfo_t *DataMemberInfo_Factory(DeclId_t declid, ClassInfo_t* clinfo) const;
417  virtual DataMemberInfo_t* DataMemberInfo_FactoryCopy(DataMemberInfo_t* dminfo) const;
418  virtual bool DataMemberInfo_IsValid(DataMemberInfo_t* dminfo) const;
419  virtual int DataMemberInfo_MaxIndex(DataMemberInfo_t* dminfo, Int_t dim) const;
420  virtual int DataMemberInfo_Next(DataMemberInfo_t* dminfo) const;
421  virtual Long_t DataMemberInfo_Offset(DataMemberInfo_t* dminfo) const;
422  virtual Long_t DataMemberInfo_Property(DataMemberInfo_t* dminfo) const;
423  virtual Long_t DataMemberInfo_TypeProperty(DataMemberInfo_t* dminfo) const;
424  virtual int DataMemberInfo_TypeSize(DataMemberInfo_t* dminfo) const;
425  virtual const char* DataMemberInfo_TypeName(DataMemberInfo_t* dminfo) const;
426  virtual const char* DataMemberInfo_TypeTrueName(DataMemberInfo_t* dminfo) const;
427  virtual const char* DataMemberInfo_Name(DataMemberInfo_t* dminfo) const;
428  virtual const char* DataMemberInfo_Title(DataMemberInfo_t* dminfo) const;
429  virtual const char* DataMemberInfo_ValidArrayIndex(DataMemberInfo_t* dminfo) const;
430  virtual void SetDeclAttr(DeclId_t, const char* /* attribute */);
431 
432 
433  // Function Template interface
434  virtual DeclId_t GetDeclId(FuncTempInfo_t *info) const;
435  virtual void FuncTempInfo_Delete(FuncTempInfo_t * /* ft_info */) const;
436  virtual FuncTempInfo_t *FuncTempInfo_Factory(DeclId_t declid) const;
437  virtual FuncTempInfo_t *FuncTempInfo_FactoryCopy(FuncTempInfo_t * /* ft_info */) const;
438  virtual Bool_t FuncTempInfo_IsValid(FuncTempInfo_t * /* ft_info */) const;
439  virtual UInt_t FuncTempInfo_TemplateNargs(FuncTempInfo_t * /* ft_info */) const;
440  virtual UInt_t FuncTempInfo_TemplateMinReqArgs(FuncTempInfo_t * /* ft_info */) const;
441  virtual Long_t FuncTempInfo_Property(FuncTempInfo_t * /* ft_info */) const;
442  virtual void FuncTempInfo_Name(FuncTempInfo_t * /* ft_info */, TString& name) const;
443  virtual void FuncTempInfo_Title(FuncTempInfo_t * /* ft_info */, TString& name) const;
444 
445  // MethodInfo interface
446  virtual DeclId_t GetDeclId(MethodInfo_t *info) const;
447  virtual void MethodInfo_CreateSignature(MethodInfo_t* minfo, TString& signature) const;
448  virtual void MethodInfo_Delete(MethodInfo_t* minfo) const;
449  virtual MethodInfo_t* MethodInfo_Factory() const;
450  virtual MethodInfo_t* MethodInfo_Factory(ClassInfo_t *clinfo) const;
451  virtual MethodInfo_t *MethodInfo_Factory(DeclId_t declid) const;
452  virtual MethodInfo_t* MethodInfo_FactoryCopy(MethodInfo_t* minfo) const;
453  virtual void* MethodInfo_InterfaceMethod(MethodInfo_t* minfo) const;
454  virtual bool MethodInfo_IsValid(MethodInfo_t* minfo) const;
455  virtual int MethodInfo_NArg(MethodInfo_t* minfo) const;
456  virtual int MethodInfo_NDefaultArg(MethodInfo_t* minfo) const;
457  virtual int MethodInfo_Next(MethodInfo_t* minfo) const;
458  virtual Long_t MethodInfo_Property(MethodInfo_t* minfo) const;
459  virtual Long_t MethodInfo_ExtraProperty(MethodInfo_t* minfo) const;
460  virtual TypeInfo_t* MethodInfo_Type(MethodInfo_t* minfo) const;
461  virtual EReturnType MethodInfo_MethodCallReturnType(MethodInfo_t* minfo) const;
462  virtual const char* MethodInfo_GetMangledName(MethodInfo_t* minfo) const;
463  virtual const char* MethodInfo_GetPrototype(MethodInfo_t* minfo) const;
464  virtual const char* MethodInfo_Name(MethodInfo_t* minfo) const;
465  virtual const char* MethodInfo_TypeName(MethodInfo_t* minfo) const;
466  virtual std::string MethodInfo_TypeNormalizedName(MethodInfo_t* minfo) const;
467  virtual const char* MethodInfo_Title(MethodInfo_t* minfo) const;
468 
469  // MethodArgInfo interface
470  virtual void MethodArgInfo_Delete(MethodArgInfo_t* marginfo) const;
471  virtual MethodArgInfo_t* MethodArgInfo_Factory() const;
472  virtual MethodArgInfo_t* MethodArgInfo_Factory(MethodInfo_t *minfo) const;
473  virtual MethodArgInfo_t* MethodArgInfo_FactoryCopy(MethodArgInfo_t* marginfo) const;
474  virtual bool MethodArgInfo_IsValid(MethodArgInfo_t* marginfo) const;
475  virtual int MethodArgInfo_Next(MethodArgInfo_t* marginfo) const;
476  virtual Long_t MethodArgInfo_Property(MethodArgInfo_t* marginfo) const;
477  virtual const char* MethodArgInfo_DefaultValue(MethodArgInfo_t* marginfo) const;
478  virtual const char* MethodArgInfo_Name(MethodArgInfo_t* marginfo) const;
479  virtual const char* MethodArgInfo_TypeName(MethodArgInfo_t* marginfo) const;
480  virtual std::string MethodArgInfo_TypeNormalizedName(MethodArgInfo_t *marginfo) const;
481 
482  // TypeInfo interface
483  virtual void TypeInfo_Delete(TypeInfo_t* tinfo) const;
484  virtual TypeInfo_t* TypeInfo_Factory() const;
485  virtual TypeInfo_t *TypeInfo_Factory(const char* name) const;
486  virtual TypeInfo_t* TypeInfo_FactoryCopy(TypeInfo_t* /* tinfo */) const;
487  virtual void TypeInfo_Init(TypeInfo_t* tinfo, const char* funcname) const;
488  virtual bool TypeInfo_IsValid(TypeInfo_t* tinfo) const;
489  virtual const char* TypeInfo_Name(TypeInfo_t* /* info */) const;
490  virtual Long_t TypeInfo_Property(TypeInfo_t* tinfo) const;
491  virtual int TypeInfo_RefType(TypeInfo_t* /* tinfo */) const;
492  virtual int TypeInfo_Size(TypeInfo_t* tinfo) const;
493  virtual const char* TypeInfo_TrueName(TypeInfo_t* tinfo) const;
494 
495  // TypedefInfo interface
496  virtual DeclId_t GetDeclId(TypedefInfo_t *info) const;
497  virtual void TypedefInfo_Delete(TypedefInfo_t* tinfo) const;
498  virtual TypedefInfo_t* TypedefInfo_Factory() const;
499  virtual TypedefInfo_t* TypedefInfo_Factory(const char* name) const;
500  virtual TypedefInfo_t* TypedefInfo_FactoryCopy(TypedefInfo_t* tinfo) const;
501  virtual void TypedefInfo_Init(TypedefInfo_t* tinfo, const char* name) const;
502  virtual bool TypedefInfo_IsValid(TypedefInfo_t* tinfo) const;
503  virtual int TypedefInfo_Next(TypedefInfo_t* tinfo) const;
504  virtual Long_t TypedefInfo_Property(TypedefInfo_t* tinfo) const;
505  virtual int TypedefInfo_Size(TypedefInfo_t* tinfo) const;
506  virtual const char* TypedefInfo_TrueName(TypedefInfo_t* tinfo) const;
507  virtual const char* TypedefInfo_Name(TypedefInfo_t* tinfo) const;
508  virtual const char* TypedefInfo_Title(TypedefInfo_t* tinfo) const;
509 
510  std::set<TClass*>& GetModTClasses() { return fModTClasses; }
511 
512  void HandleNewDecl(const void* DV, bool isDeserialized, std::set<TClass*>& modifiedClasses);
513  void UpdateListsOnCommitted(const cling::Transaction &T);
514  void UpdateListsOnUnloaded(const cling::Transaction &T);
515  void TransactionRollback(const cling::Transaction &T);
516  void LibraryLoaded(const void* dyLibHandle, const char* canonicalName);
517  void LibraryUnloaded(const void* dyLibHandle, const char* canonicalName);
518 
519 private: // Private Utility Functions and Classes
520 
521  class TUniqueString {
522  public:
523  TUniqueString() = delete;
524  TUniqueString(const TUniqueString &) = delete;
525  TUniqueString(Long64_t size);
526  const char *Data();
527  bool Append(const std::string &str);
528  private:
529  std::string fContent;
530  std::set<size_t> fLinesHashSet;
531  std::hash<std::string> fHashFunc;
532  };
533 
534  TCling();
535  TCling(const TCling&); // NOT IMPLEMENTED
536  TCling& operator=(const TCling&); // NOT IMPLEMENTED
537 
538  void Execute(TMethod*, TObjArray*, int* /*error*/ = 0)
539  {
540  }
541 
542  void UpdateListOfLoadedSharedLibraries();
543  void RegisterLoadedSharedLibrary(const char* name);
544  void AddFriendToClass(clang::FunctionDecl*, clang::CXXRecordDecl*) const;
545 
546  bool LoadPCM(TString pcmFileName, const char** headers,
547  void (*triggerFunc)()) const;
548  void InitRootmapFile(const char *name);
549  int ReadRootmapFile(const char *rootmapfile, TUniqueString* uniqueString = nullptr);
550  Bool_t HandleNewTransaction(const cling::Transaction &T);
551  void UnloadClassMembers(TClass* cl, const clang::DeclContext* DC);
552 
553 };
554 
555 #endif
RooFit::Offset
RooCmdArg Offset(Bool_t flag=kTRUE)
Definition: RooGlobalFunc.cxx:208
TEnum
The TEnum class implements the enum type.
Definition: TEnum.h:42
TInterpreter
This class defines an abstract interface to a generic command line interpreter.
Definition: TInterpreter.h:50
TObjArray
An array of TObjects.
Definition: TObjArray.h:39
TCling::SpecialObjectLookupCtx_t
void * SpecialObjectLookupCtx_t
Definition: TCling.h:141
llvm
Definition: TString.h:780
Long64_t
long long Long64_t
Definition: RtypesCore.h:69
TCling::TUniqueString::fContent
std::string fContent
Definition: TCling.h:529
ROOT
This namespace contains pre-defined functions to be used in conjuction with TExecutor::Map and TExecu...
Definition: StringConv.hxx:21
TCling::fSpecialObjectMaps
std::map< SpecialObjectLookupCtx_t, SpecialObjectMap_t > fSpecialObjectMaps
Definition: TCling.h:143
line
TLine * line
Definition: entrylistblock_figure1.C:237
TCling__UpdateListsOnUnloaded
void TCling__UpdateListsOnUnloaded(const cling::Transaction &)
Definition: TCling.cxx:560
Float_t
float Float_t
Definition: RtypesCore.h:53
TInterpreter::DeclId_t
TDictionary::DeclId_t DeclId_t
Definition: TInterpreter.h:251
ROOT::Math::Chebyshev::T
double T(double x)
Definition: ChebyshevPol.h:34
TCling::SpecialObjectMap_t
std::unordered_map< std::string, TObject * > SpecialObjectMap_t
Definition: TCling.h:142
TCling::fMetaProcessor
cling::MetaProcessor * fMetaProcessor
Definition: TCling.h:121
TCling::fInterpreter
cling::Interpreter * fInterpreter
Definition: TCling.h:120
TInterpreter::CallFuncIFacePtr_t
Definition: TInterpreter.h:69
TEnv
The TEnv class reads config files, by default named .rootrc.
Definition: TEnv.h:128
TString
Basic string class.
Definition: TString.h:137
TCling::fNormalizedCtxt
ROOT::TMetaUtils::TNormalizedCtxt * fNormalizedCtxt
Definition: TCling.h:124
Int_t
int Int_t
Definition: RtypesCore.h:41
Bool_t
bool Bool_t
Definition: RtypesCore.h:59
a
TArc * a
Definition: textangle.C:12
TInterpreter::FwdDeclArgsToKeepCollection_t
std::vector< std::pair< std::string, int > > FwdDeclArgsToKeepCollection_t
Definition: TInterpreter.h:108
kFALSE
const Bool_t kFALSE
Definition: Rtypes.h:92
TCling::fExitCode
Int_t fExitCode
Definition: TCling.h:100
TCling::fPrevLoadedDynLibInfo
void * fPrevLoadedDynLibInfo
Definition: TCling.h:127
TMemberInspector
Abstract base class for accessing the data-members of a class.
Definition: TMemberInspector.h:31
TCling::fTemporaries
std::vector< cling::Value > * fTemporaries
Definition: TCling.h:123
xmlio::Name
const char * Name
Definition: TXMLSetup.cxx:67
TCling__GetObjectDecl
const clang::Decl * TCling__GetObjectDecl(TObject *obj)
Definition: TCling.cxx:586
TCling::fPayloads
std::set< size_t > fPayloads
Definition: TCling.h:112
TCling::fCurExecutingMacros
std::vector< const char * > fCurExecutingMacros
Definition: TCling.h:139
ROOT::GetClass
TClass * GetClass(T *)
Definition: TClass.h:555
THashTable
THashTable implements a hash table to store TObject&#39;s.
Definition: THashTable.h:39
TCling::TUniqueString::fHashFunc
std::hash< std::string > fHashFunc
Definition: TCling.h:531
TCling::fTransactionHeadersMap
std::map< const cling::Transaction *, size_t > fTransactionHeadersMap
Definition: TCling.h:110
TCling::SetProcessLineLock
void SetProcessLineLock(Bool_t lock=kTRUE)
Definition: TCling.h:274
TCling::fSharedLibs
TString fSharedLibs
Definition: TCling.h:104
TCling::fMapfile
TEnv * fMapfile
Definition: TCling.h:108
ROOT::EFunctionMatchMode
EFunctionMatchMode
Definition: TDictionary.h:155
Data
std::vector< std::vector< double > > Data
Definition: ParallelTest.cxx:55
TCling::CharPtrCmp_t::operator()
bool operator()(const char *a, const char *b) const
Definition: TCling.h:131
TCling::fTransactionCount
ULong64_t fTransactionCount
Definition: TCling.h:138
TCling::Execute
void Execute(TMethod *, TObjArray *, int *=0)
Execute method on this object with parameters stored in the TObjArray.
Definition: TCling.h:538
TCling__TransactionRollback
void TCling__TransactionRollback(const cling::Transaction &)
Definition: TCling.cxx:564
TCling::GetExitCode
Int_t GetExitCode() const
Definition: TCling.h:177
TCling::GetInterpreterStateMarker
unsigned long long GetInterpreterStateMarker() const
Definition: TCling.h:190
TCling::GetInterpreter
cling::Interpreter * GetInterpreter()
Definition: TCling.h:160
TCling
This class defines an interface to the cling C++ interpreter.
Definition: TCling.h:92
DictFuncPtr_t
TClass *(* DictFuncPtr_t)()
Definition: Rtypes.h:75
TCling::GetNormalizedContext
const ROOT::TMetaUtils::TNormalizedCtxt & GetNormalizedContext() const
Definition: TCling.h:316
TCling::TUniqueString::fLinesHashSet
std::set< size_t > fLinesHashSet
Definition: TCling.h:530
TCling::GetAutoLoadCallBack
void * GetAutoLoadCallBack() const
Definition: TCling.h:163
TCling::fRootmapLoadPath
TString fRootmapLoadPath
Definition: TCling.h:107
TCling::fRegisterModuleDyLibs
std::vector< void * > fRegisterModuleDyLibs
Definition: TCling.h:128
TMVA::TMVAGlob::Initialize
void Initialize(Bool_t useTMVAStyle=kTRUE)
Definition: tmvaglob.cxx:176
TCling::GetModTClasses
std::set< TClass * > & GetModTClasses()
Definition: TCling.h:510
TCling__UpdateListsOnCommitted
void TCling__UpdateListsOnCommitted(const cling::Transaction &, cling::Interpreter *)
Definition: TCling.cxx:554
UInt_t
unsigned int UInt_t
Definition: RtypesCore.h:42
m
TMarker * m
Definition: textangle.C:8
TClass
The ROOT global object gROOT contains a list of all defined classes.
Definition: TClass.h:81
ROOT::Internal::Reset
void Reset(Detail::TBranchProxy *x)
Definition: TBranchProxyDirector.cxx:38
ROOT::Math::IntegrationOneDim::Type
Type
enumeration specifying the integration types.
Definition: AllIntegrationTypes.h:45
TCling::fLockProcessLine
Bool_t fLockProcessLine
Definition: TCling.h:117
TCling::fNSFromRootmaps
std::unordered_set< const clang::NamespaceDecl * > fNSFromRootmaps
Definition: TCling.h:115
TCling::fModTClasses
std::set< TClass * > fModTClasses
Definition: TCling.h:135
Long_t
long Long_t
Definition: RtypesCore.h:50
TCling::fLookedUpClasses
std::set< size_t > fLookedUpClasses
Definition: TCling.h:111
TCling__LibraryLoaded
void TCling__LibraryLoaded(const void *dyLibHandle, const char *canonicalName)
Double_t
double Double_t
Definition: RtypesCore.h:55
text
TText * text
Definition: entrylist_figure1.C:12
clang
Definition: TCling.h:48
ULong64_t
unsigned long long ULong64_t
Definition: RtypesCore.h:70
cling
Print a TSeq at the prompt:
Definition: TDatime.h:114
ULong_t
unsigned long ULong_t
Definition: RtypesCore.h:51
TCling::IsProcessLineLocked
Bool_t IsProcessLineLocked() const
Definition: TCling.h:271
TCling::fAllowLibLoad
Bool_t fAllowLibLoad
Definition: TCling.h:118
TCling::fRootmapFiles
TObjArray * fRootmapFiles
Definition: TCling.h:116
TCling__LibraryUnloaded
void TCling__LibraryUnloaded(const void *dyLibHandle, const char *canonicalName)
func
double func(double *x, double *p)
Definition: stressTF1.cxx:213
TCling::fAutoLoadCallBack
void * fAutoLoadCallBack
Definition: TCling.h:137
TCling::fParsedPayloadsAddresses
std::set< const char * > fParsedPayloadsAddresses
Definition: TCling.h:113
TCling::fLookupHelper
ROOT::TMetaUtils::TClingLookupHelper * fLookupHelper
Definition: TCling.h:125
TCling::fClingCallbacks
TClingCallbacks * fClingCallbacks
Definition: TCling.h:129
e
you should not use this method at all Int_t Int_t Double_t Double_t Double_t e
Definition: TRolke.cxx:630
TCling__GetObjectAddress
TObject * TCling__GetObjectAddress(const char *Name, void *&LookupCtx)
Definition: TCling.cxx:582
TCling::fIncludePath
TString fIncludePath
Definition: TCling.h:106
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
TFunction
Global functions class (global functions are obtained from CINT).
Definition: TFunction.h:30
TListOfEnums
A collection of TEnum objects designed for fast access given a DeclId_t and for keep track of TEnum t...
Definition: TListOfEnums.h:36
TCling::CharPtrCmp_t
Definition: TCling.h:130
TCling::fHeaderParsingOnDemand
Bool_t fHeaderParsingOnDemand
Definition: TCling.h:147
TCling::fGlobalsListSerial
Int_t fGlobalsListSerial
Definition: TCling.h:105
TMethod
Each ROOT class (see TClass) has a linked list of methods.
Definition: TMethod.h:40
TCling::fClassesToUpdate
std::vector< std::pair< TClass *, DictFuncPtr_t > > fClassesToUpdate
Definition: TCling.h:136
TCling::fgSetOfSpecials
static void * fgSetOfSpecials
Definition: TCling.h:95
b
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
proto
const char * proto
Definition: civetweb.c:11652
TCling::IsAutoParsingSuspended
Bool_t IsAutoParsingSuspended() const
Definition: TCling.h:302
TCling::fMore
Int_t fMore
Definition: TCling.h:99
TCling::GetMapfile
TEnv * GetMapfile() const
Definition: TCling.h:178
TCling::GetMore
Int_t GetMore() const
Definition: TCling.h:179
TCling::fIsAutoParsingSuspended
Bool_t fIsAutoParsingSuspended
Definition: TCling.h:148
TCling::fStringHashFunction
std::hash< std::string > fStringHashFunction
Definition: TCling.h:114
TCling::SetAutoLoadCallBack
void * SetAutoLoadCallBack(void *cb)
Definition: TCling.h:164
TCling::GetRootMapFiles
TObjArray * GetRootMapFiles() const
Definition: TCling.h:189
kTRUE
const Bool_t kTRUE
Definition: Rtypes.h:91
TCling::GetPrompt
char * GetPrompt()
Definition: TCling.h:183
n
const Int_t n
Definition: legend1.C:16
name
char name[80]
Definition: TGX11.cxx:109
xmlio::Value
const char * Value
Definition: TXMLSetup.cxx:73
TCling::fClassesHeadersMap
std::map< size_t, std::vector< const char * > > fClassesHeadersMap
Definition: TCling.h:109