Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TClassEdit.h
Go to the documentation of this file.
1// @(#)root/metautils:$Id$
2// Author: Victor Perev 10/04/2003
3// Philippe Canal 05/2004
4
5/*************************************************************************
6 * Copyright (C) 1995-2003, Rene Brun and Fons Rademakers. *
7 * All rights reserved. *
8 * *
9 * For the licensing terms see $ROOTSYS/LICENSE. *
10 * For the list of contributors see $ROOTSYS/README/CREDITS. *
11 *************************************************************************/
12
13#ifndef ROOT_TClassEdit
14#define ROOT_TClassEdit
15
16#include <ROOT/RConfig.hxx>
17#include "RConfigure.h"
18#include <stdlib.h>
19#ifdef R__WIN32
20#ifndef UNDNAME_COMPLETE
21#define UNDNAME_COMPLETE 0x0000
22#endif
23extern "C" {
24 char *__unDName(char *demangled, const char *mangled, int out_len,
25 void * (* pAlloc )(size_t), void (* pFree )(void *),
26 unsigned short int flags);
27}
28#else
29#include <cxxabi.h>
30#endif
31#include <string>
32#include <vector>
33#include <array>
34
35#include "ESTLType.h"
36
37#ifdef R__OLDHPACC
38namespace std {
39 using ::string;
40 using ::vector;
41}
42#endif
43
44#if defined(__CYGWIN__)
45// std::to_string is missing on cygwin with gcc 4.8.2-2 and 4.8.3
46#include <sstream>
47namespace std {
48 template <typename T>
49 string to_string(T value) {
50 ostringstream os;
51 os << value;
52 return os.str();
53 }
54}
55#endif
56
57namespace cling {
58 class Interpreter;
59}
60namespace ROOT {
61 namespace TMetaUtils {
62 class TNormalizedCtxt;
63 }
64}
65#include "ROOT/RStringView.hxx"
66
67// TClassEdit is used to manipulate class and type names.
68//
69// This class does not dependent on any other ROOT facility
70// so that it can be used by rootcint.
71
72namespace TClassEdit {
73
74 enum EModType {
75 kNone = 0,
78 kDropAlloc = 1<<2,
81 kDropStlDefault = 1<<5, /* implies kDropDefaultAlloc */
82 kDropComparator = 1<<6, /* if the class has a comparator, drops BOTH the comparator and the Allocator */
83 kDropAllDefault = 1<<7, /* Drop default template parameter even in non STL classes */
84 kLong64 = 1<<8, /* replace all 'long long' with Long64_t. */
85 kDropStd = 1<<9, /* Drop any std:: */
86 kKeepOuterConst = 1<<10,/* Make sure to keep the const keyword even outside the template parameters */
87 kResolveTypedef = 1<<11,/* Strip all typedef except Double32_t and co. */
88 kDropPredicate = 1<<12,/* Drop the predicate if applies to the collection */
89 kDropHash = 1<<13 /* Drop the hash if applies to the collection */
90 };
91
92 enum ESTLType {
108 };
109
110 enum class EComplexType : short {
111 kNone,
112 kDouble,
113 kFloat,
114 kInt,
115 kLong
116 };
117
118 EComplexType GetComplexType(const char*);
119
121 public:
124
125 virtual bool ExistingTypeCheck(const std::string & /*tname*/,
126 std::string & /*result*/) = 0;
127 virtual void GetPartiallyDesugaredName(std::string & /*nameLong*/) = 0;
128 virtual bool IsAlreadyPartiallyDesugaredName(const std::string & /*nondef*/,
129 const std::string & /*nameLong*/) = 0;
130 virtual bool IsDeclaredScope(const std::string & /*base*/, bool & /*isInlined*/) = 0;
131 virtual bool GetPartiallyDesugaredNameWithScopeHandling(const std::string & /*tname*/,
132 std::string & /*result*/,
133 bool /* dropstd */ = true) = 0;
134 virtual void ShuttingDownSignal() = 0;
135 };
136
137 struct TSplitType {
138
139 const char *fName; // Original spelling of the name.
140 std::vector<std::string> fElements;
141 int fNestedLocation; // Stores the location of the tail (nested names) in nestedLoc (0 indicates no tail).
142
143 TSplitType(const char *type2split, EModType mode = TClassEdit::kNone);
144
145 int IsSTLCont(int testAlloc=0) const;
146 ROOT::ESTLType IsInSTL() const;
147 void ShortType(std::string &answer, int mode);
148 bool IsTemplate();
149
150 private:
151 TSplitType(const TSplitType&) = delete;
152 TSplitType &operator=(const TSplitType &) = delete;
153 };
154
156
157 std::string CleanType (const char *typeDesc,int mode = 0,const char **tail=0);
158 inline bool IsArtificial(std::string_view name) { return name.find('@') != name.npos; }
159 inline bool IsArtificial(ROOT::Internal::TStringView name) {return IsArtificial(std::string_view(name)); }
160 bool IsDefAlloc(const char *alloc, const char *classname);
161 bool IsDefAlloc(const char *alloc, const char *keyclassname, const char *valueclassname);
162 bool IsDefComp (const char *comp , const char *classname);
163 bool IsDefPred(const char *predname, const char *classname);
164 bool IsDefHash(const char *hashname, const char *classname);
165 bool IsInterpreterDetail(const char *type);
166 bool IsSTLBitset(const char *type);
167 ROOT::ESTLType UnderlyingIsSTLCont(std::string_view type);
169 ROOT::ESTLType IsSTLCont (std::string_view type);
171 int IsSTLCont (const char *type,int testAlloc);
172 bool IsStdClass(const char *type);
173 bool IsVectorBool(const char *name);
174 void GetNormalizedName(std::string &norm_name, std::string_view name);
175 inline void GetNormalizedName (std::string &norm_name, ROOT::Internal::TStringView name) { return GetNormalizedName(norm_name, std::string_view(name)); }
176 std::string GetLong64_Name(const char *original);
177 std::string GetLong64_Name(const std::string& original);
178 int GetSplit (const char *type, std::vector<std::string> &output, int &nestedLoc, EModType mode = TClassEdit::kNone);
179 ROOT::ESTLType STLKind(std::string_view type); //Kind of stl container
180 inline ROOT::ESTLType STLKind(ROOT::Internal::TStringView type) { return STLKind(std::string_view(type)); }
181 int STLArgs (int kind); //Min number of arguments without allocator
182 std::string ResolveTypedef(const char *tname, bool resolveAll = false);
183 std::string ShortType (const char *typeDesc, int mode);
184 std::string InsertStd(const char *tname);
185 const char* GetUnqualifiedName(const char*name);
186 inline bool IsUniquePtr(std::string_view name) {return 0 == name.compare(0, 11, "unique_ptr<");}
187 inline bool IsUniquePtr(ROOT::Internal::TStringView name) {return IsUniquePtr(std::string_view(name)); }
188 inline bool IsStdArray(std::string_view name) {return 0 == name.compare(0, 6, "array<");}
189 inline bool IsStdArray(ROOT::Internal::TStringView name) {return IsStdArray(std::string_view(name)); }
190 inline bool IsStdPair(std::string_view name)
191 {
192 return 0 == name.compare(0, 10, "std::pair<") || 0 == name.compare(0, 5, "pair<");
193 }
194 inline bool IsStdPair(ROOT::Internal::TStringView name) {return IsStdPair(std::string_view(name)); }
195 inline bool IsStdPairBase(std::string_view name)
196 {
197 return 0 == name.compare(0, 17, "std::__pair_base<") || 0 == name.compare(0, 12, "__pair_base<");
198 }
199 inline bool IsStdPairBase(ROOT::Internal::TStringView name) {return IsStdPairBase(std::string_view(name)); }
200 inline std::string GetUniquePtrType(std::string_view name)
201 {
202 // Find the first template parameter
203 std::vector<std::string> v;
204 int i;
205 GetSplit(name.data(), v, i);
206 return v[1];
207 }
208 inline std::string GetUniquePtrType(ROOT::Internal::TStringView name) {return GetUniquePtrType(std::string_view(name)); }
209 std::string GetNameForIO(const std::string& templateInstanceName,
211 bool* hasChanged = nullptr);
212 bool GetStdArrayProperties(const char* typeName,
213 std::string& typeNameBuf,
214 std::array<int, 5>& maxIndices,
215 int& ndim);
216
217 inline char* DemangleName(const char* mangled_name, int& errorCode)
218 {
219 // Demangle in a portable way the name.
220 // IMPORTANT: The caller is responsible for freeing the returned const char*
221
222 errorCode=0;
223#ifdef R__WIN32
224 char *demangled_name = __unDName(0, mangled_name, 0, malloc, free, UNDNAME_COMPLETE);
225 if (!demangled_name) {
226 errorCode = -1;
227 return nullptr;
228 }
229 std::string demangledName = demangled_name;
230 if (demangledName.compare(0, 6, "class ") == 0)
231 demangledName.erase(0, 6);
232 else if (demangledName.compare(0, 7, "struct ") == 0)
233 demangledName.erase(0, 7);
234 strcpy(demangled_name, demangledName.c_str());
235#else
236 char *demangled_name = abi::__cxa_demangle(mangled_name, 0, 0, &errorCode);
237 if (!demangled_name || errorCode) {
238 free(demangled_name);
239 return nullptr;
240 }
241#endif
242 return demangled_name;
243 }
244 char* DemangleTypeIdName(const std::type_info& ti, int& errorCode);
245
246
247 /// Result of splitting a function declaration into
248 /// fReturnType fScopeName::fFunctionName<fFunctionTemplateArguments>(fFunctionParameters)
250 /// Return type of the function, might be empty if the function declaration string did not provide it.
251 std::string fReturnType;
252
253 /// Name of the scope qualification of the function, possibly empty
254 std::string fScopeName;
255
256 /// Name of the function
257 std::string fFunctionName;
258
259 /// Template arguments of the function template specialization, if any; will contain one element "" for
260 /// `function<>()`
261 std::vector<std::string> fFunctionTemplateArguments;
262
263 /// Function parameters.
264 std::vector<std::string> fFunctionParameters;
265 };
266
267 /// Split a function declaration into its different parts.
268 bool SplitFunction(std::string_view decl, FunctionSplitInfo &result);
269}
270
271#endif
char name[80]
Definition TGX11.cxx:110
int type
Definition TGX11.cxx:121
#define free
Definition civetweb.c:1539
#define malloc
Definition civetweb.c:1536
virtual bool GetPartiallyDesugaredNameWithScopeHandling(const std::string &, std::string &, bool=true)=0
virtual bool IsAlreadyPartiallyDesugaredName(const std::string &, const std::string &)=0
virtual bool IsDeclaredScope(const std::string &, bool &)=0
virtual void GetPartiallyDesugaredName(std::string &)=0
virtual bool ExistingTypeCheck(const std::string &, std::string &)=0
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
ESTLType
Definition ESTLType.h:28
@ kSTLbitset
Definition ESTLType.h:37
@ kSTLmap
Definition ESTLType.h:33
@ kSTLunorderedmultiset
Definition ESTLType.h:43
@ kSTLend
Definition ESTLType.h:46
@ kSTLset
Definition ESTLType.h:35
@ kSTLmultiset
Definition ESTLType.h:36
@ kSTLdeque
Definition ESTLType.h:32
@ kSTLvector
Definition ESTLType.h:30
@ kSTLunorderedmultimap
Definition ESTLType.h:45
@ kSTLunorderedset
Definition ESTLType.h:42
@ kSTLlist
Definition ESTLType.h:31
@ kSTLforwardlist
Definition ESTLType.h:41
@ kSTLunorderedmap
Definition ESTLType.h:44
@ kNotSTL
Definition ESTLType.h:29
@ kSTLmultimap
Definition ESTLType.h:34
ROOT::ESTLType STLKind(std::string_view type)
Converts STL container name to number.
bool IsStdPairBase(std::string_view name)
Definition TClassEdit.h:195
bool IsDefComp(const char *comp, const char *classname)
return whether or not 'compare' is the STL default comparator for type 'classname'
std::string ResolveTypedef(const char *tname, bool resolveAll=false)
std::string CleanType(const char *typeDesc, int mode=0, const char **tail=0)
Cleanup type description, redundant blanks removed and redundant tail ignored return *tail = pointer ...
@ kUnorderedMultiSet
Definition TClassEdit.h:103
@ kUnorderedMultiMap
Definition TClassEdit.h:105
bool IsStdArray(std::string_view name)
Definition TClassEdit.h:188
bool IsStdClass(const char *type)
return true if the class belongs to the std namespace
bool IsDefHash(const char *hashname, const char *classname)
return whether or not 'hashname' is the STL default hash for type 'classname'
bool IsStdPair(std::string_view name)
Definition TClassEdit.h:190
bool IsInterpreterDetail(const char *type)
Return true if the type is one the interpreter details which are only forward declared (ClassInfo_t e...
std::string InsertStd(const char *tname)
bool SplitFunction(std::string_view decl, FunctionSplitInfo &result)
Split a function declaration into its different parts.
std::string GetLong64_Name(const char *original)
Replace 'long long' and 'unsigned long long' by 'Long64_t' and 'ULong64_t'.
bool IsDefPred(const char *predname, const char *classname)
return whether or not 'predname' is the STL default predicate for type 'classname'
char * DemangleTypeIdName(const std::type_info &ti, int &errorCode)
Demangle in a portable way the type id name.
const char * GetUnqualifiedName(const char *name)
Return the start of the unqualified name include in 'original'.
std::string GetUniquePtrType(std::string_view name)
Definition TClassEdit.h:200
bool IsVectorBool(const char *name)
void Init(TClassEdit::TInterpreterLookupHelper *helper)
ROOT::ESTLType IsSTLCont(std::string_view type)
type : type name: vector<list<classA,allocator>,allocator> result: 0 : not stl container code of cont...
std::string ShortType(const char *typeDesc, int mode)
Return the absolute type of typeDesc.
char * DemangleName(const char *mangled_name, int &errorCode)
Definition TClassEdit.h:217
bool IsArtificial(std::string_view name)
Definition TClassEdit.h:158
bool GetStdArrayProperties(const char *typeName, std::string &typeNameBuf, std::array< int, 5 > &maxIndices, int &ndim)
std::string GetNameForIO(const std::string &templateInstanceName, TClassEdit::EModType mode=TClassEdit::kNone, bool *hasChanged=nullptr)
int STLArgs(int kind)
Return number of arguments for STL container before allocator.
int GetSplit(const char *type, std::vector< std::string > &output, int &nestedLoc, EModType mode=TClassEdit::kNone)
Stores in output (after emptying it) the split type.
void GetNormalizedName(std::string &norm_name, std::string_view name)
Return the normalized name.
bool IsDefAlloc(const char *alloc, const char *classname)
return whether or not 'allocname' is the STL default allocator for type 'classname'
bool IsUniquePtr(std::string_view name)
Definition TClassEdit.h:186
@ kDropDefaultAlloc
Definition TClassEdit.h:77
@ kResolveTypedef
Definition TClassEdit.h:87
@ kInnedMostClass
Definition TClassEdit.h:80
@ kDropComparator
Definition TClassEdit.h:82
@ kDropAllDefault
Definition TClassEdit.h:83
@ kKeepOuterConst
Definition TClassEdit.h:86
@ kDropStlDefault
Definition TClassEdit.h:81
bool IsSTLBitset(const char *type)
Return true is the name is std::bitset<number> or bitset<number>
ROOT::ESTLType UnderlyingIsSTLCont(std::string_view type)
Return the type of STL collection, if any, that is the underlying type of the given type.
EComplexType GetComplexType(const char *)
Result of splitting a function declaration into fReturnType fScopeName::fFunctionName<fFunctionTempla...
Definition TClassEdit.h:249
std::string fFunctionName
Name of the function.
Definition TClassEdit.h:257
std::vector< std::string > fFunctionTemplateArguments
Template arguments of the function template specialization, if any; will contain one element "" for f...
Definition TClassEdit.h:261
std::string fScopeName
Name of the scope qualification of the function, possibly empty.
Definition TClassEdit.h:254
std::vector< std::string > fFunctionParameters
Function parameters.
Definition TClassEdit.h:264
std::string fReturnType
Return type of the function, might be empty if the function declaration string did not provide it.
Definition TClassEdit.h:251
TSplitType(const TSplitType &)=delete
bool IsTemplate()
Check if the type is a template.
int IsSTLCont(int testAlloc=0) const
type : type name: vector<list<classA,allocator>,allocator> testAlloc: if true, we test allocator,...
std::vector< std::string > fElements
Definition TClassEdit.h:140
ROOT::ESTLType IsInSTL() const
type : type name: vector<list<classA,allocator>,allocator>[::iterator] result: 0 : not stl container ...
TSplitType & operator=(const TSplitType &)=delete
void ShortType(std::string &answer, int mode)
Return the absolute type of typeDesc into the string answ.
static void output(int code)
Definition gifencode.c:226