Logo ROOT  
Reference Guide
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#include <typeinfo>
35
36#include "ESTLType.h"
37
38#ifdef R__OLDHPACC
39namespace std {
40 using ::string;
41 using ::vector;
42}
43#endif
44
45#if defined(__CYGWIN__)
46// std::to_string is missing on cygwin with gcc 4.8.2-2 and 4.8.3
47#include <sstream>
48namespace std {
49 template <typename T>
50 string to_string(T value) {
51 ostringstream os;
52 os << value;
53 return os.str();
54 }
55}
56#endif
57
58namespace cling {
59 class Interpreter;
60}
61namespace ROOT {
62 namespace TMetaUtils {
63 class TNormalizedCtxt;
64 }
65}
66#include "ROOT/RStringView.hxx"
67
68// TClassEdit is used to manipulate class and type names.
69//
70// This class does not dependent on any other ROOT facility
71// so that it can be used by rootcint.
72
73namespace TClassEdit {
74
75 enum EModType {
76 kNone = 0,
79 kDropAlloc = 1<<2,
82 kDropStlDefault = 1<<5, /* implies kDropDefaultAlloc */
83 kDropComparator = 1<<6, /* if the class has a comparator, drops BOTH the comparator and the Allocator */
84 kDropAllDefault = 1<<7, /* Drop default template parameter even in non STL classes */
85 kLong64 = 1<<8, /* replace all 'long long' with Long64_t. */
86 kDropStd = 1<<9, /* Drop any std:: */
87 kKeepOuterConst = 1<<10,/* Make sure to keep the const keyword even outside the template parameters */
88 kResolveTypedef = 1<<11,/* Strip all typedef except Double32_t and co. */
89 kDropPredicate = 1<<12,/* Drop the predicate if applies to the collection */
90 kDropHash = 1<<13 /* Drop the hash if applies to the collection */
91 };
92
93 enum ESTLType {
109 };
110
111 enum class EComplexType : short {
112 kNone,
113 kDouble,
114 kFloat,
115 kInt,
116 kLong
117 };
118
119 EComplexType GetComplexType(const char*);
120
122 public:
125
126 virtual bool ExistingTypeCheck(const std::string & /*tname*/,
127 std::string & /*result*/) = 0;
128 virtual void GetPartiallyDesugaredName(std::string & /*nameLong*/) = 0;
129 virtual bool IsAlreadyPartiallyDesugaredName(const std::string & /*nondef*/,
130 const std::string & /*nameLong*/) = 0;
131 virtual bool IsDeclaredScope(const std::string & /*base*/, bool & /*isInlined*/) = 0;
132 virtual bool GetPartiallyDesugaredNameWithScopeHandling(const std::string & /*tname*/,
133 std::string & /*result*/,
134 bool /* dropstd */ = true) = 0;
135 virtual void ShuttingDownSignal() = 0;
136 };
137
138 struct TSplitType {
139
140 const char *fName; // Original spelling of the name.
141 std::vector<std::string> fElements;
142 int fNestedLocation; // Stores the location of the tail (nested names) in nestedLoc (0 indicates no tail).
143
144 TSplitType(const char *type2split, EModType mode = TClassEdit::kNone);
145
146 int IsSTLCont(int testAlloc=0) const;
147 ROOT::ESTLType IsInSTL() const;
148 void ShortType(std::string &answer, int mode);
149 bool IsTemplate();
150
151 private:
152 TSplitType(const TSplitType&) = delete;
153 TSplitType &operator=(const TSplitType &) = delete;
154 };
155
157
158 std::string CleanType (const char *typeDesc,int mode = 0,const char **tail=0);
159 inline bool IsArtificial(std::string_view name) { return name.find('@') != name.npos; }
161 bool IsDefAlloc(const char *alloc, const char *classname);
162 bool IsDefAlloc(const char *alloc, const char *keyclassname, const char *valueclassname);
163 bool IsDefComp (const char *comp , const char *classname);
164 bool IsDefPred(const char *predname, const char *classname);
165 bool IsDefHash(const char *hashname, const char *classname);
166 bool IsInterpreterDetail(const char *type);
167 bool IsSTLBitset(const char *type);
172 int IsSTLCont (const char *type,int testAlloc);
173 bool IsStdClass(const char *type);
174 bool IsVectorBool(const char *name);
175 void GetNormalizedName(std::string &norm_name, std::string_view name);
176 inline void GetNormalizedName (std::string &norm_name, ROOT::Internal::TStringView name) { return GetNormalizedName(norm_name, std::string_view(name)); }
177 std::string GetLong64_Name(const char *original);
178 std::string GetLong64_Name(const std::string& original);
179 int GetSplit (const char *type, std::vector<std::string> &output, int &nestedLoc, EModType mode = TClassEdit::kNone);
180 ROOT::ESTLType STLKind(std::string_view type); //Kind of stl container
182 int STLArgs (int kind); //Min number of arguments without allocator
183 std::string ResolveTypedef(const char *tname, bool resolveAll = false);
184 std::string ShortType (const char *typeDesc, int mode);
185 std::string InsertStd(const char *tname);
186 const char* GetUnqualifiedName(const char*name);
187 inline bool IsUniquePtr(std::string_view name) {return 0 == name.compare(0, 11, "unique_ptr<");}
189 inline bool IsStdArray(std::string_view name) {return 0 == name.compare(0, 6, "array<");}
192 {
193 return 0 == name.compare(0, 10, "std::pair<") || 0 == name.compare(0, 5, "pair<");
194 }
197 {
198 return 0 == name.compare(0, 17, "std::__pair_base<") || 0 == name.compare(0, 12, "__pair_base<");
199 }
202 {
203 // Find the first template parameter
204 std::vector<std::string> v;
205 int i;
206 GetSplit(name.data(), v, i);
207 return v[1];
208 }
210 std::string GetNameForIO(const std::string& templateInstanceName,
212 bool* hasChanged = nullptr);
213 bool GetStdArrayProperties(const char* typeName,
214 std::string& typeNameBuf,
215 std::array<int, 5>& maxIndices,
216 int& ndim);
217
218 inline char* DemangleName(const char* mangled_name, int& errorCode)
219 {
220 // Demangle in a portable way the name.
221 // IMPORTANT: The caller is responsible for freeing the returned const char*
222
223 errorCode=0;
224#ifdef R__WIN32
225 char *demangled_name = __unDName(0, mangled_name, 0, malloc, free, UNDNAME_COMPLETE);
226 if (!demangled_name) {
227 errorCode = -1;
228 return nullptr;
229 }
230 std::string demangledName = demangled_name;
231 if (demangledName.compare(0, 6, "class ") == 0)
232 demangledName.erase(0, 6);
233 else if (demangledName.compare(0, 7, "struct ") == 0)
234 demangledName.erase(0, 7);
235 strcpy(demangled_name, demangledName.c_str());
236#else
237 char *demangled_name = abi::__cxa_demangle(mangled_name, 0, 0, &errorCode);
238 if (!demangled_name || errorCode) {
239 free(demangled_name);
240 return nullptr;
241 }
242#endif
243 return demangled_name;
244 }
245 char* DemangleTypeIdName(const std::type_info& ti, int& errorCode);
246
247
248 /// Result of splitting a function declaration into
249 /// fReturnType fScopeName::fFunctionName<fFunctionTemplateArguments>(fFunctionParameters)
251 /// Return type of the function, might be empty if the function declaration string did not provide it.
252 std::string fReturnType;
253
254 /// Name of the scope qualification of the function, possibly empty
255 std::string fScopeName;
256
257 /// Name of the function
258 std::string fFunctionName;
259
260 /// Template arguments of the function template specialization, if any; will contain one element "" for
261 /// `function<>()`
262 std::vector<std::string> fFunctionTemplateArguments;
263
264 /// Function parameters.
265 std::vector<std::string> fFunctionParameters;
266 };
267
268 /// Split a function declaration into its different parts.
270}
271
272#endif
l unsigned short
Definition: Converters.cxx:880
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
basic_string_view< char > string_view
double T(double x)
Definition: ChebyshevPol.h:34
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:47
@ 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.
Definition: TClassEdit.cxx:511
bool IsStdPairBase(std::string_view name)
Definition: TClassEdit.h:196
bool IsDefComp(const char *comp, const char *classname)
return whether or not 'compare' is the STL default comparator for type 'classname'
Definition: TClassEdit.cxx:804
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:104
@ kUnorderedMultiMap
Definition: TClassEdit.h:106
@ kForwardlist
Definition: TClassEdit.h:97
bool IsStdArray(std::string_view name)
Definition: TClassEdit.h:189
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'
Definition: TClassEdit.cxx:822
bool IsStdPair(std::string_view name)
Definition: TClassEdit.h:191
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'.
Definition: TClassEdit.cxx:891
bool IsDefPred(const char *predname, const char *classname)
return whether or not 'predname' is the STL default predicate for type 'classname'
Definition: TClassEdit.cxx:813
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'.
Definition: TClassEdit.cxx:925
std::string GetUniquePtrType(std::string_view name)
Definition: TClassEdit.h:201
bool IsVectorBool(const char *name)
void Init(TClassEdit::TInterpreterLookupHelper *helper)
Definition: TClassEdit.cxx:154
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:218
bool IsArtificial(std::string_view name)
Definition: TClassEdit.h:159
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.
Definition: TClassEdit.cxx:558
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.
Definition: TClassEdit.cxx:837
bool IsDefAlloc(const char *alloc, const char *classname)
return whether or not 'allocname' is the STL default allocator for type 'classname'
Definition: TClassEdit.cxx:604
bool IsUniquePtr(std::string_view name)
Definition: TClassEdit.h:187
@ kDropTrailStar
Definition: TClassEdit.h:77
@ kDropDefaultAlloc
Definition: TClassEdit.h:78
@ kResolveTypedef
Definition: TClassEdit.h:88
@ kInnedMostClass
Definition: TClassEdit.h:81
@ kDropComparator
Definition: TClassEdit.h:83
@ kDropAllDefault
Definition: TClassEdit.h:84
@ kKeepOuterConst
Definition: TClassEdit.h:87
@ kDropStlDefault
Definition: TClassEdit.h:82
@ kDropPredicate
Definition: TClassEdit.h:89
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 *)
Definition: TClassEdit.cxx:120
Result of splitting a function declaration into fReturnType fScopeName::fFunctionName<fFunctionTempla...
Definition: TClassEdit.h:250
std::string fFunctionName
Name of the function.
Definition: TClassEdit.h:258
std::vector< std::string > fFunctionTemplateArguments
Template arguments of the function template specialization, if any; will contain one element "" for f...
Definition: TClassEdit.h:262
std::string fScopeName
Name of the scope qualification of the function, possibly empty.
Definition: TClassEdit.h:255
std::vector< std::string > fFunctionParameters
Function parameters.
Definition: TClassEdit.h:265
std::string fReturnType
Return type of the function, might be empty if the function declaration string did not provide it.
Definition: TClassEdit.h:252
TSplitType(const TSplitType &)=delete
bool IsTemplate()
Check if the type is a template.
Definition: TClassEdit.cxx:502
int IsSTLCont(int testAlloc=0) const
type : type name: vector<list<classA,allocator>,allocator> testAlloc: if true, we test allocator,...
Definition: TClassEdit.cxx:189
TSplitType(const char *type2split, EModType mode=TClassEdit::kNone)
default constructor
Definition: TClassEdit.cxx:162
std::vector< std::string > fElements
Definition: TClassEdit.h:141
ROOT::ESTLType IsInSTL() const
type : type name: vector<list<classA,allocator>,allocator>[::iterator] result: 0 : not stl container ...
Definition: TClassEdit.cxx:172
TSplitType & operator=(const TSplitType &)=delete
void ShortType(std::string &answer, int mode)
Return the absolute type of typeDesc into the string answ.
Definition: TClassEdit.cxx:233
const char * fName
Definition: TClassEdit.h:140
static void output(int code)
Definition: gifencode.c:226