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
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&); // intentionally not implemented
152 TSplitType &operator=(const TSplitType &); // intentionally not implemented
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; }
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);
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
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<");}
188 inline bool IsStdArray(std::string_view name) {return 0 == name.compare(0, 6, "array<");}
191 {
192 return 0 == name.compare(0, 10, "std::pair<") || 0 == name.compare(0, 5, "pair<");
193 }
196 {
197 return 0 == name.compare(0, 17, "std::__pair_base<") || 0 == name.compare(0, 12, "__pair_base<");
198 }
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 }
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#else
230 char *demangled_name = abi::__cxa_demangle(mangled_name, 0, 0, &errorCode);
231 if (!demangled_name || errorCode) {
232 free(demangled_name);
233 return nullptr;
234 }
235#endif
236 return demangled_name;
237 }
238 char* DemangleTypeIdName(const std::type_info& ti, int& errorCode);
239
240
241 /// Result of splitting a function declaration into
242 /// fReturnType fScopeName::fFunctionName<fFunctionTemplateArguments>(fFunctionParameters)
244 /// Return type of the function, might be empty if the function declaration string did not provide it.
245 std::string fReturnType;
246
247 /// Name of the scope qualification of the function, possibly empty
248 std::string fScopeName;
249
250 /// Name of the function
251 std::string fFunctionName;
252
253 /// Template arguments of the function template specialization, if any; will contain one element "" for
254 /// `function<>()`
255 std::vector<std::string> fFunctionTemplateArguments;
256
257 /// Function parameters.
258 std::vector<std::string> fFunctionParameters;
259 };
260
261 /// Split a function declaration into its different parts.
263}
264
265#endif
l unsigned short
Definition: Converters.cxx:862
char name[80]
Definition: TGX11.cxx:109
int type
Definition: TGX11.cxx:120
#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...
Definition: StringConv.hxx:21
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.
Definition: TClassEdit.cxx:511
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'
Definition: TClassEdit.cxx:800
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
@ kForwardlist
Definition: TClassEdit.h:96
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'
Definition: TClassEdit.cxx:818
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'.
Definition: TClassEdit.cxx:887
bool IsDefPred(const char *predname, const char *classname)
return whether or not 'predname' is the STL default predicate for type 'classname'
Definition: TClassEdit.cxx:809
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:921
std::string GetUniquePtrType(std::string_view name)
Definition: TClassEdit.h:200
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: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.
Definition: TClassEdit.cxx:555
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:833
bool IsDefAlloc(const char *alloc, const char *classname)
return whether or not 'allocname' is the STL default allocator for type 'classname'
Definition: TClassEdit.cxx:600
bool IsUniquePtr(std::string_view name)
Definition: TClassEdit.h:186
@ kDropTrailStar
Definition: TClassEdit.h:76
@ 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
@ kDropPredicate
Definition: TClassEdit.h:88
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:243
std::string fFunctionName
Name of the function.
Definition: TClassEdit.h:251
std::vector< std::string > fFunctionTemplateArguments
Template arguments of the function template specialization, if any; will contain one element "" for f...
Definition: TClassEdit.h:255
std::string fScopeName
Name of the scope qualification of the function, possibly empty.
Definition: TClassEdit.h:248
std::vector< std::string > fFunctionParameters
Function parameters.
Definition: TClassEdit.h:258
std::string fReturnType
Return type of the function, might be empty if the function declaration string did not provide it.
Definition: TClassEdit.h:245
TSplitType & operator=(const TSplitType &)
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
TSplitType(const TSplitType &)
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 ...
Definition: TClassEdit.cxx:172
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:139
static void output(int code)
Definition: gifencode.c:226