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 bool IsDefAlloc(const char *alloc, const char *classname);
159 bool IsDefAlloc(const char *alloc, const char *keyclassname, const char *valueclassname);
160 bool IsDefComp (const char *comp , const char *classname);
161 bool IsDefPred(const char *predname, const char *classname);
162 bool IsDefHash(const char *hashname, const char *classname);
163 bool IsInterpreterDetail(const char *type);
164 bool IsSTLBitset(const char *type);
169 int IsSTLCont (const char *type,int testAlloc);
170 bool IsStdClass(const char *type);
171 bool IsVectorBool(const char *name);
172 void GetNormalizedName(std::string &norm_name, std::string_view name);
173 inline void GetNormalizedName (std::string &norm_name, ROOT::Internal::TStringView name) { return GetNormalizedName(norm_name, std::string_view(name)); }
174 std::string GetLong64_Name(const char *original);
175 std::string GetLong64_Name(const std::string& original);
176 int GetSplit (const char *type, std::vector<std::string> &output, int &nestedLoc, EModType mode = TClassEdit::kNone);
177 ROOT::ESTLType STLKind(std::string_view type); //Kind of stl container
179 int STLArgs (int kind); //Min number of arguments without allocator
180 std::string ResolveTypedef(const char *tname, bool resolveAll = false);
181 std::string ShortType (const char *typeDesc, int mode);
182 std::string InsertStd(const char *tname);
183 const char* GetUnqualifiedName(const char*name);
184 inline bool IsUniquePtr(std::string_view name) {return 0 == name.compare(0, 11, "unique_ptr<");}
186 inline bool IsStdArray(std::string_view name) {return 0 == name.compare(0, 6, "array<");}
189 {
190 // Find the first template parameter
191 std::vector<std::string> v;
192 int i;
193 GetSplit(name.data(), v, i);
194 return v[1];
195 }
197 std::string GetNameForIO(const std::string& templateInstanceName,
199 bool* hasChanged = nullptr);
200 bool GetStdArrayProperties(const char* typeName,
201 std::string& typeNameBuf,
202 std::array<int, 5>& maxIndices,
203 int& ndim);
204
205 inline char* DemangleName(const char* mangled_name, int& errorCode)
206 {
207 // Demangle in a portable way the name.
208 // IMPORTANT: The caller is responsible for freeing the returned const char*
209
210 errorCode=0;
211#ifdef R__WIN32
212 char *demangled_name = __unDName(0, mangled_name, 0, malloc, free, UNDNAME_COMPLETE);
213 if (!demangled_name) {
214 errorCode = -1;
215 return nullptr;
216 }
217#else
218 char *demangled_name = abi::__cxa_demangle(mangled_name, 0, 0, &errorCode);
219 if (!demangled_name || errorCode) {
220 free(demangled_name);
221 return nullptr;
222 }
223#endif
224 return demangled_name;
225 }
226 char* DemangleTypeIdName(const std::type_info& ti, int& errorCode);
227
228
229 /// Result of splitting a function declaration into
230 /// fReturnType fScopeName::fFunctionName<fFunctionTemplateArguments>(fFunctionParameters)
232 /// Return type of the function, might be empty if the function declaration string did not provide it.
233 std::string fReturnType;
234
235 /// Name of the scope qualification of the function, possibly empty
236 std::string fScopeName;
237
238 /// Name of the function
239 std::string fFunctionName;
240
241 /// Template arguments of the function template specialization, if any; will contain one element "" for
242 /// `function<>()`
243 std::vector<std::string> fFunctionTemplateArguments;
244
245 /// Function parameters.
246 std::vector<std::string> fFunctionParameters;
247 };
248
249 /// Split a function declaration into its different parts.
251}
252
253#endif
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
VSD Structures.
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:512
bool IsDefComp(const char *comp, const char *classname)
return whether or not 'compare' is the STL default comparator for type 'classname'
Definition: TClassEdit.cxx:799
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:186
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:817
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:874
bool IsDefPred(const char *predname, const char *classname)
return whether or not 'predname' is the STL default predicate for type 'classname'
Definition: TClassEdit.cxx:808
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:908
std::string GetUniquePtrType(std::string_view name)
Definition: TClassEdit.h:188
bool IsVectorBool(const char *name)
void Init(TClassEdit::TInterpreterLookupHelper *helper)
Definition: TClassEdit.cxx:155
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:205
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:556
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.
Definition: TClassEdit.cxx:995
void GetNormalizedName(std::string &norm_name, std::string_view name)
Return the normalized name.
Definition: TClassEdit.cxx:832
bool IsDefAlloc(const char *alloc, const char *classname)
return whether or not 'allocname' is the STL default allocator for type 'classname'
Definition: TClassEdit.cxx:601
bool IsUniquePtr(std::string_view name)
Definition: TClassEdit.h:184
@ 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:121
Result of splitting a function declaration into fReturnType fScopeName::fFunctionName<fFunctionTempla...
Definition: TClassEdit.h:231
std::string fFunctionName
Name of the function.
Definition: TClassEdit.h:239
std::vector< std::string > fFunctionTemplateArguments
Template arguments of the function template specialization, if any; will contain one element "" for f...
Definition: TClassEdit.h:243
std::string fScopeName
Name of the scope qualification of the function, possibly empty.
Definition: TClassEdit.h:236
std::vector< std::string > fFunctionParameters
Function parameters.
Definition: TClassEdit.h:246
std::string fReturnType
Return type of the function, might be empty if the function declaration string did not provide it.
Definition: TClassEdit.h:233
TSplitType & operator=(const TSplitType &)
bool IsTemplate()
Check if the type is a template.
Definition: TClassEdit.cxx:503
int IsSTLCont(int testAlloc=0) const
type : type name: vector<list<classA,allocator>,allocator> testAlloc: if true, we test allocator,...
Definition: TClassEdit.cxx:190
TSplitType(const char *type2split, EModType mode=TClassEdit::kNone)
default constructor
Definition: TClassEdit.cxx:163
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:173
void ShortType(std::string &answer, int mode)
Return the absolute type of typeDesc into the string answ.
Definition: TClassEdit.cxx:234
const char * fName
Definition: TClassEdit.h:139
static void output(int code)
Definition: gifencode.c:226