Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
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-2019, 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++ interpreter based on //
23 // clang/LLVM technology. //
24 // //
25 //////////////////////////////////////////////////////////////////////////
26 
27 #include "TInterpreter.h"
28 
29 #include <map>
30 #include <memory>
31 #include <set>
32 #include <tuple>
33 #include <unordered_map>
34 #include <unordered_set>
35 #include <vector>
36 
37 #ifndef WIN32
38 #define TWin32SendClass char
39 #endif
40 
41 namespace llvm {
42  class GlobalValue;
43  class StringRef;
44 }
45 
46 namespace clang {
47  class CXXRecordDecl;
48  class Decl;
49  class DeclContext;
50  class EnumDecl;
51  class FunctionDecl;
52  class NamedDecl;
53  class NamespaceDecl;
54  class TagDecl;
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 TFile;
68 class THashTable;
69 class TInterpreterValue;
70 class TMethod;
71 class TObjArray;
72 class TListOfDataMembers;
73 class TListOfFunctions;
74 class TListOfFunctionTemplates;
75 class TListOfEnums;
76 
77 namespace ROOT {
78  namespace TMetaUtils {
79  class TNormalizedCtxt;
80  class TClingLookupHelper;
81  }
82 }
83 
84 extern "C" {
85  void TCling__UpdateListsOnCommitted(const cling::Transaction&,
86  cling::Interpreter*);
87  void TCling__UpdateListsOnUnloaded(const cling::Transaction&);
88  void TCling__InvalidateGlobal(const clang::Decl*);
89  void TCling__TransactionRollback(const cling::Transaction&);
90  TObject* TCling__GetObjectAddress(const char *Name, void *&LookupCtx);
91  const clang::Decl* TCling__GetObjectDecl(TObject *obj);
92  void TCling__LibraryLoaded(const void* dyLibHandle,
93  const char* canonicalName);
94  void TCling__LibraryUnloaded(const void* dyLibHandle,
95  const char* canonicalName);
96  void TCling__RegisterRdictForLoadPCM(const std::string &pcmFileNameFullPath, llvm::StringRef *pcmContent);
97 }
98 
99 class TCling final : public TInterpreter {
100 private: // Static Data Members
101 
102  static void* fgSetOfSpecials; // set of TObjects used in CINT variables
103 
104 private: // Data Members
105 
106  Int_t fMore; // The brace indent level for the cint command line processor.
107  Int_t fExitCode; // Value passed to exit() in interpreter.
108  char fPrompt[64]; // Command line prompt string.
109  //cling::DictPosition fDictPos; // dictionary context after initialization is complete.
110  //cling::DictPosition fDictPosGlobals; // dictionary context after ResetGlobals().
111  TString fSharedLibs; // Shared libraries loaded by G__loadfile().
112  Int_t fGlobalsListSerial;// Last time we refreshed the ROOT list of globals.
113  TString fIncludePath; // Interpreter include path.
114  TString fRootmapLoadPath; // Dynamic load path for rootmap files.
115  TEnv* fMapfile; // Association of classes to libraries.
116  std::vector<std::string> fAutoLoadLibStorage; // A storage to return a const char* from GetClassSharedLibsForModule.
117  std::map<size_t,std::vector<const char*>> fClassesHeadersMap; // Map of classes hashes and headers associated
118  std::map<const cling::Transaction*,size_t> fTransactionHeadersMap; // Map which transaction contains which autoparse.
119  std::set<size_t> fLookedUpClasses; // Set of classes for which headers were looked up already
120  std::set<size_t> fPayloads; // Set of payloads
121  std::set<const char*> fParsedPayloadsAddresses; // Set of payloads which were parsed
122  std::hash<std::string> fStringHashFunction; // A simple hashing function
123  std::unordered_set<const clang::NamespaceDecl*> fNSFromRootmaps; // Collection of namespaces fwd declared in the rootmaps
124  TObjArray* fRootmapFiles; // Loaded rootmap files.
125  Bool_t fLockProcessLine; // True if ProcessLine should lock gInterpreterMutex.
126  Bool_t fCxxModulesEnabled;// True if C++ modules was enabled
127 
128  std::unique_ptr<cling::Interpreter> fInterpreter; // The interpreter.
129  std::unique_ptr<cling::MetaProcessor> fMetaProcessor; // The metaprocessor.
130 
131  std::vector<cling::Value> *fTemporaries; // Stack of temporaries
132  ROOT::TMetaUtils::TNormalizedCtxt *fNormalizedCtxt; // Which typedef to avoid stripping.
133  ROOT::TMetaUtils::TClingLookupHelper *fLookupHelper; // lookup helper used by TClassEdit
134 
135  void* fPrevLoadedDynLibInfo; // Internal info to mark the last loaded libray.
136  std::vector<void*> fRegisterModuleDyLibs; // Stack of libraries currently running RegisterModule
137  TClingCallbacks* fClingCallbacks; // cling::Interpreter owns it.
138  struct CharPtrCmp_t {
139  bool operator()(const char* a, const char *b) const {
140  return strcmp(a, b) < 0;
141  }
142  };
143  std::set<TClass*> fModTClasses;
144  std::vector<std::pair<TClass*,DictFuncPtr_t> > fClassesToUpdate;
145  void* fAutoLoadCallBack;
146  ULong64_t fTransactionCount; // Cling counter for commited or unloaded transactions which changed the AST.
147  std::vector<const char*> fCurExecutingMacros;
148 
149  typedef void* SpecialObjectLookupCtx_t;
150  typedef std::unordered_map<std::string, TObject*> SpecialObjectMap_t;
151  std::map<SpecialObjectLookupCtx_t, SpecialObjectMap_t> fSpecialObjectMaps;
152 
153  struct MutexStateAndRecurseCount {
154  /// State of gCoreMutex when the first interpreter-related function was invoked.
155  std::unique_ptr<ROOT::TVirtualRWMutex::State> fState;
156 
157  /// Interpreter-related functions will push the "entry" lock state to *this.
158  /// Recursive calls will do that, too - but we must only forget about the lock
159  /// state once this recursion count went to 0.
160  Int_t fRecurseCount = 0;
161 
162  operator bool() const { return (bool)fState; }
163  };
164 
165  std::vector<MutexStateAndRecurseCount> fInitialMutex{1};
166 
167  DeclId_t GetDeclId(const llvm::GlobalValue *gv) const;
168 
169  Bool_t fHeaderParsingOnDemand;
170  Bool_t fIsAutoParsingSuspended;
171 
172  UInt_t AutoParseImplRecurse(const char *cls, bool topLevel);
173  constexpr static const char* kNullArgv[] = {nullptr};
174 
175  bool fIsShuttingDown = false;
176 
177 protected:
178  Bool_t SetSuspendAutoParsing(Bool_t value);
179 
180 public: // Public Interface
181 
182  virtual ~TCling();
183  TCling(const char* name, const char* title, const char* const argv[]);
184  TCling(const char* name, const char* title): TCling(name, title, kNullArgv) {}
185 
186  void AddIncludePath(const char* path);
187  void *GetAutoLoadCallBack() const { return fAutoLoadCallBack; }
188  void *SetAutoLoadCallBack(void* cb) { void* prev = fAutoLoadCallBack; fAutoLoadCallBack = cb; return prev; }
189  Int_t AutoLoad(const char *classname, Bool_t knowDictNotLoaded = kFALSE);
190  Int_t AutoLoad(const std::type_info& typeinfo, Bool_t knowDictNotLoaded = kFALSE);
191  Int_t AutoParse(const char* cls);
192  void* LazyFunctionCreatorAutoload(const std::string& mangled_name);
193  bool LibraryLoadingFailed(const std::string&, const std::string&, bool, bool);
194  Bool_t IsAutoLoadNamespaceCandidate(const clang::NamespaceDecl* nsDecl);
195  void ClearFileBusy();
196  void ClearStack(); // Delete existing temporary values
197  Bool_t Declare(const char* code);
198  void EnableAutoLoading();
199  void EndOfLineAction();
200  TClass *GetClass(const std::type_info& typeinfo, Bool_t load) const;
201  Int_t GetExitCode() const { return fExitCode; }
202  TEnv* GetMapfile() const { return fMapfile; }
203  Int_t GetMore() const { return fMore; }
204  TClass *GenerateTClass(const char *classname, Bool_t emulation, Bool_t silent = kFALSE);
205  TClass *GenerateTClass(ClassInfo_t *classinfo, Bool_t silent = kFALSE);
206  Int_t GenerateDictionary(const char* classes, const char* includes = "", const char* options = 0);
207  char* GetPrompt() { return fPrompt; }
208  const char* GetSharedLibs();
209  const char* GetClassSharedLibs(const char* cls);
210  const char* GetSharedLibDeps(const char* lib, bool tryDyld = false);
211  const char* GetIncludePath();
212  virtual const char* GetSTLIncludePath() const;
213  TObjArray* GetRootMapFiles() const { return fRootmapFiles; }
214  unsigned long long GetInterpreterStateMarker() const { return fTransactionCount;}
215  virtual void Initialize();
216  virtual void ShutDown();
217  void InspectMembers(TMemberInspector&, const void* obj, const TClass* cl, Bool_t isTransient);
218  Bool_t IsLoaded(const char* filename) const;
219  Bool_t IsLibraryLoaded(const char* libname) const;
220  Bool_t HasPCMForLibrary(const char *libname) const;
221  Int_t Load(const char* filenam, Bool_t system = kFALSE);
222  void LoadMacro(const char* filename, EErrorCode* error = 0);
223  Int_t LoadLibraryMap(const char* rootmapfile = 0);
224  Int_t RescanLibraryMap();
225  Int_t ReloadAllSharedLibraryMaps();
226  Int_t UnloadAllSharedLibraryMaps();
227  Int_t UnloadLibraryMap(const char* library);
228  Long_t ProcessLine(const char* line, EErrorCode* error = 0);
229  Long_t ProcessLineAsynch(const char* line, EErrorCode* error = 0);
230  Long_t ProcessLineSynch(const char* line, EErrorCode* error = 0);
231  void PrintIntro();
232  bool RegisterPrebuiltModulePath(const std::string& FullPath,
233  const std::string& ModuleMapName = "module.modulemap") const;
234  void RegisterModule(const char* modulename,
235  const char** headers,
236  const char** includePaths,
237  const char* payloadCode,
238  const char* fwdDeclsCode,
239  void (*triggerFunc)(),
240  const FwdDeclArgsToKeepCollection_t& fwdDeclsArgToSkip,
241  const char** classesHeaders,
242  Bool_t lateRegistration = false,
243  Bool_t hasCxxModule = false);
244  void RegisterTClassUpdate(TClass *oldcl,DictFuncPtr_t dict);
245  void UnRegisterTClassUpdate(const TClass *oldcl);
246 
247  Int_t SetClassSharedLibs(const char *cls, const char *libs);
248  void SetGetline(const char * (*getlineFunc)(const char* prompt),
249  void (*histaddFunc)(const char* line));
250  void Reset();
251  void ResetAll();
252  void ResetGlobals();
253  void ResetGlobalVar(void* obj);
254  void RewindDictionary();
255  Int_t DeleteGlobal(void* obj);
256  Int_t DeleteVariable(const char *name);
257  void SaveContext();
258  void SaveGlobalsContext();
259  void UpdateListOfGlobals();
260  void UpdateListOfGlobalFunctions();
261  void UpdateListOfTypes();
262  void SetClassInfo(TClass* cl, Bool_t reload = kFALSE);
263 
264  ECheckClassInfo CheckClassInfo(const char *name, Bool_t autoload, Bool_t isClassOrNamespaceOnly = kFALSE);
265 
266  Bool_t CheckClassTemplate(const char *name);
267  Long_t Calc(const char* line, EErrorCode* error = 0);
268  void CreateListOfBaseClasses(TClass* cl) const;
269  void CreateListOfDataMembers(TClass* cl) const;
270  void CreateListOfMethods(TClass* cl) const;
271  void CreateListOfMethodArgs(TFunction* m) const;
272  void UpdateListOfMethods(TClass* cl) const;
273  void UpdateListOfDataMembers(TClass* cl) const;
274 
275  virtual DeclId_t GetDataMember(ClassInfo_t *cl, const char *name) const;
276  virtual DeclId_t GetDataMemberAtAddr(const void *addr) const;
277  virtual DeclId_t GetDataMemberWithValue(const void *ptrvalue) const;
278  virtual DeclId_t GetEnum(TClass *cl, const char *name) const;
279  virtual TEnum* CreateEnum(void *VD, TClass *cl) const;
280  virtual void UpdateEnumConstants(TEnum* enumObj, TClass* cl) const;
281  virtual void LoadEnums(TListOfEnums& cl) const;
282  virtual std::string ToString(const char* type, void *obj);
283  TString GetMangledName(TClass* cl, const char* method, const char* params, Bool_t objectIsConst = kFALSE);
284  TString GetMangledNameWithPrototype(TClass* cl, const char* method, const char* proto, Bool_t objectIsConst = kFALSE, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch);
285  void* GetInterfaceMethod(TClass* cl, const char* method, const char* params, Bool_t objectIsConst = kFALSE);
286  void* GetInterfaceMethodWithPrototype(TClass* cl, const char* method, const char* proto, Bool_t objectIsConst = kFALSE, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch);
287  DeclId_t GetFunction(ClassInfo_t *cl, const char *funcname);
288  DeclId_t GetFunctionWithPrototype(ClassInfo_t *cl, const char* method, const char* proto, Bool_t objectIsConst = kFALSE, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch);
289  DeclId_t GetFunctionWithValues(ClassInfo_t *cl, const char* method, const char* params, Bool_t objectIsConst = kFALSE);
290  DeclId_t GetFunctionTemplate(ClassInfo_t *cl, const char *funcname);
291  void GetFunctionOverloads(ClassInfo_t *cl, const char *funcname, std::vector<DeclId_t>& res) const;
292  virtual void LoadFunctionTemplates(TClass* cl) const;
293 
294  virtual std::vector<std::string> GetUsingNamespaces(ClassInfo_t *cl) const;
295 
296  void GetInterpreterTypeName(const char* name, std::string &output, Bool_t full = kFALSE);
297  void Execute(const char* function, const char* params, int* error = 0);
298  void Execute(TObject* obj, TClass* cl, const char* method, const char* params, int* error = 0);
299  void Execute(TObject* obj, TClass* cl, const char* method, const char* params, Bool_t objectIsConst, int* error = 0);
300  void Execute(TObject* obj, TClass* cl, TMethod* method, TObjArray* params, int* error = 0);
301  void ExecuteWithArgsAndReturn(TMethod* method, void* address, const void* args[] = 0, int nargs = 0, void* ret= 0) const;
302  Long_t ExecuteMacro(const char* filename, EErrorCode* error = 0);
303  void RecursiveRemove(TObject* obj);
304  Bool_t IsErrorMessagesEnabled() const;
305  Bool_t SetErrorMessages(Bool_t enable = kTRUE);
306  Bool_t IsProcessLineLocked() const {
307  return fLockProcessLine;
308  }
309  void SetProcessLineLock(Bool_t lock = kTRUE) {
310  fLockProcessLine = lock;
311  }
312  const char* TypeName(const char* typeDesc);
313 
314  void SnapshotMutexState(ROOT::TVirtualRWMutex* mtx);
315  void ForgetMutexState();
316 
317  void ApplyToInterpreterMutex(void* delta);
318  void *RewindInterpreterMutex();
319 
320  static void UpdateClassInfo(char* name, Long_t tagnum);
321  static void UpdateClassInfoWork(const char* name);
322  void RefreshClassInfo(TClass *cl, const clang::NamedDecl *def, bool alias);
323  void UpdateClassInfoWithDecl(const clang::NamedDecl* ND);
324  static void UpdateAllCanvases();
325 
326  // Misc
327  virtual int DisplayClass(FILE* fout, const char* name, int base, int start) const;
328  virtual int DisplayIncludePath(FILE* fout) const;
329  virtual void* FindSym(const char* entry) const;
330  virtual void GenericError(const char* error) const;
331  virtual Long_t GetExecByteCode() const;
332  virtual const char* GetTopLevelMacroName() const;
333  virtual const char* GetCurrentMacroName() const;
334  virtual int GetSecurityError() const;
335  virtual int LoadFile(const char* path) const;
336  virtual Bool_t LoadText(const char* text) const;
337  virtual const char* MapCppName(const char*) const;
338  virtual void SetAlloclockfunc(void (*)()) const;
339  virtual void SetAllocunlockfunc(void (*)()) const;
340  virtual int SetClassAutoloading(int) const;
341  virtual int SetClassAutoparsing(int) ;
342  Bool_t IsAutoParsingSuspended() const { return fIsAutoParsingSuspended; }
343  virtual void SetErrmsgcallback(void* p) const;
344  virtual void SetTempLevel(int val) const;
345  virtual int UnloadFile(const char* path) const;
346 
347  void CodeComplete(const std::string&, size_t&,
348  std::vector<std::string>&);
349  virtual int Evaluate(const char*, TInterpreterValue&);
350  virtual std::unique_ptr<TInterpreterValue> MakeInterpreterValue() const;
351  void RegisterTemporary(const TInterpreterValue& value);
352  void RegisterTemporary(const cling::Value& value);
353  const ROOT::TMetaUtils::TNormalizedCtxt& GetNormalizedContext() const {return *fNormalizedCtxt;};
354  TObject* GetObjectAddress(const char *Name, void *&LookupCtx);
355 
356 
357  // core/meta helper functions.
358  virtual EReturnType MethodCallReturnType(TFunction *func) const;
359  virtual void GetFunctionName(const clang::FunctionDecl *decl, std::string &name) const;
360  virtual bool DiagnoseIfInterpreterException(const std::exception &e) const;
361 
362  // CallFunc interface
363  virtual DeclId_t GetDeclId(CallFunc_t *info) const;
364  virtual void CallFunc_Delete(CallFunc_t* func) const;
365  virtual void CallFunc_Exec(CallFunc_t* func, void* address) const;
366  virtual void CallFunc_Exec(CallFunc_t* func, void* address, TInterpreterValue& val) const;
367  virtual void CallFunc_ExecWithReturn(CallFunc_t* func, void* address, void* ret) const;
368  virtual void CallFunc_ExecWithArgsAndReturn(CallFunc_t* func, void* address, const void* args[] = 0, int nargs = 0, void* ret = 0) const;
369  virtual Long_t CallFunc_ExecInt(CallFunc_t* func, void* address) const;
370  virtual Long64_t CallFunc_ExecInt64(CallFunc_t* func, void* address) const;
371  virtual Double_t CallFunc_ExecDouble(CallFunc_t* func, void* address) const;
372  virtual CallFunc_t* CallFunc_Factory() const;
373  virtual CallFunc_t* CallFunc_FactoryCopy(CallFunc_t* func) const;
374  virtual MethodInfo_t* CallFunc_FactoryMethod(CallFunc_t* func) const;
375  virtual void CallFunc_IgnoreExtraArgs(CallFunc_t* func, bool ignore) const;
376  virtual void CallFunc_Init(CallFunc_t* func) const;
377  virtual bool CallFunc_IsValid(CallFunc_t* func) const;
378  virtual CallFuncIFacePtr_t CallFunc_IFacePtr(CallFunc_t * func) const;
379  virtual void CallFunc_ResetArg(CallFunc_t* func) const;
380  virtual void CallFunc_SetArg(CallFunc_t* func, Long_t param) const;
381  virtual void CallFunc_SetArg(CallFunc_t* func, ULong_t param) const;
382  virtual void CallFunc_SetArg(CallFunc_t* func, Float_t param) const;
383  virtual void CallFunc_SetArg(CallFunc_t* func, Double_t param) const;
384  virtual void CallFunc_SetArg(CallFunc_t* func, Long64_t param) const;
385  virtual void CallFunc_SetArg(CallFunc_t* func, ULong64_t param) const;
386  virtual void CallFunc_SetArgArray(CallFunc_t* func, Long_t* paramArr, Int_t nparam) const;
387  virtual void CallFunc_SetArgs(CallFunc_t* func, const char* param) const;
388  virtual void CallFunc_SetFunc(CallFunc_t* func, ClassInfo_t* info, const char* method, const char* params, Long_t* Offset) const;
389  virtual void CallFunc_SetFunc(CallFunc_t* func, ClassInfo_t* info, const char* method, const char* params, bool objectIsConst, Long_t* Offset) const;
390  virtual void CallFunc_SetFunc(CallFunc_t* func, MethodInfo_t* info) const;
391  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;
392  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;
393  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;
394  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;
395 
396  virtual std::string CallFunc_GetWrapperCode(CallFunc_t *func) const;
397 
398  // ClassInfo interface
399  virtual DeclId_t GetDeclId(ClassInfo_t *info) const;
400  virtual Bool_t ClassInfo_Contains(ClassInfo_t *info, DeclId_t declid) const;
401  virtual Long_t ClassInfo_ClassProperty(ClassInfo_t* info) const;
402  virtual void ClassInfo_Delete(ClassInfo_t* info) const;
403  virtual void ClassInfo_Delete(ClassInfo_t* info, void* arena) const;
404  virtual void ClassInfo_DeleteArray(ClassInfo_t* info, void* arena, bool dtorOnly) const;
405  virtual void ClassInfo_Destruct(ClassInfo_t* info, void* arena) const;
406  virtual ClassInfo_t* ClassInfo_Factory(Bool_t all = kTRUE) const;
407  virtual ClassInfo_t* ClassInfo_Factory(ClassInfo_t* cl) const;
408  virtual ClassInfo_t* ClassInfo_Factory(const char* name) const;
409  virtual ClassInfo_t* ClassInfo_Factory(DeclId_t declid) const;
410  virtual Long_t ClassInfo_GetBaseOffset(ClassInfo_t* fromDerived, ClassInfo_t* toBase, void * address, bool isDerivedObject) const;
411  virtual int ClassInfo_GetMethodNArg(ClassInfo_t* info, const char* method, const char* proto, Bool_t objectIsConst = false, ROOT::EFunctionMatchMode mode = ROOT::kConversionMatch) const;
412  virtual bool ClassInfo_HasDefaultConstructor(ClassInfo_t* info) const;
413  virtual bool ClassInfo_HasMethod(ClassInfo_t* info, const char* name) const;
414  virtual void ClassInfo_Init(ClassInfo_t* info, const char* funcname) const;
415  virtual void ClassInfo_Init(ClassInfo_t* info, int tagnum) const;
416  virtual bool ClassInfo_IsBase(ClassInfo_t* info, const char* name) const;
417  virtual bool ClassInfo_IsEnum(const char* name) const;
418  virtual bool ClassInfo_IsScopedEnum(ClassInfo_t* info) const;
419  virtual EDataType ClassInfo_GetUnderlyingType(ClassInfo_t* info) const;
420  virtual bool ClassInfo_IsLoaded(ClassInfo_t* info) const;
421  virtual bool ClassInfo_IsValid(ClassInfo_t* info) const;
422  virtual bool ClassInfo_IsValidMethod(ClassInfo_t* info, const char* method, const char* proto, Long_t* offset, ROOT::EFunctionMatchMode /* mode */ = ROOT::kConversionMatch) const;
423  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;
424  virtual int ClassInfo_Next(ClassInfo_t* info) const;
425  virtual void* ClassInfo_New(ClassInfo_t* info) const;
426  virtual void* ClassInfo_New(ClassInfo_t* info, int n) const;
427  virtual void* ClassInfo_New(ClassInfo_t* info, int n, void* arena) const;
428  virtual void* ClassInfo_New(ClassInfo_t* info, void* arena) const;
429  virtual Long_t ClassInfo_Property(ClassInfo_t* info) const;
430  virtual int ClassInfo_Size(ClassInfo_t* info) const;
431  virtual Long_t ClassInfo_Tagnum(ClassInfo_t* info) const;
432  virtual const char* ClassInfo_FileName(ClassInfo_t* info) const;
433  virtual const char* ClassInfo_FullName(ClassInfo_t* info) const;
434  virtual const char* ClassInfo_Name(ClassInfo_t* info) const;
435  virtual const char* ClassInfo_Title(ClassInfo_t* info) const;
436  virtual const char* ClassInfo_TmpltName(ClassInfo_t* info) const;
437 
438  // BaseClassInfo interface
439  virtual void BaseClassInfo_Delete(BaseClassInfo_t* bcinfo) const;
440  virtual BaseClassInfo_t* BaseClassInfo_Factory(ClassInfo_t* info) const;
441  virtual BaseClassInfo_t* BaseClassInfo_Factory(ClassInfo_t* derived,
442  ClassInfo_t* base) const;
443  virtual int BaseClassInfo_Next(BaseClassInfo_t* bcinfo) const;
444  virtual int BaseClassInfo_Next(BaseClassInfo_t* bcinfo, int onlyDirect) const;
445  virtual Long_t BaseClassInfo_Offset(BaseClassInfo_t* toBaseClassInfo, void * address, bool isDerivedObject) const;
446  virtual Long_t BaseClassInfo_Property(BaseClassInfo_t* bcinfo) const;
447  virtual Long_t BaseClassInfo_Tagnum(BaseClassInfo_t* bcinfo) const;
448  virtual ClassInfo_t*BaseClassInfo_ClassInfo(BaseClassInfo_t * /* bcinfo */) const;
449  virtual const char* BaseClassInfo_FullName(BaseClassInfo_t* bcinfo) const;
450  virtual const char* BaseClassInfo_Name(BaseClassInfo_t* bcinfo) const;
451  virtual const char* BaseClassInfo_TmpltName(BaseClassInfo_t* bcinfo) const;
452 
453  // DataMemberInfo interface
454  virtual DeclId_t GetDeclId(DataMemberInfo_t *info) const;
455  virtual int DataMemberInfo_ArrayDim(DataMemberInfo_t* dminfo) const;
456  virtual void DataMemberInfo_Delete(DataMemberInfo_t* dminfo) const;
457  virtual DataMemberInfo_t* DataMemberInfo_Factory(ClassInfo_t* clinfo = 0) const;
458  virtual DataMemberInfo_t *DataMemberInfo_Factory(DeclId_t declid, ClassInfo_t* clinfo) const;
459  virtual DataMemberInfo_t* DataMemberInfo_FactoryCopy(DataMemberInfo_t* dminfo) const;
460  virtual bool DataMemberInfo_IsValid(DataMemberInfo_t* dminfo) const;
461  virtual int DataMemberInfo_MaxIndex(DataMemberInfo_t* dminfo, Int_t dim) const;
462  virtual int DataMemberInfo_Next(DataMemberInfo_t* dminfo) const;
463  virtual Long_t DataMemberInfo_Offset(DataMemberInfo_t* dminfo) const;
464  virtual Long_t DataMemberInfo_Property(DataMemberInfo_t* dminfo) const;
465  virtual Long_t DataMemberInfo_TypeProperty(DataMemberInfo_t* dminfo) const;
466  virtual int DataMemberInfo_TypeSize(DataMemberInfo_t* dminfo) const;
467  virtual const char* DataMemberInfo_TypeName(DataMemberInfo_t* dminfo) const;
468  virtual const char* DataMemberInfo_TypeTrueName(DataMemberInfo_t* dminfo) const;
469  virtual const char* DataMemberInfo_Name(DataMemberInfo_t* dminfo) const;
470  virtual const char* DataMemberInfo_Title(DataMemberInfo_t* dminfo) const;
471  virtual const char* DataMemberInfo_ValidArrayIndex(DataMemberInfo_t* dminfo) const;
472  virtual void SetDeclAttr(DeclId_t, const char* /* attribute */);
473 
474 
475  // Function Template interface
476  virtual DeclId_t GetDeclId(FuncTempInfo_t *info) const;
477  virtual void FuncTempInfo_Delete(FuncTempInfo_t * /* ft_info */) const;
478  virtual FuncTempInfo_t *FuncTempInfo_Factory(DeclId_t declid) const;
479  virtual FuncTempInfo_t *FuncTempInfo_FactoryCopy(FuncTempInfo_t * /* ft_info */) const;
480  virtual Bool_t FuncTempInfo_IsValid(FuncTempInfo_t * /* ft_info */) const;
481  virtual UInt_t FuncTempInfo_TemplateNargs(FuncTempInfo_t * /* ft_info */) const;
482  virtual UInt_t FuncTempInfo_TemplateMinReqArgs(FuncTempInfo_t * /* ft_info */) const;
483  virtual Long_t FuncTempInfo_Property(FuncTempInfo_t * /* ft_info */) const;
484  virtual Long_t FuncTempInfo_ExtraProperty(FuncTempInfo_t * /* ft_info */) const;
485  virtual void FuncTempInfo_Name(FuncTempInfo_t * /* ft_info */, TString& name) const;
486  virtual void FuncTempInfo_Title(FuncTempInfo_t * /* ft_info */, TString& name) const;
487 
488  // MethodInfo interface
489  virtual DeclId_t GetDeclId(MethodInfo_t *info) const;
490  virtual void MethodInfo_CreateSignature(MethodInfo_t* minfo, TString& signature) const;
491  virtual void MethodInfo_Delete(MethodInfo_t* minfo) const;
492  virtual MethodInfo_t* MethodInfo_Factory() const;
493  virtual MethodInfo_t* MethodInfo_Factory(ClassInfo_t *clinfo) const;
494  virtual MethodInfo_t *MethodInfo_Factory(DeclId_t declid) const;
495  virtual MethodInfo_t* MethodInfo_FactoryCopy(MethodInfo_t* minfo) const;
496  virtual void* MethodInfo_InterfaceMethod(MethodInfo_t* minfo) const;
497  virtual bool MethodInfo_IsValid(MethodInfo_t* minfo) const;
498  virtual int MethodInfo_NArg(MethodInfo_t* minfo) const;
499  virtual int MethodInfo_NDefaultArg(MethodInfo_t* minfo) const;
500  virtual int MethodInfo_Next(MethodInfo_t* minfo) const;
501  virtual Long_t MethodInfo_Property(MethodInfo_t* minfo) const;
502  virtual Long_t MethodInfo_ExtraProperty(MethodInfo_t* minfo) const;
503  virtual TypeInfo_t* MethodInfo_Type(MethodInfo_t* minfo) const;
504  virtual EReturnType MethodInfo_MethodCallReturnType(MethodInfo_t* minfo) const;
505  virtual const char* MethodInfo_GetMangledName(MethodInfo_t* minfo) const;
506  virtual const char* MethodInfo_GetPrototype(MethodInfo_t* minfo) const;
507  virtual const char* MethodInfo_Name(MethodInfo_t* minfo) const;
508  virtual const char* MethodInfo_TypeName(MethodInfo_t* minfo) const;
509  virtual std::string MethodInfo_TypeNormalizedName(MethodInfo_t* minfo) const;
510  virtual const char* MethodInfo_Title(MethodInfo_t* minfo) const;
511 
512  // MethodArgInfo interface
513  virtual void MethodArgInfo_Delete(MethodArgInfo_t* marginfo) const;
514  virtual MethodArgInfo_t* MethodArgInfo_Factory() const;
515  virtual MethodArgInfo_t* MethodArgInfo_Factory(MethodInfo_t *minfo) const;
516  virtual MethodArgInfo_t* MethodArgInfo_FactoryCopy(MethodArgInfo_t* marginfo) const;
517  virtual bool MethodArgInfo_IsValid(MethodArgInfo_t* marginfo) const;
518  virtual int MethodArgInfo_Next(MethodArgInfo_t* marginfo) const;
519  virtual Long_t MethodArgInfo_Property(MethodArgInfo_t* marginfo) const;
520  virtual const char* MethodArgInfo_DefaultValue(MethodArgInfo_t* marginfo) const;
521  virtual const char* MethodArgInfo_Name(MethodArgInfo_t* marginfo) const;
522  virtual const char* MethodArgInfo_TypeName(MethodArgInfo_t* marginfo) const;
523  virtual std::string MethodArgInfo_TypeNormalizedName(MethodArgInfo_t *marginfo) const;
524 
525  // TypeInfo interface
526  virtual void TypeInfo_Delete(TypeInfo_t* tinfo) const;
527  virtual TypeInfo_t* TypeInfo_Factory() const;
528  virtual TypeInfo_t *TypeInfo_Factory(const char* name) const;
529  virtual TypeInfo_t* TypeInfo_FactoryCopy(TypeInfo_t* /* tinfo */) const;
530  virtual void TypeInfo_Init(TypeInfo_t* tinfo, const char* funcname) const;
531  virtual bool TypeInfo_IsValid(TypeInfo_t* tinfo) const;
532  virtual const char* TypeInfo_Name(TypeInfo_t* /* info */) const;
533  virtual Long_t TypeInfo_Property(TypeInfo_t* tinfo) const;
534  virtual int TypeInfo_RefType(TypeInfo_t* /* tinfo */) const;
535  virtual int TypeInfo_Size(TypeInfo_t* tinfo) const;
536  virtual const char* TypeInfo_TrueName(TypeInfo_t* tinfo) const;
537 
538  // TypedefInfo interface
539  virtual DeclId_t GetDeclId(TypedefInfo_t *info) const;
540  virtual void TypedefInfo_Delete(TypedefInfo_t* tinfo) const;
541  virtual TypedefInfo_t* TypedefInfo_Factory() const;
542  virtual TypedefInfo_t* TypedefInfo_Factory(const char* name) const;
543  virtual TypedefInfo_t* TypedefInfo_FactoryCopy(TypedefInfo_t* tinfo) const;
544  virtual void TypedefInfo_Init(TypedefInfo_t* tinfo, const char* name) const;
545  virtual bool TypedefInfo_IsValid(TypedefInfo_t* tinfo) const;
546  virtual int TypedefInfo_Next(TypedefInfo_t* tinfo) const;
547  virtual Long_t TypedefInfo_Property(TypedefInfo_t* tinfo) const;
548  virtual int TypedefInfo_Size(TypedefInfo_t* tinfo) const;
549  virtual const char* TypedefInfo_TrueName(TypedefInfo_t* tinfo) const;
550  virtual const char* TypedefInfo_Name(TypedefInfo_t* tinfo) const;
551  virtual const char* TypedefInfo_Title(TypedefInfo_t* tinfo) const;
552 
553  std::set<TClass*>& GetModTClasses() { return fModTClasses; }
554 
555  void HandleNewDecl(const void* DV, bool isDeserialized, std::set<TClass*>& modifiedClasses);
556  void UpdateListsOnCommitted(const cling::Transaction &T);
557  void UpdateListsOnUnloaded(const cling::Transaction &T);
558  void InvalidateGlobal(const clang::Decl *D);
559  void TransactionRollback(const cling::Transaction &T);
560  void LibraryLoaded(const void* dyLibHandle, const char* canonicalName);
561  void LibraryUnloaded(const void* dyLibHandle, const char* canonicalName);
562 
563 private: // Private Utility Functions and Classes
564  template <typename List, typename Object>
565  static void RemoveAndInvalidateObject(List &L, Object *O) {
566  // Invalidate stored information by setting the `xxxInfo_t' to nullptr.
567  if (O && O->IsValid())
568  L.Unload(O), O->Update(nullptr);
569  }
570 
571  void InvalidateCachedDecl(const std::tuple<TListOfDataMembers*,
572  TListOfFunctions*,
573  TListOfFunctionTemplates*,
574  TListOfEnums*> &Lists, const clang::Decl *D);
575 
576  class SuspendAutoloadingRAII {
577  TCling *fTCling = nullptr;
578  bool fOldValue;
579 
580  public:
581  SuspendAutoloadingRAII(TCling *tcling) : fTCling(tcling) { fOldValue = fTCling->SetClassAutoloading(false); }
582  ~SuspendAutoloadingRAII() { fTCling->SetClassAutoloading(fOldValue); }
583  };
584 
585  class TUniqueString {
586  public:
587  TUniqueString() = delete;
588  TUniqueString(const TUniqueString &) = delete;
589  TUniqueString(Long64_t size);
590  const char *Data();
591  bool Append(const std::string &str);
592  private:
593  std::string fContent;
594  std::set<size_t> fLinesHashSet;
595  std::hash<std::string> fHashFunc;
596  };
597 
598  TCling();
599  TCling(const TCling&); // NOT IMPLEMENTED
600  TCling& operator=(const TCling&); // NOT IMPLEMENTED
601 
602  void Execute(TMethod*, TObjArray*, int* /*error*/ = 0)
603  {
604  }
605 
606  void UpdateListOfLoadedSharedLibraries();
607  void RegisterLoadedSharedLibrary(const char* name);
608  void AddFriendToClass(clang::FunctionDecl*, clang::CXXRecordDecl*) const;
609 
610  std::map<std::string, llvm::StringRef> fPendingRdicts;
611  void RegisterRdictForLoadPCM(const std::string &pcmFileNameFullPath, llvm::StringRef *pcmContent);
612  void LoadPCM(std::string pcmFileNameFullPath);
613  void LoadPCMImpl(TFile &pcmFile);
614 
615  void InitRootmapFile(const char *name);
616  int ReadRootmapFile(const char *rootmapfile, TUniqueString* uniqueString = nullptr);
617  Bool_t HandleNewTransaction(const cling::Transaction &T);
618  bool IsClassAutoloadingEnabled() const;
619  void ProcessClassesToUpdate();
620  cling::Interpreter *GetInterpreterImpl() const { return fInterpreter.get(); }
621  cling::MetaProcessor *GetMetaProcessorImpl() const { return fMetaProcessor.get(); }
622 
623  friend void TCling__RegisterRdictForLoadPCM(const std::string &pcmFileNameFullPath, llvm::StringRef *pcmContent);
624  friend cling::Interpreter* TCling__GetInterpreter();
625 };
626 
627 #endif