1 //===-- Mangled.cpp ---------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 // FreeBSD9-STABLE requires this to know about size_t in cxxabi.h
14 // Cannot enable the builtin demangler on msvc as it does not support the cpp11 within the implementation.
15 #elif defined (__FreeBSD__)
16 #define LLDB_USE_BUILTIN_DEMANGLER
21 #ifdef LLDB_USE_BUILTIN_DEMANGLER
23 // Provide a fast-path demangler implemented in FastDemangle.cpp until it can
24 // replace the existing C++ demangler with a complete implementation
25 namespace lldb_private
27 extern char * FastDemangle (const char * mangled_name,
28 long mangled_name_length);
31 //----------------------------------------------------------------------
33 // http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_demangle.cpp
37 // - remove the "__cxxabiv1" namespace
38 // - stripped GCC attributes()
39 // - removed extern "C" from the cxa_demangle function
40 // - Changed the scope of the unnamed namespace to include cxa_demangle
42 // - Added "#undef _LIBCPP_EXTERN_TEMPLATE" to avoid warning
43 //----------------------------------------------------------------------
45 #undef _LIBCPP_EXTERN_TEMPLATE // Avoid warning below
47 //===-------------------------- cxa_demangle.cpp --------------------------===//
49 // The LLVM Compiler Infrastructure
51 // This file is dual licensed under the MIT and the University of Illinois Open
52 // Source Licenses. See LICENSE.TXT for details.
54 //===----------------------------------------------------------------------===//
56 #define _LIBCPP_EXTERN_TEMPLATE(...)
57 #define _LIBCPP_NO_EXCEPTIONS
81 const char* parse_type(const char* first, const char* last, C& db);
83 const char* parse_encoding(const char* first, const char* last, C& db);
85 const char* parse_name(const char* first, const char* last, C& db);
87 const char* parse_expression(const char* first, const char* last, C& db);
89 const char* parse_template_args(const char* first, const char* last, C& db);
91 const char* parse_operator_name(const char* first, const char* last, C& db);
93 const char* parse_unqualified_name(const char* first, const char* last, C& db);
95 const char* parse_decltype(const char* first, const char* last, C& db);
99 print_stack(const C& db)
101 printf("---------\n");
103 for (auto& s : db.names)
104 printf("{%s#%s}\n", s.first.c_str(), s.second.c_str());
107 for (auto& v : db.subs)
110 printf("S%i_ = {", i);
114 printf("{%s#%s}", s.first.c_str(), s.second.c_str());
118 printf("template_param:\n");
119 for (auto& t : db.template_param)
126 printf("T%i_ = {", i);
130 printf("{%s#%s}", s.first.c_str(), s.second.c_str());
135 printf("---------\n\n");
140 print_state(const char* msg, const char* first, const char* last, const C& db)
143 for (; first != last; ++first)
144 printf("%c", *first);
149 // <number> ::= [n] <non-negative decimal integer>
152 parse_number(const char* first, const char* last)
156 const char* t = first;
165 else if ('1' <= *t && *t <= '9')
168 while (first != last && std::isdigit(*first))
176 template <class Float>
180 struct float_data<float>
182 static const size_t mangled_size = 8;
183 static const size_t max_demangled_size = 24;
184 static constexpr const char* spec = "%af";
187 constexpr const char* float_data<float>::spec;
190 struct float_data<double>
192 static const size_t mangled_size = 16;
193 static const size_t max_demangled_size = 32;
194 static constexpr const char* spec = "%a";
197 constexpr const char* float_data<double>::spec;
200 struct float_data<long double>
202 static const size_t mangled_size = 20; // May need to be adjusted to 16 or 24 on other platforms
203 static const size_t max_demangled_size = 40;
204 static constexpr const char* spec = "%LaL";
207 constexpr const char* float_data<long double>::spec;
209 template <class Float, class C>
211 parse_floating_number(const char* first, const char* last, C& db)
213 const size_t N = float_data<Float>::mangled_size;
214 if (static_cast<std::size_t>(last - first) > N)
220 char buf[sizeof(Float)];
222 const char* t = first;
224 for (; t != last; ++t, ++e)
228 unsigned d1 = isdigit(*t) ? static_cast<unsigned>(*t - '0') :
229 static_cast<unsigned>(*t - 'a' + 10);
231 unsigned d0 = isdigit(*t) ? static_cast<unsigned>(*t - '0') :
232 static_cast<unsigned>(*t - 'a' + 10);
233 *e = static_cast<char>((d1 << 4) + d0);
237 #if __LITTLE_ENDIAN__
238 std::reverse(buf, e);
240 char num[float_data<Float>::max_demangled_size] = {0};
241 int n = snprintf(num, sizeof(num), float_data<Float>::spec, value);
242 if (static_cast<std::size_t>(n) >= sizeof(num))
244 db.names.push_back(typename C::String(num, static_cast<std::size_t>(n)));
251 // <source-name> ::= <positive length number> <identifier>
255 parse_source_name(const char* first, const char* last, C& db)
260 if (isdigit(c) && first+1 != last)
262 const char* t = first+1;
263 size_t n = static_cast<size_t>(c - '0');
264 for (c = *t; isdigit(c); c = *t)
266 n = n * 10 + static_cast<size_t>(c - '0');
270 if (static_cast<size_t>(last - t) >= n)
272 typename C::String r(t, n);
273 if (r.substr(0, 10) == "_GLOBAL__N")
274 db.names.push_back("(anonymous namespace)");
276 db.names.push_back(std::move(r));
284 // <substitution> ::= S <seq-id> _
286 // <substitution> ::= Sa # ::std::allocator
287 // <substitution> ::= Sb # ::std::basic_string
288 // <substitution> ::= Ss # ::std::basic_string < char,
289 // ::std::char_traits<char>,
290 // ::std::allocator<char> >
291 // <substitution> ::= Si # ::std::basic_istream<char, std::char_traits<char> >
292 // <substitution> ::= So # ::std::basic_ostream<char, std::char_traits<char> >
293 // <substitution> ::= Sd # ::std::basic_iostream<char, std::char_traits<char> >
297 parse_substitution(const char* first, const char* last, C& db)
299 if (last - first >= 2)
306 db.names.push_back("std::allocator");
310 db.names.push_back("std::basic_string");
314 db.names.push_back("std::string");
318 db.names.push_back("std::istream");
322 db.names.push_back("std::ostream");
326 db.names.push_back("std::iostream");
330 if (!db.subs.empty())
332 for (const auto& n : db.subs.front())
333 db.names.push_back(n);
338 if (std::isdigit(first[1]) || std::isupper(first[1]))
341 const char* t = first+1;
342 if (std::isdigit(*t))
343 sub = static_cast<size_t>(*t - '0');
345 sub = static_cast<size_t>(*t - 'A') + 10;
346 for (++t; t != last && (std::isdigit(*t) || std::isupper(*t)); ++t)
349 if (std::isdigit(*t))
350 sub += static_cast<size_t>(*t - '0');
352 sub += static_cast<size_t>(*t - 'A') + 10;
354 if (t == last || *t != '_')
357 if (sub < db.subs.size())
359 for (const auto& n : db.subs[sub])
360 db.names.push_back(n);
371 // <builtin-type> ::= v # void
375 // ::= a # signed char
376 // ::= h # unsigned char
378 // ::= t # unsigned short
380 // ::= j # unsigned int
382 // ::= m # unsigned long
383 // ::= x # long long, __int64
384 // ::= y # unsigned long long, __int64
386 // ::= o # unsigned __int128
389 // ::= e # long double, __float80
390 // ::= g # __float128
392 // ::= Dd # IEEE 754r decimal floating point (64 bits)
393 // ::= De # IEEE 754r decimal floating point (128 bits)
394 // ::= Df # IEEE 754r decimal floating point (32 bits)
395 // ::= Dh # IEEE 754r half-precision floating point (16 bits)
398 // ::= Da # auto (in dependent new-expressions)
399 // ::= Dn # std::nullptr_t (i.e., decltype(nullptr))
400 // ::= u <source-name> # vendor extended type
404 parse_builtin_type(const char* first, const char* last, C& db)
411 db.names.push_back("void");
415 db.names.push_back("wchar_t");
419 db.names.push_back("bool");
423 db.names.push_back("char");
427 db.names.push_back("signed char");
431 db.names.push_back("unsigned char");
435 db.names.push_back("short");
439 db.names.push_back("unsigned short");
443 db.names.push_back("int");
447 db.names.push_back("unsigned int");
451 db.names.push_back("long");
455 db.names.push_back("unsigned long");
459 db.names.push_back("long long");
463 db.names.push_back("unsigned long long");
467 db.names.push_back("__int128");
471 db.names.push_back("unsigned __int128");
475 db.names.push_back("float");
479 db.names.push_back("double");
483 db.names.push_back("long double");
487 db.names.push_back("__float128");
491 db.names.push_back("...");
496 const char*t = parse_source_name(first+1, last, db);
507 db.names.push_back("decimal64");
511 db.names.push_back("decimal128");
515 db.names.push_back("decimal32");
519 db.names.push_back("decimal16");
523 db.names.push_back("char32_t");
527 db.names.push_back("char16_t");
531 db.names.push_back("auto");
535 db.names.push_back("std::nullptr_t");
546 // <CV-qualifiers> ::= [r] [V] [K]
549 parse_cv_qualifiers(const char* first, const char* last, unsigned& cv)
573 // <template-param> ::= T_ # first template parameter
574 // ::= T <parameter-2 non-negative number> _
578 parse_template_param(const char* first, const char* last, C& db)
580 if (last - first >= 2)
586 if (db.template_param.empty())
588 if (!db.template_param.back().empty())
590 for (auto& t : db.template_param.back().front())
591 db.names.push_back(t);
596 db.names.push_back("T_");
598 db.fix_forward_references = true;
601 else if (isdigit(first[1]))
603 const char* t = first+1;
604 size_t sub = static_cast<size_t>(*t - '0');
605 for (++t; t != last && isdigit(*t); ++t)
608 sub += static_cast<size_t>(*t - '0');
610 if (t == last || *t != '_' || db.template_param.empty())
613 if (sub < db.template_param.back().size())
615 for (auto& temp : db.template_param.back()[sub])
616 db.names.push_back(temp);
621 db.names.push_back(typename C::String(first, t+1));
623 db.fix_forward_references = true;
631 // cc <type> <expression> # const_cast<type> (expression)
635 parse_const_cast_expr(const char* first, const char* last, C& db)
637 if (last - first >= 3 && first[0] == 'c' && first[1] == 'c')
639 const char* t = parse_type(first+2, last, db);
642 const char* t1 = parse_expression(t, last, db);
645 if (db.names.size() < 2)
647 auto expr = db.names.back().move_full();
649 db.names.back() = "const_cast<" + db.names.back().move_full() + ">(" + expr + ")";
657 // dc <type> <expression> # dynamic_cast<type> (expression)
661 parse_dynamic_cast_expr(const char* first, const char* last, C& db)
663 if (last - first >= 3 && first[0] == 'd' && first[1] == 'c')
665 const char* t = parse_type(first+2, last, db);
668 const char* t1 = parse_expression(t, last, db);
671 if (db.names.size() < 2)
673 auto expr = db.names.back().move_full();
675 db.names.back() = "dynamic_cast<" + db.names.back().move_full() + ">(" + expr + ")";
683 // rc <type> <expression> # reinterpret_cast<type> (expression)
687 parse_reinterpret_cast_expr(const char* first, const char* last, C& db)
689 if (last - first >= 3 && first[0] == 'r' && first[1] == 'c')
691 const char* t = parse_type(first+2, last, db);
694 const char* t1 = parse_expression(t, last, db);
697 if (db.names.size() < 2)
699 auto expr = db.names.back().move_full();
701 db.names.back() = "reinterpret_cast<" + db.names.back().move_full() + ">(" + expr + ")";
709 // sc <type> <expression> # static_cast<type> (expression)
713 parse_static_cast_expr(const char* first, const char* last, C& db)
715 if (last - first >= 3 && first[0] == 's' && first[1] == 'c')
717 const char* t = parse_type(first+2, last, db);
720 const char* t1 = parse_expression(t, last, db);
723 if (db.names.size() < 2)
725 auto expr = db.names.back().move_full();
727 db.names.back() = "static_cast<" + db.names.back().move_full() + ">(" + expr + ")";
735 // sp <expression> # pack expansion
739 parse_pack_expansion(const char* first, const char* last, C& db)
741 if (last - first >= 3 && first[0] == 's' && first[1] == 'p')
743 const char* t = parse_expression(first+2, last, db);
750 // st <type> # sizeof (a type)
754 parse_sizeof_type_expr(const char* first, const char* last, C& db)
756 if (last - first >= 3 && first[0] == 's' && first[1] == 't')
758 const char* t = parse_type(first+2, last, db);
761 if (db.names.empty())
763 db.names.back() = "sizeof (" + db.names.back().move_full() + ")";
770 // sz <expr> # sizeof (a expression)
774 parse_sizeof_expr_expr(const char* first, const char* last, C& db)
776 if (last - first >= 3 && first[0] == 's' && first[1] == 'z')
778 const char* t = parse_expression(first+2, last, db);
781 if (db.names.empty())
783 db.names.back() = "sizeof (" + db.names.back().move_full() + ")";
790 // sZ <template-param> # size of a parameter pack
794 parse_sizeof_param_pack_expr(const char* first, const char* last, C& db)
796 if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'T')
798 size_t k0 = db.names.size();
799 const char* t = parse_template_param(first+2, last, db);
800 size_t k1 = db.names.size();
803 typename C::String tmp("sizeof...(");
807 tmp += db.names[k].move_full();
808 for (++k; k != k1; ++k)
809 tmp += ", " + db.names[k].move_full();
812 for (; k1 != k0; --k1)
814 db.names.push_back(std::move(tmp));
821 // <function-param> ::= fp <top-level CV-qualifiers> _ # L == 0, first parameter
822 // ::= fp <top-level CV-qualifiers> <parameter-2 non-negative number> _ # L == 0, second and later parameters
823 // ::= fL <L-1 non-negative number> p <top-level CV-qualifiers> _ # L > 0, first parameter
824 // ::= fL <L-1 non-negative number> p <top-level CV-qualifiers> <parameter-2 non-negative number> _ # L > 0, second and later parameters
828 parse_function_param(const char* first, const char* last, C& db)
830 if (last - first >= 3 && *first == 'f')
835 const char* t = parse_cv_qualifiers(first+2, last, cv);
836 const char* t1 = parse_number(t, last);
837 if (t1 != last && *t1 == '_')
839 db.names.push_back("fp" + typename C::String(t, t1));
843 else if (first[1] == 'L')
846 const char* t0 = parse_number(first+2, last);
847 if (t0 != last && *t0 == 'p')
850 const char* t = parse_cv_qualifiers(t0, last, cv);
851 const char* t1 = parse_number(t, last);
852 if (t1 != last && *t1 == '_')
854 db.names.push_back("fp" + typename C::String(t, t1));
863 // sZ <function-param> # size of a function parameter pack
867 parse_sizeof_function_param_pack_expr(const char* first, const char* last, C& db)
869 if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'f')
871 const char* t = parse_function_param(first+2, last, db);
874 if (db.names.empty())
876 db.names.back() = "sizeof...(" + db.names.back().move_full() + ")";
883 // te <expression> # typeid (expression)
884 // ti <type> # typeid (type)
888 parse_typeid_expr(const char* first, const char* last, C& db)
890 if (last - first >= 3 && first[0] == 't' && (first[1] == 'e' || first[1] == 'i'))
894 t = parse_expression(first+2, last, db);
896 t = parse_type(first+2, last, db);
899 if (db.names.empty())
901 db.names.back() = "typeid(" + db.names.back().move_full() + ")";
908 // tw <expression> # throw expression
912 parse_throw_expr(const char* first, const char* last, C& db)
914 if (last - first >= 3 && first[0] == 't' && first[1] == 'w')
916 const char* t = parse_expression(first+2, last, db);
919 if (db.names.empty())
921 db.names.back() = "throw " + db.names.back().move_full();
928 // ds <expression> <expression> # expr.*expr
932 parse_dot_star_expr(const char* first, const char* last, C& db)
934 if (last - first >= 3 && first[0] == 'd' && first[1] == 's')
936 const char* t = parse_expression(first+2, last, db);
939 const char* t1 = parse_expression(t, last, db);
942 if (db.names.size() < 2)
944 auto expr = db.names.back().move_full();
946 db.names.back().first += ".*" + expr;
954 // <simple-id> ::= <source-name> [ <template-args> ]
958 parse_simple_id(const char* first, const char* last, C& db)
962 const char* t = parse_source_name(first, last, db);
965 const char* t1 = parse_template_args(t, last, db);
968 if (db.names.size() < 2)
970 auto args = db.names.back().move_full();
972 db.names.back().first += std::move(args);
982 // <unresolved-type> ::= <template-param>
984 // ::= <substitution>
988 parse_unresolved_type(const char* first, const char* last, C& db)
992 const char* t = first;
997 size_t k0 = db.names.size();
998 t = parse_template_param(first, last, db);
999 size_t k1 = db.names.size();
1000 if (t != first && k1 == k0 + 1)
1002 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
1007 for (; k1 != k0; --k1)
1008 db.names.pop_back();
1013 t = parse_decltype(first, last, db);
1016 if (db.names.empty())
1018 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
1023 t = parse_substitution(first, last, db);
1028 if (last - first > 2 && first[1] == 't')
1030 t = parse_unqualified_name(first+2, last, db);
1033 if (db.names.empty())
1035 db.names.back().first.insert(0, "std::");
1036 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
1047 // <destructor-name> ::= <unresolved-type> # e.g., ~T or ~decltype(f())
1048 // ::= <simple-id> # e.g., ~A<2*N>
1052 parse_destructor_name(const char* first, const char* last, C& db)
1056 const char* t = parse_unresolved_type(first, last, db);
1058 t = parse_simple_id(first, last, db);
1061 if (db.names.empty())
1063 db.names.back().first.insert(0, "~");
1070 // <base-unresolved-name> ::= <simple-id> # unresolved name
1071 // extension ::= <operator-name> # unresolved operator-function-id
1072 // extension ::= <operator-name> <template-args> # unresolved operator template-id
1073 // ::= on <operator-name> # unresolved operator-function-id
1074 // ::= on <operator-name> <template-args> # unresolved operator template-id
1075 // ::= dn <destructor-name> # destructor or pseudo-destructor;
1076 // # e.g. ~X or ~X<N-1>
1080 parse_base_unresolved_name(const char* first, const char* last, C& db)
1082 if (last - first >= 2)
1084 if ((first[0] == 'o' || first[0] == 'd') && first[1] == 'n')
1086 if (first[0] == 'o')
1088 const char* t = parse_operator_name(first+2, last, db);
1091 first = parse_template_args(t, last, db);
1094 if (db.names.size() < 2)
1096 auto args = db.names.back().move_full();
1097 db.names.pop_back();
1098 db.names.back().first += std::move(args);
1104 const char* t = parse_destructor_name(first+2, last, db);
1111 const char* t = parse_simple_id(first, last, db);
1114 t = parse_operator_name(first, last, db);
1117 first = parse_template_args(t, last, db);
1120 if (db.names.size() < 2)
1122 auto args = db.names.back().move_full();
1123 db.names.pop_back();
1124 db.names.back().first += std::move(args);
1135 // <unresolved-qualifier-level> ::= <simple-id>
1139 parse_unresolved_qualifier_level(const char* first, const char* last, C& db)
1141 return parse_simple_id(first, last, db);
1144 // <unresolved-name>
1145 // extension ::= srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name>
1146 // ::= [gs] <base-unresolved-name> # x or (with "gs") ::x
1147 // ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name>
1148 // # A::x, N::y, A<T>::z; "gs" means leading "::"
1149 // ::= sr <unresolved-type> <base-unresolved-name> # T::x / decltype(p)::x
1150 // extension ::= sr <unresolved-type> <template-args> <base-unresolved-name>
1151 // # T::N::x /decltype(p)::N::x
1152 // (ignored) ::= srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name>
1156 parse_unresolved_name(const char* first, const char* last, C& db)
1158 if (last - first > 2)
1160 const char* t = first;
1161 bool global = false;
1162 if (t[0] == 'g' && t[1] == 's')
1167 const char* t2 = parse_base_unresolved_name(t, last, db);
1172 if (db.names.empty())
1174 db.names.back().first.insert(0, "::");
1178 else if (last - t > 2 && t[0] == 's' && t[1] == 'r')
1183 const char* t1 = parse_unresolved_type(t, last, db);
1184 if (t1 == t || t1 == last)
1187 t1 = parse_template_args(t, last, db);
1190 if (db.names.size() < 2)
1192 auto args = db.names.back().move_full();
1193 db.names.pop_back();
1194 db.names.back().first += std::move(args);
1198 db.names.pop_back();
1204 t1 = parse_unresolved_qualifier_level(t, last, db);
1205 if (t1 == t || t1 == last || db.names.size() < 2)
1207 auto s = db.names.back().move_full();
1208 db.names.pop_back();
1209 db.names.back().first += "::" + std::move(s);
1213 t1 = parse_base_unresolved_name(t, last, db);
1216 if (!db.names.empty())
1217 db.names.pop_back();
1220 if (db.names.size() < 2)
1222 auto s = db.names.back().move_full();
1223 db.names.pop_back();
1224 db.names.back().first += "::" + std::move(s);
1230 const char* t1 = parse_unresolved_type(t, last, db);
1234 t1 = parse_template_args(t, last, db);
1237 if (db.names.size() < 2)
1239 auto args = db.names.back().move_full();
1240 db.names.pop_back();
1241 db.names.back().first += std::move(args);
1244 t1 = parse_base_unresolved_name(t, last, db);
1247 if (!db.names.empty())
1248 db.names.pop_back();
1251 if (db.names.size() < 2)
1253 auto s = db.names.back().move_full();
1254 db.names.pop_back();
1255 db.names.back().first += "::" + std::move(s);
1260 t1 = parse_unresolved_qualifier_level(t, last, db);
1261 if (t1 == t || t1 == last)
1266 if (db.names.empty())
1268 db.names.back().first.insert(0, "::");
1272 t1 = parse_unresolved_qualifier_level(t, last, db);
1273 if (t1 == t || t1 == last || db.names.size() < 2)
1275 auto s = db.names.back().move_full();
1276 db.names.pop_back();
1277 db.names.back().first += "::" + std::move(s);
1281 t1 = parse_base_unresolved_name(t, last, db);
1284 if (!db.names.empty())
1285 db.names.pop_back();
1288 if (db.names.size() < 2)
1290 auto s = db.names.back().move_full();
1291 db.names.pop_back();
1292 db.names.back().first += "::" + std::move(s);
1301 // dt <expression> <unresolved-name> # expr.name
1305 parse_dot_expr(const char* first, const char* last, C& db)
1307 if (last - first >= 3 && first[0] == 'd' && first[1] == 't')
1309 const char* t = parse_expression(first+2, last, db);
1312 const char* t1 = parse_unresolved_name(t, last, db);
1315 if (db.names.size() < 2)
1317 auto name = db.names.back().move_full();
1318 db.names.pop_back();
1319 db.names.back().first += "." + name;
1327 // cl <expression>+ E # call
1331 parse_call_expr(const char* first, const char* last, C& db)
1333 if (last - first >= 4 && first[0] == 'c' && first[1] == 'l')
1335 const char* t = parse_expression(first+2, last, db);
1340 if (db.names.empty())
1342 db.names.back().first += db.names.back().second;
1343 db.names.back().second = typename C::String();
1344 db.names.back().first.append("(");
1345 bool first_expr = true;
1348 const char* t1 = parse_expression(t, last, db);
1349 if (t1 == t || t1 == last)
1351 if (db.names.empty())
1353 auto tmp = db.names.back().move_full();
1354 db.names.pop_back();
1357 if (db.names.empty())
1361 db.names.back().first.append(", ");
1364 db.names.back().first.append(tmp);
1369 if (db.names.empty())
1371 db.names.back().first.append(")");
1378 // [gs] nw <expression>* _ <type> E # new (expr-list) type
1379 // [gs] nw <expression>* _ <type> <initializer> # new (expr-list) type (init)
1380 // [gs] na <expression>* _ <type> E # new[] (expr-list) type
1381 // [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type (init)
1382 // <initializer> ::= pi <expression>* E # parenthesized initialization
1386 parse_new_expr(const char* first, const char* last, C& db)
1388 if (last - first >= 4)
1390 const char* t = first;
1391 bool parsed_gs = false;
1392 if (t[0] == 'g' && t[1] == 's')
1397 if (t[0] == 'n' && (t[1] == 'w' || t[1] == 'a'))
1399 bool is_array = t[1] == 'a';
1403 bool has_expr_list = false;
1404 bool first_expr = true;
1407 const char* t1 = parse_expression(t, last, db);
1408 if (t1 == t || t1 == last)
1410 has_expr_list = true;
1413 if (db.names.empty())
1415 auto tmp = db.names.back().move_full();
1416 db.names.pop_back();
1419 if (db.names.empty())
1421 db.names.back().first.append(", ");
1422 db.names.back().first.append(tmp);
1429 const char* t1 = parse_type(t, last, db);
1430 if (t1 == t || t1 == last)
1433 bool has_init = false;
1434 if (last - t >= 3 && t[0] == 'p' && t[1] == 'i')
1441 t1 = parse_expression(t, last, db);
1442 if (t1 == t || t1 == last)
1446 if (db.names.empty())
1448 auto tmp = db.names.back().move_full();
1449 db.names.pop_back();
1452 if (db.names.empty())
1454 db.names.back().first.append(", ");
1455 db.names.back().first.append(tmp);
1464 typename C::String init_list;
1467 if (db.names.empty())
1469 init_list = db.names.back().move_full();
1470 db.names.pop_back();
1472 if (db.names.empty())
1474 auto type = db.names.back().move_full();
1475 db.names.pop_back();
1476 typename C::String expr_list;
1479 if (db.names.empty())
1481 expr_list = db.names.back().move_full();
1482 db.names.pop_back();
1484 typename C::String r;
1492 r += "(" + expr_list + ") ";
1495 r += " (" + init_list + ")";
1496 db.names.push_back(std::move(r));
1503 // cv <type> <expression> # conversion with one argument
1504 // cv <type> _ <expression>* E # conversion with a different number of arguments
1508 parse_conversion_expr(const char* first, const char* last, C& db)
1510 if (last - first >= 3 && first[0] == 'c' && first[1] == 'v')
1512 bool try_to_parse_template_args = db.try_to_parse_template_args;
1513 db.try_to_parse_template_args = false;
1514 const char* t = parse_type(first+2, last, db);
1515 db.try_to_parse_template_args = try_to_parse_template_args;
1516 if (t != first+2 && t != last)
1520 const char* t1 = parse_expression(t, last, db);
1531 db.names.emplace_back();
1534 bool first_expr = true;
1537 const char* t1 = parse_expression(t, last, db);
1538 if (t1 == t || t1 == last)
1542 if (db.names.empty())
1544 auto tmp = db.names.back().move_full();
1545 db.names.pop_back();
1548 if (db.names.empty())
1550 db.names.back().first.append(", ");
1551 db.names.back().first.append(tmp);
1560 if (db.names.size() < 2)
1562 auto tmp = db.names.back().move_full();
1563 db.names.pop_back();
1564 db.names.back() = "(" + db.names.back().move_full() + ")(" + tmp + ")";
1571 // pt <expression> <expression> # expr->name
1575 parse_arrow_expr(const char* first, const char* last, C& db)
1577 if (last - first >= 3 && first[0] == 'p' && first[1] == 't')
1579 const char* t = parse_expression(first+2, last, db);
1582 const char* t1 = parse_expression(t, last, db);
1585 if (db.names.size() < 2)
1587 auto tmp = db.names.back().move_full();
1588 db.names.pop_back();
1589 db.names.back().first += "->";
1590 db.names.back().first += tmp;
1598 // <ref-qualifier> ::= R # & ref-qualifier
1599 // <ref-qualifier> ::= O # && ref-qualifier
1601 // <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E
1605 parse_function_type(const char* first, const char* last, C& db)
1607 if (first != last && *first == 'F')
1609 const char* t = first+1;
1612 bool externC = false;
1619 const char* t1 = parse_type(t, last, db);
1623 typename C::String sig("(");
1629 db.names.pop_back();
1642 if (*t == 'R' && t+1 != last && t[1] == 'E')
1648 if (*t == 'O' && t+1 != last && t[1] == 'E')
1654 size_t k0 = db.names.size();
1655 t1 = parse_type(t, last, db);
1656 size_t k1 = db.names.size();
1657 if (t1 == t || t1 == last)
1659 for (size_t k = k0; k < k1; ++k)
1663 sig += db.names[k].move_full();
1665 for (size_t k = k0; k < k1; ++k)
1666 db.names.pop_back();
1679 if (db.names.empty())
1681 db.names.back().first += " ";
1682 db.names.back().second.insert(0, sig);
1690 // <pointer-to-member-type> ::= M <class type> <member type>
1694 parse_pointer_to_member_type(const char* first, const char* last, C& db)
1696 if (first != last && *first == 'M')
1698 const char* t = parse_type(first+1, last, db);
1701 const char* t2 = parse_type(t, last, db);
1704 if (db.names.size() < 2)
1706 auto func = std::move(db.names.back());
1707 db.names.pop_back();
1708 auto class_type = std::move(db.names.back());
1709 if (func.second.front() == '(')
1711 db.names.back().first = std::move(func.first) + "(" + class_type.move_full() + "::*";
1712 db.names.back().second = ")" + std::move(func.second);
1716 db.names.back().first = std::move(func.first) + " " + class_type.move_full() + "::*";
1717 db.names.back().second = std::move(func.second);
1726 // <array-type> ::= A <positive dimension number> _ <element type>
1727 // ::= A [<dimension expression>] _ <element type>
1731 parse_array_type(const char* first, const char* last, C& db)
1733 if (first != last && *first == 'A' && first+1 != last)
1735 if (first[1] == '_')
1737 const char* t = parse_type(first+2, last, db);
1740 if (db.names.empty())
1742 if (db.names.back().second.substr(0, 2) == " [")
1743 db.names.back().second.erase(0, 1);
1744 db.names.back().second.insert(0, " []");
1748 else if ('1' <= first[1] && first[1] <= '9')
1750 const char* t = parse_number(first+1, last);
1751 if (t != last && *t == '_')
1753 const char* t2 = parse_type(t+1, last, db);
1756 if (db.names.empty())
1758 if (db.names.back().second.substr(0, 2) == " [")
1759 db.names.back().second.erase(0, 1);
1760 db.names.back().second.insert(0, " [" + typename C::String(first+1, t) + "]");
1767 const char* t = parse_expression(first+1, last, db);
1768 if (t != first+1 && t != last && *t == '_')
1770 const char* t2 = parse_type(++t, last, db);
1773 if (db.names.size() < 2)
1775 auto type = std::move(db.names.back());
1776 db.names.pop_back();
1777 auto expr = std::move(db.names.back());
1778 db.names.back().first = std::move(type.first);
1779 if (type.second.substr(0, 2) == " [")
1780 type.second.erase(0, 1);
1781 db.names.back().second = " [" + expr.move_full() + "]" + std::move(type.second);
1790 // <decltype> ::= Dt <expression> E # decltype of an id-expression or class member access (C++0x)
1791 // ::= DT <expression> E # decltype of an expression (C++0x)
1795 parse_decltype(const char* first, const char* last, C& db)
1797 if (last - first >= 4 && first[0] == 'D')
1804 const char* t = parse_expression(first+2, last, db);
1805 if (t != first+2 && t != last && *t == 'E')
1807 if (db.names.empty())
1809 db.names.back() = "decltype(" + db.names.back().move_full() + ")";
1820 // <vector-type> ::= Dv <positive dimension number> _
1821 // <extended element type>
1822 // ::= Dv [<dimension expression>] _ <element type>
1823 // <extended element type> ::= <element type>
1824 // ::= p # AltiVec vector pixel
1828 parse_vector_type(const char* first, const char* last, C& db)
1830 if (last - first > 3 && first[0] == 'D' && first[1] == 'v')
1832 if ('1' <= first[2] && first[2] <= '9')
1834 const char* t = parse_number(first+2, last);
1835 if (t == last || *t != '_')
1837 const char* num = first + 2;
1838 size_t sz = static_cast<size_t>(t - num);
1843 const char* t1 = parse_type(t, last, db);
1846 if (db.names.empty())
1848 db.names.back().first += " vector[" + typename C::String(num, sz) + "]";
1855 db.names.push_back("pixel vector[" + typename C::String(num, sz) + "]");
1862 typename C::String num;
1863 const char* t1 = first+2;
1866 const char* t = parse_expression(t1, last, db);
1869 if (db.names.empty())
1871 num = db.names.back().move_full();
1872 db.names.pop_back();
1876 if (t1 != last && *t1 == '_' && ++t1 != last)
1878 const char* t = parse_type(t1, last, db);
1881 if (db.names.empty())
1883 db.names.back().first += " vector[" + num + "]";
1892 // <type> ::= <builtin-type>
1893 // ::= <function-type>
1894 // ::= <class-enum-type>
1896 // ::= <pointer-to-member-type>
1897 // ::= <template-param>
1898 // ::= <template-template-param> <template-args>
1900 // ::= <substitution>
1901 // ::= <CV-qualifiers> <type>
1902 // ::= P <type> # pointer-to
1903 // ::= R <type> # reference-to
1904 // ::= O <type> # rvalue reference-to (C++0x)
1905 // ::= C <type> # complex pair (C 2000)
1906 // ::= G <type> # imaginary (C 2000)
1907 // ::= Dp <type> # pack expansion (C++0x)
1908 // ::= U <source-name> <type> # vendor extended type qualifier
1909 // extension := U <objc-name> <objc-type> # objc-type<identifier>
1910 // extension := <vector-type> # <vector-type> starts with Dv
1912 // <objc-name> ::= <k0 number> objcproto <k1 number> <identifier> # k0 = 9 + <number of digits in k1> + k1
1913 // <objc-type> := <source-name> # PU<11+>objcproto 11objc_object<source-name> 11objc_object -> id<source-name>
1917 parse_type(const char* first, const char* last, C& db)
1928 const char* t = parse_cv_qualifiers(first, last, cv);
1931 bool is_function = *t == 'F';
1932 size_t k0 = db.names.size();
1933 const char* t1 = parse_type(t, last, db);
1934 size_t k1 = db.names.size();
1939 db.subs.emplace_back(db.names.get_allocator());
1940 for (size_t k = k0; k < k1; ++k)
1944 size_t p = db.names[k].second.size();
1945 if (db.names[k].second[p-2] == '&')
1947 else if (db.names[k].second.back() == '&')
1951 db.names[k].second.insert(p, " const");
1956 db.names[k].second.insert(p, " volatile");
1960 db.names[k].second.insert(p, " restrict");
1965 db.names[k].first.append(" const");
1967 db.names[k].first.append(" volatile");
1969 db.names[k].first.append(" restrict");
1971 db.subs.back().push_back(db.names[k]);
1980 const char* t = parse_builtin_type(first, last, db);
1990 t = parse_array_type(first, last, db);
1993 if (db.names.empty())
1996 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2000 t = parse_type(first+1, last, db);
2003 if (db.names.empty())
2005 db.names.back().first.append(" complex");
2007 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2011 t = parse_function_type(first, last, db);
2014 if (db.names.empty())
2017 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2021 t = parse_type(first+1, last, db);
2024 if (db.names.empty())
2026 db.names.back().first.append(" imaginary");
2028 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2032 t = parse_pointer_to_member_type(first, last, db);
2035 if (db.names.empty())
2038 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2043 size_t k0 = db.names.size();
2044 t = parse_type(first+1, last, db);
2045 size_t k1 = db.names.size();
2048 db.subs.emplace_back(db.names.get_allocator());
2049 for (size_t k = k0; k < k1; ++k)
2051 if (db.names[k].second.substr(0, 2) == " [")
2053 db.names[k].first += " (";
2054 db.names[k].second.insert(0, ")");
2056 else if (db.names[k].second.front() == '(')
2058 db.names[k].first += "(";
2059 db.names[k].second.insert(0, ")");
2061 db.names[k].first.append("&&");
2062 db.subs.back().push_back(db.names[k]);
2070 size_t k0 = db.names.size();
2071 t = parse_type(first+1, last, db);
2072 size_t k1 = db.names.size();
2075 db.subs.emplace_back(db.names.get_allocator());
2076 for (size_t k = k0; k < k1; ++k)
2078 if (db.names[k].second.substr(0, 2) == " [")
2080 db.names[k].first += " (";
2081 db.names[k].second.insert(0, ")");
2083 else if (db.names[k].second.front() == '(')
2085 db.names[k].first += "(";
2086 db.names[k].second.insert(0, ")");
2088 if (first[1] != 'U' || db.names[k].first.substr(0, 12) != "objc_object<")
2090 db.names[k].first.append("*");
2094 db.names[k].first.replace(0, 11, "id");
2096 db.subs.back().push_back(db.names[k]);
2104 size_t k0 = db.names.size();
2105 t = parse_type(first+1, last, db);
2106 size_t k1 = db.names.size();
2109 db.subs.emplace_back(db.names.get_allocator());
2110 for (size_t k = k0; k < k1; ++k)
2112 if (db.names[k].second.substr(0, 2) == " [")
2114 db.names[k].first += " (";
2115 db.names[k].second.insert(0, ")");
2117 else if (db.names[k].second.front() == '(')
2119 db.names[k].first += "(";
2120 db.names[k].second.insert(0, ")");
2122 db.names[k].first.append("&");
2123 db.subs.back().push_back(db.names[k]);
2131 size_t k0 = db.names.size();
2132 t = parse_template_param(first, last, db);
2133 size_t k1 = db.names.size();
2136 db.subs.emplace_back(db.names.get_allocator());
2137 for (size_t k = k0; k < k1; ++k)
2138 db.subs.back().push_back(db.names[k]);
2139 if (db.try_to_parse_template_args && k1 == k0+1)
2141 const char* t1 = parse_template_args(t, last, db);
2144 auto args = db.names.back().move_full();
2145 db.names.pop_back();
2146 db.names.back().first += std::move(args);
2147 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2156 if (first+1 != last)
2158 t = parse_source_name(first+1, last, db);
2161 const char* t2 = parse_type(t, last, db);
2164 if (db.names.size() < 2)
2166 auto type = db.names.back().move_full();
2167 db.names.pop_back();
2168 if (db.names.back().first.substr(0, 9) != "objcproto")
2170 db.names.back() = type + " " + db.names.back().move_full();
2174 auto proto = db.names.back().move_full();
2175 db.names.pop_back();
2176 t = parse_source_name(proto.data() + 9, proto.data() + proto.size(), db);
2177 if (t != proto.data() + 9)
2179 db.names.back() = type + "<" + db.names.back().move_full() + ">";
2183 db.names.push_back(type + " " + proto);
2186 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2193 if (first+1 != last && first[1] == 't')
2195 t = parse_name(first, last, db);
2198 if (db.names.empty())
2200 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2206 t = parse_substitution(first, last, db);
2210 // Parsed a substitution. If the substitution is a
2211 // <template-param> it might be followed by <template-args>.
2212 t = parse_template_args(first, last, db);
2215 if (db.names.size() < 2)
2217 auto template_args = db.names.back().move_full();
2218 db.names.pop_back();
2219 db.names.back().first += template_args;
2220 // Need to create substitution for <template-template-param> <template-args>
2221 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2228 if (first+1 != last)
2234 size_t k0 = db.names.size();
2235 t = parse_type(first+2, last, db);
2236 size_t k1 = db.names.size();
2239 db.subs.emplace_back(db.names.get_allocator());
2240 for (size_t k = k0; k < k1; ++k)
2241 db.subs.back().push_back(db.names[k]);
2249 t = parse_decltype(first, last, db);
2252 if (db.names.empty())
2254 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2260 t = parse_vector_type(first, last, db);
2263 if (db.names.empty())
2265 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2274 // must check for builtin-types before class-enum-types to avoid
2275 // ambiguities with operator-names
2276 t = parse_builtin_type(first, last, db);
2283 t = parse_name(first, last, db);
2286 if (db.names.empty())
2288 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2304 // ::= ad # & (unary)
2311 // ::= cv <type> # (cast)
2312 // ::= da # delete[]
2313 // ::= de # * (unary)
2324 // ::= li <source-name> # operator ""
2332 // ::= mm # -- (postfix in <expression> context)
2335 // ::= ng # - (unary)
2344 // ::= pp # ++ (postfix in <expression> context)
2345 // ::= ps # + (unary)
2352 // ::= v <digit> <source-name> # vendor extended operator
2356 parse_operator_name(const char* first, const char* last, C& db)
2358 if (last - first >= 2)
2366 db.names.push_back("operator&&");
2371 db.names.push_back("operator&");
2375 db.names.push_back("operator&=");
2379 db.names.push_back("operator=");
2388 db.names.push_back("operator()");
2392 db.names.push_back("operator,");
2396 db.names.push_back("operator~");
2401 bool try_to_parse_template_args = db.try_to_parse_template_args;
2402 db.try_to_parse_template_args = false;
2403 const char* t = parse_type(first+2, last, db);
2404 db.try_to_parse_template_args = try_to_parse_template_args;
2407 if (db.names.empty())
2409 db.names.back().first.insert(0, "operator ");
2410 db.parsed_ctor_dtor_cv = true;
2421 db.names.push_back("operator delete[]");
2425 db.names.push_back("operator*");
2429 db.names.push_back("operator delete");
2433 db.names.push_back("operator/");
2437 db.names.push_back("operator/=");
2446 db.names.push_back("operator^");
2450 db.names.push_back("operator^=");
2454 db.names.push_back("operator==");
2463 db.names.push_back("operator>=");
2467 db.names.push_back("operator>");
2473 if (first[1] == 'x')
2475 db.names.push_back("operator[]");
2483 db.names.push_back("operator<=");
2488 const char* t = parse_source_name(first+2, last, db);
2491 if (db.names.empty())
2493 db.names.back().first.insert(0, "operator\"\" ");
2499 db.names.push_back("operator<<");
2503 db.names.push_back("operator<<=");
2507 db.names.push_back("operator<");
2516 db.names.push_back("operator-");
2520 db.names.push_back("operator-=");
2524 db.names.push_back("operator*");
2528 db.names.push_back("operator*=");
2532 db.names.push_back("operator--");
2541 db.names.push_back("operator new[]");
2545 db.names.push_back("operator!=");
2549 db.names.push_back("operator-");
2553 db.names.push_back("operator!");
2557 db.names.push_back("operator new");
2566 db.names.push_back("operator||");
2570 db.names.push_back("operator|");
2574 db.names.push_back("operator|=");
2583 db.names.push_back("operator->*");
2587 db.names.push_back("operator+");
2591 db.names.push_back("operator+=");
2595 db.names.push_back("operator++");
2599 db.names.push_back("operator+");
2603 db.names.push_back("operator->");
2609 if (first[1] == 'u')
2611 db.names.push_back("operator?");
2619 db.names.push_back("operator%");
2623 db.names.push_back("operator%=");
2627 db.names.push_back("operator>>");
2631 db.names.push_back("operator>>=");
2637 if (std::isdigit(first[1]))
2639 const char* t = parse_source_name(first+2, last, db);
2642 if (db.names.empty())
2644 db.names.back().first.insert(0, "operator ");
2656 parse_integer_literal(const char* first, const char* last, const typename C::String& lit, C& db)
2658 const char* t = parse_number(first, last);
2659 if (t != first && t != last && *t == 'E')
2662 db.names.push_back("(" + lit + ")");
2664 db.names.emplace_back();
2667 db.names.back().first += '-';
2670 db.names.back().first.append(first, t);
2671 if (lit.size() <= 3)
2672 db.names.back().first += lit;
2678 // <expr-primary> ::= L <type> <value number> E # integer literal
2679 // ::= L <type> <value float> E # floating literal
2680 // ::= L <string type> E # string literal
2681 // ::= L <nullptr type> E # nullptr literal (i.e., "LDnE")
2682 // ::= L <type> <real-part float> _ <imag-part float> E # complex floating point literal (C 2000)
2683 // ::= L <mangled-name> E # external name
2687 parse_expr_primary(const char* first, const char* last, C& db)
2689 if (last - first >= 4 && *first == 'L')
2695 const char* t = parse_integer_literal(first+2, last, "wchar_t", db);
2701 if (first[3] == 'E')
2706 db.names.push_back("false");
2710 db.names.push_back("true");
2718 const char* t = parse_integer_literal(first+2, last, "char", db);
2725 const char* t = parse_integer_literal(first+2, last, "signed char", db);
2732 const char* t = parse_integer_literal(first+2, last, "unsigned char", db);
2739 const char* t = parse_integer_literal(first+2, last, "short", db);
2746 const char* t = parse_integer_literal(first+2, last, "unsigned short", db);
2753 const char* t = parse_integer_literal(first+2, last, "", db);
2760 const char* t = parse_integer_literal(first+2, last, "u", db);
2767 const char* t = parse_integer_literal(first+2, last, "l", db);
2774 const char* t = parse_integer_literal(first+2, last, "ul", db);
2781 const char* t = parse_integer_literal(first+2, last, "ll", db);
2788 const char* t = parse_integer_literal(first+2, last, "ull", db);
2795 const char* t = parse_integer_literal(first+2, last, "__int128", db);
2802 const char* t = parse_integer_literal(first+2, last, "unsigned __int128", db);
2809 const char* t = parse_floating_number<float>(first+2, last, db);
2816 const char* t = parse_floating_number<double>(first+2, last, db);
2823 const char* t = parse_floating_number<long double>(first+2, last, db);
2829 if (first[2] == 'Z')
2831 const char* t = parse_encoding(first+3, last, db);
2832 if (t != first+3 && t != last && *t == 'E')
2837 // Invalid mangled name per
2838 // http://sourcerytools.com/pipermail/cxx-abi-dev/2011-August/002422.html
2842 // might be named type
2843 const char* t = parse_type(first+1, last, db);
2844 if (t != first+1 && t != last)
2849 for (; n != last && isdigit(*n); ++n)
2851 if (n != t && n != last && *n == 'E')
2853 if (db.names.empty())
2855 db.names.back() = "(" + db.names.back().move_full() + ")" + typename C::String(t, n);
2872 template <class String>
2874 base_name(String& s)
2878 if (s == "std::string")
2880 s = "std::basic_string<char, std::char_traits<char>, std::allocator<char> >";
2881 return "basic_string";
2883 if (s == "std::istream")
2885 s = "std::basic_istream<char, std::char_traits<char> >";
2886 return "basic_istream";
2888 if (s == "std::ostream")
2890 s = "std::basic_ostream<char, std::char_traits<char> >";
2891 return "basic_ostream";
2893 if (s == "std::iostream")
2895 s = "std::basic_iostream<char, std::char_traits<char> >";
2896 return "basic_iostream";
2898 const char* const pf = s.data();
2899 const char* pe = pf + s.size();
2915 else if (pe[-1] == '>')
2919 const char* p0 = pe - 1;
2920 for (; p0 != pf; --p0)
2928 return String(p0, pe);
2931 // <ctor-dtor-name> ::= C1 # complete object constructor
2932 // ::= C2 # base object constructor
2933 // ::= C3 # complete object allocating constructor
2934 // extension ::= C5 # ?
2935 // ::= D0 # deleting destructor
2936 // ::= D1 # complete object destructor
2937 // ::= D2 # base object destructor
2938 // extension ::= D5 # ?
2942 parse_ctor_dtor_name(const char* first, const char* last, C& db)
2944 if (last-first >= 2 && !db.names.empty())
2955 if (db.names.empty())
2957 db.names.push_back(base_name(db.names.back().first));
2959 db.parsed_ctor_dtor_cv = true;
2970 if (db.names.empty())
2972 db.names.push_back("~" + base_name(db.names.back().first));
2974 db.parsed_ctor_dtor_cv = true;
2983 // <unnamed-type-name> ::= Ut [ <nonnegative number> ] _
2984 // ::= <closure-type-name>
2986 // <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
2988 // <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters
2992 parse_unnamed_type_name(const char* first, const char* last, C& db)
2994 if (last - first > 2 && first[0] == 'U')
2996 char type = first[1];
3001 db.names.push_back(typename C::String("'unnamed"));
3002 const char* t0 = first+2;
3005 db.names.pop_back();
3008 if (std::isdigit(*t0))
3010 const char* t1 = t0 + 1;
3011 while (t1 != last && std::isdigit(*t1))
3013 db.names.back().first.append(t0, t1);
3016 db.names.back().first.push_back('\'');
3017 if (t0 == last || *t0 != '_')
3019 db.names.pop_back();
3027 db.names.push_back(typename C::String("'lambda'("));
3028 const char* t0 = first+2;
3029 if (first[2] == 'v')
3031 db.names.back().first += ')';
3036 const char* t1 = parse_type(t0, last, db);
3039 db.names.pop_back();
3042 if (db.names.size() < 2)
3044 auto tmp = db.names.back().move_full();
3045 db.names.pop_back();
3046 db.names.back().first.append(tmp);
3050 t1 = parse_type(t0, last, db);
3053 if (db.names.size() < 2)
3055 tmp = db.names.back().move_full();
3056 db.names.pop_back();
3059 db.names.back().first.append(", ");
3060 db.names.back().first.append(tmp);
3064 db.names.back().first.append(")");
3066 if (t0 == last || *t0 != 'E')
3068 db.names.pop_back();
3074 db.names.pop_back();
3077 if (std::isdigit(*t0))
3079 const char* t1 = t0 + 1;
3080 while (t1 != last && std::isdigit(*t1))
3082 db.names.back().first.insert(db.names.back().first.begin()+7, t0, t1);
3085 if (t0 == last || *t0 != '_')
3087 db.names.pop_back();
3098 // <unqualified-name> ::= <operator-name>
3099 // ::= <ctor-dtor-name>
3100 // ::= <source-name>
3101 // ::= <unnamed-type-name>
3105 parse_unqualified_name(const char* first, const char* last, C& db)
3114 t = parse_ctor_dtor_name(first, last, db);
3119 t = parse_unnamed_type_name(first, last, db);
3132 t = parse_source_name(first, last, db);
3137 t = parse_operator_name(first, last, db);
3146 // <unscoped-name> ::= <unqualified-name>
3147 // ::= St <unqualified-name> # ::std::
3148 // extension ::= StL<unqualified-name>
3152 parse_unscoped_name(const char* first, const char* last, C& db)
3154 if (last - first >= 2)
3156 const char* t0 = first;
3158 if (first[0] == 'S' && first[1] == 't')
3162 if (t0 != last && *t0 == 'L')
3165 const char* t1 = parse_unqualified_name(t0, last, db);
3170 if (db.names.empty())
3172 db.names.back().first.insert(0, "std::");
3180 // at <type> # alignof (a type)
3184 parse_alignof_type(const char* first, const char* last, C& db)
3186 if (last - first >= 3 && first[0] == 'a' && first[1] == 't')
3188 const char* t = parse_type(first+2, last, db);
3191 if (db.names.empty())
3193 db.names.back().first = "alignof (" + db.names.back().move_full() + ")";
3200 // az <expression> # alignof (a expression)
3204 parse_alignof_expr(const char* first, const char* last, C& db)
3206 if (last - first >= 3 && first[0] == 'a' && first[1] == 'z')
3208 const char* t = parse_expression(first+2, last, db);
3211 if (db.names.empty())
3213 db.names.back().first = "alignof (" + db.names.back().move_full() + ")";
3222 parse_noexcept_expression(const char* first, const char* last, C& db)
3224 const char* t1 = parse_expression(first, last, db);
3227 if (db.names.empty())
3229 db.names.back().first = "noexcept (" + db.names.back().move_full() + ")";
3237 parse_prefix_expression(const char* first, const char* last, const typename C::String& op, C& db)
3239 const char* t1 = parse_expression(first, last, db);
3242 if (db.names.empty())
3244 db.names.back().first = op + "(" + db.names.back().move_full() + ")";
3252 parse_binary_expression(const char* first, const char* last, const typename C::String& op, C& db)
3254 const char* t1 = parse_expression(first, last, db);
3257 const char* t2 = parse_expression(t1, last, db);
3260 if (db.names.size() < 2)
3262 auto op2 = db.names.back().move_full();
3263 db.names.pop_back();
3264 auto op1 = db.names.back().move_full();
3265 auto& nm = db.names.back().first;
3269 nm += "(" + op1 + ") " + op + " (" + op2 + ")";
3275 db.names.pop_back();
3280 // <expression> ::= <unary operator-name> <expression>
3281 // ::= <binary operator-name> <expression> <expression>
3282 // ::= <ternary operator-name> <expression> <expression> <expression>
3283 // ::= cl <expression>+ E # call
3284 // ::= cv <type> <expression> # conversion with one argument
3285 // ::= cv <type> _ <expression>* E # conversion with a different number of arguments
3286 // ::= [gs] nw <expression>* _ <type> E # new (expr-list) type
3287 // ::= [gs] nw <expression>* _ <type> <initializer> # new (expr-list) type (init)
3288 // ::= [gs] na <expression>* _ <type> E # new[] (expr-list) type
3289 // ::= [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type (init)
3290 // ::= [gs] dl <expression> # delete expression
3291 // ::= [gs] da <expression> # delete[] expression
3292 // ::= pp_ <expression> # prefix ++
3293 // ::= mm_ <expression> # prefix --
3294 // ::= ti <type> # typeid (type)
3295 // ::= te <expression> # typeid (expression)
3296 // ::= dc <type> <expression> # dynamic_cast<type> (expression)
3297 // ::= sc <type> <expression> # static_cast<type> (expression)
3298 // ::= cc <type> <expression> # const_cast<type> (expression)
3299 // ::= rc <type> <expression> # reinterpret_cast<type> (expression)
3300 // ::= st <type> # sizeof (a type)
3301 // ::= sz <expression> # sizeof (an expression)
3302 // ::= at <type> # alignof (a type)
3303 // ::= az <expression> # alignof (an expression)
3304 // ::= nx <expression> # noexcept (expression)
3305 // ::= <template-param>
3306 // ::= <function-param>
3307 // ::= dt <expression> <unresolved-name> # expr.name
3308 // ::= pt <expression> <unresolved-name> # expr->name
3309 // ::= ds <expression> <expression> # expr.*expr
3310 // ::= sZ <template-param> # size of a parameter pack
3311 // ::= sZ <function-param> # size of a function parameter pack
3312 // ::= sp <expression> # pack expansion
3313 // ::= tw <expression> # throw expression
3314 // ::= tr # throw with no operand (rethrow)
3315 // ::= <unresolved-name> # f(p), N::f(p), ::f(p),
3316 // # freestanding dependent name (e.g., T::x),
3317 // # objectless nonstatic member reference
3318 // ::= <expr-primary>
3322 parse_expression(const char* first, const char* last, C& db)
3324 if (last - first >= 2)
3326 const char* t = first;
3327 bool parsed_gs = false;
3328 if (last - first >= 4 && t[0] == 'g' && t[1] == 's')
3336 first = parse_expr_primary(first, last, db);
3339 first = parse_template_param(first, last, db);
3342 first = parse_function_param(first, last, db);
3348 t = parse_binary_expression(first+2, last, "&&", db);
3353 t = parse_prefix_expression(first+2, last, "&", db);
3358 t = parse_binary_expression(first+2, last, "&", db);
3363 t = parse_binary_expression(first+2, last, "&=", db);
3368 t = parse_binary_expression(first+2, last, "=", db);
3373 first = parse_alignof_type(first, last, db);
3376 first = parse_alignof_expr(first, last, db);
3384 first = parse_const_cast_expr(first, last, db);
3387 first = parse_call_expr(first, last, db);
3390 t = parse_binary_expression(first+2, last, ",", db);
3395 t = parse_prefix_expression(first+2, last, "~", db);
3400 first = parse_conversion_expr(first, last, db);
3409 const char* t1 = parse_expression(t+2, last, db);
3412 if (db.names.empty())
3414 db.names.back().first = (parsed_gs ? typename C::String("::") : typename C::String()) +
3415 "delete[] " + db.names.back().move_full();
3421 first = parse_dynamic_cast_expr(first, last, db);
3424 t = parse_prefix_expression(first+2, last, "*", db);
3430 const char* t1 = parse_expression(t+2, last, db);
3433 if (db.names.empty())
3435 db.names.back().first = (parsed_gs ? typename C::String("::") : typename C::String()) +
3436 "delete " + db.names.back().move_full();
3442 return parse_unresolved_name(first, last, db);
3444 first = parse_dot_star_expr(first, last, db);
3447 first = parse_dot_expr(first, last, db);
3450 t = parse_binary_expression(first+2, last, "/", db);
3455 t = parse_binary_expression(first+2, last, "/=", db);
3465 t = parse_binary_expression(first+2, last, "^", db);
3470 t = parse_binary_expression(first+2, last, "^=", db);
3475 t = parse_binary_expression(first+2, last, "==", db);
3485 t = parse_binary_expression(first+2, last, ">=", db);
3490 t = parse_binary_expression(first+2, last, ">", db);
3499 const char* t1 = parse_expression(first+2, last, db);
3502 const char* t2 = parse_expression(t1, last, db);
3505 if (db.names.size() < 2)
3507 auto op2 = db.names.back().move_full();
3508 db.names.pop_back();
3509 auto op1 = db.names.back().move_full();
3510 db.names.back() = "(" + op1 + ")[" + op2 + "]";
3514 db.names.pop_back();
3522 t = parse_binary_expression(first+2, last, "<=", db);
3527 t = parse_binary_expression(first+2, last, "<<", db);
3532 t = parse_binary_expression(first+2, last, "<<=", db);
3537 t = parse_binary_expression(first+2, last, "<", db);
3547 t = parse_binary_expression(first+2, last, "-", db);
3552 t = parse_binary_expression(first+2, last, "-=", db);
3557 t = parse_binary_expression(first+2, last, "*", db);
3562 t = parse_binary_expression(first+2, last, "*=", db);
3567 if (first+2 != last && first[2] == '_')
3569 t = parse_prefix_expression(first+3, last, "--", db);
3575 const char* t1 = parse_expression(first+2, last, db);
3578 if (db.names.empty())
3580 db.names.back() = "(" + db.names.back().move_full() + ")--";
3592 first = parse_new_expr(first, last, db);
3595 t = parse_binary_expression(first+2, last, "!=", db);
3600 t = parse_prefix_expression(first+2, last, "-", db);
3605 t = parse_prefix_expression(first+2, last, "!", db);
3610 t = parse_noexcept_expression(first+2, last, db);
3620 return parse_unresolved_name(first, last, db);
3622 t = parse_binary_expression(first+2, last, "||", db);
3627 t = parse_binary_expression(first+2, last, "|", db);
3632 t = parse_binary_expression(first+2, last, "|=", db);
3642 t = parse_binary_expression(first+2, last, "->*", db);
3647 t = parse_binary_expression(first+2, last, "+", db);
3652 t = parse_binary_expression(first+2, last, "+=", db);
3657 if (first+2 != last && first[2] == '_')
3659 t = parse_prefix_expression(first+3, last, "++", db);
3665 const char* t1 = parse_expression(first+2, last, db);
3668 if (db.names.empty())
3670 db.names.back() = "(" + db.names.back().move_full() + ")++";
3676 t = parse_prefix_expression(first+2, last, "+", db);
3681 first = parse_arrow_expr(first, last, db);
3688 const char* t1 = parse_expression(first+2, last, db);
3691 const char* t2 = parse_expression(t1, last, db);
3694 const char* t3 = parse_expression(t2, last, db);
3697 if (db.names.size() < 3)
3699 auto op3 = db.names.back().move_full();
3700 db.names.pop_back();
3701 auto op2 = db.names.back().move_full();
3702 db.names.pop_back();
3703 auto op1 = db.names.back().move_full();
3704 db.names.back() = "(" + op1 + ") ? (" + op2 + ") : (" + op3 + ")";
3709 db.names.pop_back();
3710 db.names.pop_back();
3714 db.names.pop_back();
3722 first = parse_reinterpret_cast_expr(first, last, db);
3725 t = parse_binary_expression(first+2, last, "%", db);
3730 t = parse_binary_expression(first+2, last, "%=", db);
3735 t = parse_binary_expression(first+2, last, ">>", db);
3740 t = parse_binary_expression(first+2, last, ">>=", db);
3750 first = parse_static_cast_expr(first, last, db);
3753 first = parse_pack_expansion(first, last, db);
3756 return parse_unresolved_name(first, last, db);
3758 first = parse_sizeof_type_expr(first, last, db);
3761 first = parse_sizeof_expr_expr(first, last, db);
3769 first = parse_sizeof_param_pack_expr(first, last, db);
3772 first = parse_sizeof_function_param_pack_expr(first, last, db);
3784 first = parse_typeid_expr(first, last, db);
3787 db.names.push_back("throw");
3791 first = parse_throw_expr(first, last, db);
3804 return parse_unresolved_name(first, last, db);
3810 // <template-arg> ::= <type> # type or template
3811 // ::= X <expression> E # expression
3812 // ::= <expr-primary> # simple expressions
3813 // ::= J <template-arg>* E # argument pack
3814 // ::= LZ <encoding> E # extension
3818 parse_template_arg(const char* first, const char* last, C& db)
3826 t = parse_expression(first+1, last, db);
3829 if (t != last && *t == 'E')
3839 const char* t1 = parse_template_arg(t, last, db);
3847 // <expr-primary> or LZ <encoding> E
3848 if (first+1 != last && first[1] == 'Z')
3850 t = parse_encoding(first+2, last, db);
3851 if (t != first+2 && t != last && *t == 'E')
3855 first = parse_expr_primary(first, last, db);
3859 first = parse_type(first, last, db);
3866 // <template-args> ::= I <template-arg>* E
3867 // extension, the abi says <template-arg>+
3871 parse_template_args(const char* first, const char* last, C& db)
3873 if (last - first >= 2 && *first == 'I')
3875 if (db.tag_templates)
3876 db.template_param.back().clear();
3877 const char* t = first+1;
3878 typename C::String args("<");
3881 if (db.tag_templates)
3882 db.template_param.emplace_back(db.names.get_allocator());
3883 size_t k0 = db.names.size();
3884 const char* t1 = parse_template_arg(t, last, db);
3885 size_t k1 = db.names.size();
3886 if (db.tag_templates)
3887 db.template_param.pop_back();
3888 if (t1 == t || t1 == last)
3890 if (db.tag_templates)
3892 db.template_param.back().emplace_back(db.names.get_allocator());
3893 for (size_t k = k0; k < k1; ++k)
3894 db.template_param.back().back().push_back(db.names[k]);
3896 for (size_t k = k0; k < k1; ++k)
3898 if (args.size() > 1)
3900 args += db.names[k].move_full();
3902 for (; k1 != k0; --k1)
3903 db.names.pop_back();
3907 if (args.back() != '>')
3911 db.names.push_back(std::move(args));
3917 // <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
3918 // ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
3920 // <prefix> ::= <prefix> <unqualified-name>
3921 // ::= <template-prefix> <template-args>
3922 // ::= <template-param>
3925 // ::= <substitution>
3926 // ::= <prefix> <data-member-prefix>
3929 // <template-prefix> ::= <prefix> <template unqualified-name>
3930 // ::= <template-param>
3931 // ::= <substitution>
3935 parse_nested_name(const char* first, const char* last, C& db)
3937 if (first != last && *first == 'N')
3940 const char* t0 = parse_cv_qualifiers(first+1, last, cv);
3949 else if (*t0 == 'O')
3954 db.names.emplace_back();
3955 if (last - t0 >= 2 && t0[0] == 'S' && t0[1] == 't')
3958 db.names.back().first = "std";
3962 db.names.pop_back();
3965 bool pop_subs = false;
3972 if (t0 + 1 != last && t0[1] == 't')
3973 goto do_parse_unqualified_name;
3974 t1 = parse_substitution(t0, last, db);
3975 if (t1 != t0 && t1 != last)
3977 auto name = db.names.back().move_full();
3978 db.names.pop_back();
3979 if (!db.names.back().first.empty())
3981 db.names.back().first += "::" + name;
3982 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
3985 db.names.back().first = name;
3993 t1 = parse_template_param(t0, last, db);
3994 if (t1 != t0 && t1 != last)
3996 auto name = db.names.back().move_full();
3997 db.names.pop_back();
3998 if (!db.names.back().first.empty())
3999 db.names.back().first += "::" + name;
4001 db.names.back().first = name;
4002 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
4010 if (t0 + 1 != last && t0[1] != 't' && t0[1] != 'T')
4011 goto do_parse_unqualified_name;
4012 t1 = parse_decltype(t0, last, db);
4013 if (t1 != t0 && t1 != last)
4015 auto name = db.names.back().move_full();
4016 db.names.pop_back();
4017 if (!db.names.back().first.empty())
4018 db.names.back().first += "::" + name;
4020 db.names.back().first = name;
4021 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
4029 t1 = parse_template_args(t0, last, db);
4030 if (t1 != t0 && t1 != last)
4032 auto name = db.names.back().move_full();
4033 db.names.pop_back();
4034 db.names.back().first += name;
4035 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
4046 do_parse_unqualified_name:
4047 t1 = parse_unqualified_name(t0, last, db);
4048 if (t1 != t0 && t1 != last)
4050 auto name = db.names.back().move_full();
4051 db.names.pop_back();
4052 if (!db.names.back().first.empty())
4053 db.names.back().first += "::" + name;
4055 db.names.back().first = name;
4056 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
4067 if (pop_subs && !db.subs.empty())
4073 // <discriminator> := _ <non-negative number> # when number < 10
4074 // := __ <non-negative number> _ # when number >= 10
4075 // extension := decimal-digit+
4078 parse_discriminator(const char* first, const char* last)
4080 // parse but ignore discriminator
4085 const char* t1 = first+1;
4088 if (std::isdigit(*t1))
4090 else if (*t1 == '_')
4092 for (++t1; t1 != last && std::isdigit(*t1); ++t1)
4094 if (t1 != last && *t1 == '_')
4099 else if (std::isdigit(*first))
4101 const char* t1 = first+1;
4102 for (; t1 != last && std::isdigit(*t1); ++t1)
4110 // <local-name> := Z <function encoding> E <entity name> [<discriminator>]
4111 // := Z <function encoding> E s [<discriminator>]
4112 // := Z <function encoding> Ed [ <parameter number> ] _ <entity name>
4116 parse_local_name(const char* first, const char* last, C& db)
4118 if (first != last && *first == 'Z')
4120 const char* t = parse_encoding(first+1, last, db);
4121 if (t != first+1 && t != last && *t == 'E' && ++t != last)
4126 first = parse_discriminator(t+1, last);
4127 if (db.names.empty())
4129 db.names.back().first.append("::string literal");
4134 const char* t1 = parse_number(t, last);
4135 if (t1 != last && *t1 == '_')
4138 t1 = parse_name(t, last, db);
4141 if (db.names.size() < 2)
4143 auto name = db.names.back().move_full();
4144 db.names.pop_back();
4145 db.names.back().first.append("::");
4146 db.names.back().first.append(name);
4150 db.names.pop_back();
4156 const char* t1 = parse_name(t, last, db);
4159 // parse but ignore discriminator
4160 first = parse_discriminator(t1, last);
4161 if (db.names.size() < 2)
4163 auto name = db.names.back().move_full();
4164 db.names.pop_back();
4165 db.names.back().first.append("::");
4166 db.names.back().first.append(name);
4169 db.names.pop_back();
4178 // <name> ::= <nested-name> // N
4179 // ::= <local-name> # See Scope Encoding below // Z
4180 // ::= <unscoped-template-name> <template-args>
4181 // ::= <unscoped-name>
4183 // <unscoped-template-name> ::= <unscoped-name>
4184 // ::= <substitution>
4188 parse_name(const char* first, const char* last, C& db)
4190 if (last - first >= 2)
4192 const char* t0 = first;
4193 // extension: ignore L here
4200 const char* t1 = parse_nested_name(t0, last, db);
4207 const char* t1 = parse_local_name(t0, last, db);
4214 const char* t1 = parse_unscoped_name(t0, last, db);
4217 if (t1 != last && *t1 == 'I') // <unscoped-template-name> <template-args>
4219 if (db.names.empty())
4221 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
4223 t1 = parse_template_args(t0, last, db);
4226 if (db.names.size() < 2)
4228 auto tmp = db.names.back().move_full();
4229 db.names.pop_back();
4230 db.names.back().first += tmp;
4234 else // <unscoped-name>
4238 { // try <substitution> <template-args>
4239 t1 = parse_substitution(t0, last, db);
4240 if (t1 != t0 && t1 != last && *t1 == 'I')
4243 t1 = parse_template_args(t0, last, db);
4246 if (db.names.size() < 2)
4248 auto tmp = db.names.back().move_full();
4249 db.names.pop_back();
4250 db.names.back().first += tmp;
4262 // <call-offset> ::= h <nv-offset> _
4263 // ::= v <v-offset> _
4265 // <nv-offset> ::= <offset number>
4266 // # non-virtual base override
4268 // <v-offset> ::= <offset number> _ <virtual offset number>
4269 // # virtual base override, with vcall offset
4272 parse_call_offset(const char* first, const char* last)
4280 const char* t = parse_number(first + 1, last);
4281 if (t != first + 1 && t != last && *t == '_')
4287 const char* t = parse_number(first + 1, last);
4288 if (t != first + 1 && t != last && *t == '_')
4290 const char* t2 = parse_number(++t, last);
4291 if (t2 != t && t2 != last && *t2 == '_')
4301 // <special-name> ::= TV <type> # virtual table
4302 // ::= TT <type> # VTT structure (construction vtable index)
4303 // ::= TI <type> # typeinfo structure
4304 // ::= TS <type> # typeinfo name (null-terminated byte string)
4305 // ::= Tc <call-offset> <call-offset> <base encoding>
4306 // # base is the nominal target function of thunk
4307 // # first call-offset is 'this' adjustment
4308 // # second call-offset is result adjustment
4309 // ::= T <call-offset> <base encoding>
4310 // # base is the nominal target function of thunk
4311 // ::= GV <object name> # Guard variable for one-time initialization
4313 // extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first
4314 // extension ::= GR <object name> # reference temporary for object
4318 parse_special_name(const char* first, const char* last, C& db)
4320 if (last - first > 2)
4329 // TV <type> # virtual table
4330 t = parse_type(first+2, last, db);
4333 if (db.names.empty())
4335 db.names.back().first.insert(0, "vtable for ");
4340 // TT <type> # VTT structure (construction vtable index)
4341 t = parse_type(first+2, last, db);
4344 if (db.names.empty())
4346 db.names.back().first.insert(0, "VTT for ");
4351 // TI <type> # typeinfo structure
4352 t = parse_type(first+2, last, db);
4355 if (db.names.empty())
4357 db.names.back().first.insert(0, "typeinfo for ");
4362 // TS <type> # typeinfo name (null-terminated byte string)
4363 t = parse_type(first+2, last, db);
4366 if (db.names.empty())
4368 db.names.back().first.insert(0, "typeinfo name for ");
4373 // Tc <call-offset> <call-offset> <base encoding>
4375 const char* t0 = parse_call_offset(first+2, last);
4378 const char* t1 = parse_call_offset(t0, last);
4381 t = parse_encoding(t1, last, db);
4384 if (db.names.empty())
4386 db.names.back().first.insert(0, "covariant return thunk to ");
4392 // extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first
4393 t = parse_type(first+2, last, db);
4396 const char* t0 = parse_number(t, last);
4397 if (t0 != t && t0 != last && *t0 == '_')
4399 const char* t1 = parse_type(++t0, last, db);
4402 if (db.names.size() < 2)
4404 auto left = db.names.back().move_full();
4405 db.names.pop_back();
4406 db.names.back().first = "construction vtable for " +
4407 std::move(left) + "-in-" +
4408 db.names.back().move_full();
4415 // T <call-offset> <base encoding>
4417 const char* t0 = parse_call_offset(first+1, last);
4420 t = parse_encoding(t0, last, db);
4423 if (db.names.empty())
4425 if (first[1] == 'v')
4427 db.names.back().first.insert(0, "virtual thunk to ");
4432 db.names.back().first.insert(0, "non-virtual thunk to ");
4444 // GV <object name> # Guard variable for one-time initialization
4445 t = parse_name(first+2, last, db);
4448 if (db.names.empty())
4450 db.names.back().first.insert(0, "guard variable for ");
4455 // extension ::= GR <object name> # reference temporary for object
4456 t = parse_name(first+2, last, db);
4459 if (db.names.empty())
4461 db.names.back().first.insert(0, "reference temporary for ");
4478 save_value(T& restore)
4479 : restore_(restore),
4480 original_value_(restore)
4485 restore_ = std::move(original_value_);
4488 save_value(const save_value&) = delete;
4489 save_value& operator=(const save_value&) = delete;
4492 // <encoding> ::= <function name> <bare-function-type>
4494 // ::= <special-name>
4498 parse_encoding(const char* first, const char* last, C& db)
4502 save_value<decltype(db.encoding_depth)> su(db.encoding_depth);
4503 ++db.encoding_depth;
4504 save_value<decltype(db.tag_templates)> sb(db.tag_templates);
4505 if (db.encoding_depth > 1)
4506 db.tag_templates = true;
4511 first = parse_special_name(first, last, db);
4515 const char* t = parse_name(first, last, db);
4516 unsigned cv = db.cv;
4517 unsigned ref = db.ref;
4520 if (t != last && *t != 'E' && *t != '.')
4522 save_value<bool> sb2(db.tag_templates);
4523 db.tag_templates = false;
4525 typename C::String ret2;
4526 if (db.names.empty())
4528 const typename C::String& nm = db.names.back().first;
4531 if (!db.parsed_ctor_dtor_cv && nm.back() == '>' && nm[nm.size()-2] != '-'
4532 && nm[nm.size()-2] != '>')
4534 t2 = parse_type(t, last, db);
4537 if (db.names.size() < 2)
4539 auto ret1 = std::move(db.names.back().first);
4540 ret2 = std::move(db.names.back().second);
4543 db.names.pop_back();
4544 db.names.back().first.insert(0, ret1);
4547 db.names.back().first += '(';
4548 if (t != last && *t == 'v')
4554 bool first_arg = true;
4557 size_t k0 = db.names.size();
4558 t2 = parse_type(t, last, db);
4559 size_t k1 = db.names.size();
4564 typename C::String tmp;
4565 for (size_t k = k0; k < k1; ++k)
4569 tmp += db.names[k].move_full();
4571 for (size_t k = k0; k < k1; ++k)
4572 db.names.pop_back();
4575 if (db.names.empty())
4578 db.names.back().first += ", ";
4581 db.names.back().first += tmp;
4587 if (db.names.empty())
4589 db.names.back().first += ')';
4591 db.names.back().first.append(" const");
4593 db.names.back().first.append(" volatile");
4595 db.names.back().first.append(" restrict");
4597 db.names.back().first.append(" &");
4599 db.names.back().first.append(" &&");
4600 db.names.back().first += ret2;
4614 // _block_invoke<decimal-digit>+
4615 // _block_invoke_<decimal-digit>+
4619 parse_block_invoke(const char* first, const char* last, C& db)
4621 if (last - first >= 13)
4623 const char test[] = "_block_invoke";
4624 const char* t = first;
4625 for (int i = 0; i < 13; ++i, ++t)
4634 // must have at least 1 decimal digit
4635 if (++t == last || !std::isdigit(*t))
4639 // parse zero or more digits
4640 while (t != last && isdigit(*t))
4643 if (db.names.empty())
4645 db.names.back().first.insert(0, "invocation function for block in ");
4652 // <dot-suffix> := .<anything and everything>
4656 parse_dot_suffix(const char* first, const char* last, C& db)
4658 if (first != last && *first == '.')
4660 if (db.names.empty())
4662 db.names.back().first += " (" + typename C::String(first, last) + ")";
4668 // <block-involcaton-function> ___Z<encoding>_block_invoke
4669 // <block-involcaton-function> ___Z<encoding>_block_invoke<decimal-digit>+
4670 // <block-involcaton-function> ___Z<encoding>_block_invoke_<decimal-digit>+
4671 // <mangled-name> ::= _Z<encoding>
4676 demangle(const char* first, const char* last, C& db, int& status)
4680 status = invalid_mangled_name;
4685 if (last - first >= 4)
4687 if (first[1] == 'Z')
4689 const char* t = parse_encoding(first+2, last, db);
4690 if (t != first+2 && t != last && *t == '.')
4691 t = parse_dot_suffix(t, last, db);
4693 status = invalid_mangled_name;
4695 else if (first[1] == '_' && first[2] == '_' && first[3] == 'Z')
4697 const char* t = parse_encoding(first+4, last, db);
4698 if (t != first+4 && t != last)
4700 const char* t1 = parse_block_invoke(t, last, db);
4702 status = invalid_mangled_name;
4705 status = invalid_mangled_name;
4708 status = invalid_mangled_name;
4711 status = invalid_mangled_name;
4715 const char* t = parse_type(first, last, db);
4717 status = invalid_mangled_name;
4719 if (status == success && db.names.empty())
4720 status = invalid_mangled_name;
4723 template <std::size_t N>
4726 static const std::size_t alignment = 16;
4727 alignas(alignment) char buf_[N];
4731 align_up(std::size_t n) noexcept
4732 {return n + (alignment-1) & ~(alignment-1);}
4735 pointer_in_buffer(char* p) noexcept
4736 {return buf_ <= p && p <= buf_ + N;}
4739 arena() noexcept : ptr_(buf_) {}
4740 ~arena() {ptr_ = nullptr;}
4741 arena(const arena&) = delete;
4742 arena& operator=(const arena&) = delete;
4744 char* allocate(std::size_t n);
4745 void deallocate(char* p, std::size_t n) noexcept;
4747 static constexpr std::size_t size() {return N;}
4748 std::size_t used() const {return static_cast<std::size_t>(ptr_ - buf_);}
4749 void reset() {ptr_ = buf_;}
4752 template <std::size_t N>
4754 arena<N>::allocate(std::size_t n)
4757 if (static_cast<std::size_t>(buf_ + N - ptr_) >= n)
4763 return static_cast<char*>(std::malloc(n));
4766 template <std::size_t N>
4768 arena<N>::deallocate(char* p, std::size_t n) noexcept
4770 if (pointer_in_buffer(p))
4780 template <class T, std::size_t N>
4785 typedef T value_type;
4788 template <class _Up> struct rebind {typedef short_alloc<_Up, N> other;};
4790 short_alloc(arena<N>& a) noexcept : a_(a) {}
4792 short_alloc(const short_alloc<U, N>& a) noexcept
4794 short_alloc(const short_alloc&) = default;
4795 short_alloc& operator=(const short_alloc&) = delete;
4797 T* allocate(std::size_t n)
4799 return reinterpret_cast<T*>(a_.allocate(n*sizeof(T)));
4801 void deallocate(T* p, std::size_t n) noexcept
4803 a_.deallocate(reinterpret_cast<char*>(p), n*sizeof(T));
4806 template <class T1, std::size_t N1, class U, std::size_t M>
4809 operator==(const short_alloc<T1, N1>& x, const short_alloc<U, M>& y) noexcept;
4811 template <class U, std::size_t M> friend class short_alloc;
4814 template <class T, std::size_t N, class U, std::size_t M>
4817 operator==(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept
4819 return N == M && &x.a_ == &y.a_;
4822 template <class T, std::size_t N, class U, std::size_t M>
4825 operator!=(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept
4834 typedef T value_type;
4836 malloc_alloc() = default;
4837 template <class U> malloc_alloc(const malloc_alloc<U>&) noexcept {}
4839 T* allocate(std::size_t n)
4841 return static_cast<T*>(std::malloc(n*sizeof(T)));
4843 void deallocate(T* p, std::size_t) noexcept
4849 template <class T, class U>
4852 operator==(const malloc_alloc<T>&, const malloc_alloc<U>&) noexcept
4857 template <class T, class U>
4860 operator!=(const malloc_alloc<T>& x, const malloc_alloc<U>& y) noexcept
4865 const size_t bs = 4 * 1024;
4866 template <class T> using Alloc = short_alloc<T, bs>;
4867 template <class T> using Vector = std::vector<T, Alloc<T>>;
4868 using String = std::basic_string<char, std::char_traits<char>, malloc_alloc<char>>;
4875 string_pair() = default;
4876 string_pair(String f) : first(std::move(f)) {}
4877 string_pair(String f, String s)
4878 : first(std::move(f)), second(std::move(s)) {}
4880 string_pair(const char (&s)[N]) : first(s, N-1) {}
4882 size_t size() const {return first.size() + second.size();}
4883 String full() const {return first + second;}
4884 String move_full() {return std::move(first) + std::move(second);}
4889 typedef String String;
4890 typedef Vector<string_pair> sub_type;
4891 typedef Vector<sub_type> template_param_type;
4892 Vector<string_pair> names;
4893 Vector<sub_type> subs;
4894 Vector<template_param_type> template_param;
4897 unsigned encoding_depth;
4898 bool parsed_ctor_dtor_cv;
4900 bool fix_forward_references;
4901 bool try_to_parse_template_args;
4907 template_param(0, subs, ar)
4912 __cxa_demangle(const char* mangled_name, char* buf, size_t* n, int* status)
4914 if (mangled_name == nullptr || (buf != nullptr && n == nullptr))
4917 *status = invalid_args;
4920 size_t internal_size = buf != nullptr ? *n : 0;
4925 db.encoding_depth = 0;
4926 db.parsed_ctor_dtor_cv = false;
4927 db.tag_templates = true;
4928 db.template_param.emplace_back(a);
4929 db.fix_forward_references = false;
4930 db.try_to_parse_template_args = true;
4931 int internal_status = success;
4932 size_t len = std::strlen(mangled_name);
4933 demangle(mangled_name, mangled_name + len, db,
4935 if (internal_status == success && db.fix_forward_references &&
4936 !db.template_param.empty() && !db.template_param.front().empty())
4938 db.fix_forward_references = false;
4939 db.tag_templates = false;
4942 demangle(mangled_name, mangled_name + len, db, internal_status);
4943 if (db.fix_forward_references)
4944 internal_status = invalid_mangled_name;
4946 if (internal_status == success)
4948 size_t sz = db.names.back().size() + 1;
4949 if (sz > internal_size)
4951 char* newbuf = static_cast<char*>(std::realloc(buf, sz));
4952 if (newbuf == nullptr)
4954 internal_status = memory_alloc_failure;
4966 db.names.back().first += db.names.back().second;
4967 std::memcpy(buf, db.names.back().first.data(), sz-1);
4968 buf[sz-1] = char(0);
4974 *status = internal_status;
4982 #include "llvm/ADT/DenseMap.h"
4984 #include "lldb/Core/ConstString.h"
4985 #include "lldb/Core/Mangled.h"
4986 #include "lldb/Core/RegularExpression.h"
4987 #include "lldb/Core/Stream.h"
4988 #include "lldb/Core/Timer.h"
4989 #include "lldb/Target/CPPLanguageRuntime.h"
4995 using namespace lldb_private;
4998 cstring_is_mangled (const char *s)
5001 return s[0] == '_' && s[1] == 'Z';
5005 static const ConstString &
5006 get_demangled_name_without_arguments (const Mangled *obj)
5008 // This pair is <mangled name, demangled name without function arguments>
5009 static std::pair<ConstString, ConstString> g_most_recent_mangled_to_name_sans_args;
5011 // Need to have the mangled & demangled names we're currently examining as statics
5012 // so we can return a const ref to them at the end of the func if we don't have
5014 static ConstString g_last_mangled;
5015 static ConstString g_last_demangled;
5017 ConstString mangled = obj->GetMangledName ();
5018 ConstString demangled = obj->GetDemangledName ();
5020 if (mangled && g_most_recent_mangled_to_name_sans_args.first == mangled)
5022 return g_most_recent_mangled_to_name_sans_args.second;
5025 g_last_demangled = demangled;
5026 g_last_mangled = mangled;
5028 const char *mangled_name_cstr = mangled.GetCString();
5030 if (demangled && mangled_name_cstr && mangled_name_cstr[0])
5032 if (mangled_name_cstr[0] == '_' && mangled_name_cstr[1] == 'Z' &&
5033 (mangled_name_cstr[2] != 'T' && // avoid virtual table, VTT structure, typeinfo structure, and typeinfo mangled_name
5034 mangled_name_cstr[2] != 'G' && // avoid guard variables
5035 mangled_name_cstr[2] != 'Z')) // named local entities (if we eventually handle eSymbolTypeData, we will want this back)
5037 CPPLanguageRuntime::MethodName cxx_method (demangled);
5038 if (!cxx_method.GetBasename().empty() && !cxx_method.GetContext().empty())
5040 std::string shortname = cxx_method.GetContext().str();
5042 shortname += cxx_method.GetBasename().str();
5043 ConstString result(shortname.c_str());
5044 g_most_recent_mangled_to_name_sans_args.first = mangled;
5045 g_most_recent_mangled_to_name_sans_args.second = result;
5046 return g_most_recent_mangled_to_name_sans_args.second;
5052 return g_last_demangled;
5053 return g_last_mangled;
5056 #pragma mark Mangled
5057 //----------------------------------------------------------------------
5058 // Default constructor
5059 //----------------------------------------------------------------------
5060 Mangled::Mangled () :
5066 //----------------------------------------------------------------------
5067 // Constructor with an optional string and a boolean indicating if it is
5068 // the mangled version.
5069 //----------------------------------------------------------------------
5070 Mangled::Mangled (const ConstString &s, bool mangled) :
5075 SetValue(s, mangled);
5078 Mangled::Mangled (const ConstString &s) :
5086 //----------------------------------------------------------------------
5088 //----------------------------------------------------------------------
5089 Mangled::~Mangled ()
5093 //----------------------------------------------------------------------
5094 // Convert to pointer operator. This allows code to check any Mangled
5095 // objects to see if they contain anything valid using code such as:
5097 // Mangled mangled(...);
5100 //----------------------------------------------------------------------
5101 Mangled::operator void* () const
5103 return (m_mangled) ? const_cast<Mangled*>(this) : NULL;
5106 //----------------------------------------------------------------------
5107 // Logical NOT operator. This allows code to check any Mangled
5108 // objects to see if they are invalid using code such as:
5110 // Mangled mangled(...);
5113 //----------------------------------------------------------------------
5115 Mangled::operator! () const
5120 //----------------------------------------------------------------------
5121 // Clear the mangled and demangled values.
5122 //----------------------------------------------------------------------
5127 m_demangled.Clear();
5131 //----------------------------------------------------------------------
5132 // Compare the the string values.
5133 //----------------------------------------------------------------------
5135 Mangled::Compare (const Mangled& a, const Mangled& b)
5137 return ConstString::Compare(a.GetName(ePreferMangled), a.GetName(ePreferMangled));
5142 //----------------------------------------------------------------------
5143 // Set the string value in this objects. If "mangled" is true, then
5144 // the mangled named is set with the new value in "s", else the
5145 // demangled name is set.
5146 //----------------------------------------------------------------------
5148 Mangled::SetValue (const ConstString &s, bool mangled)
5154 m_demangled.Clear();
5165 m_demangled.Clear();
5171 Mangled::SetValue (const ConstString &name)
5175 if (cstring_is_mangled(name.GetCString()))
5177 m_demangled.Clear();
5188 m_demangled.Clear();
5193 //----------------------------------------------------------------------
5194 // Generate the demangled name on demand using this accessor. Code in
5195 // this class will need to use this accessor if it wishes to decode
5196 // the demangled name. The result is cached and will be kept until a
5197 // new string value is supplied to this object, or until the end of the
5198 // object's lifetime.
5199 //----------------------------------------------------------------------
5201 Mangled::GetDemangledName () const
5203 // Check to make sure we have a valid mangled name and that we
5204 // haven't already decoded our mangled name.
5205 if (m_mangled && !m_demangled)
5207 // We need to generate and cache the demangled name.
5208 Timer scoped_timer (__PRETTY_FUNCTION__,
5209 "Mangled::GetDemangledName (m_mangled = %s)",
5210 m_mangled.GetCString());
5212 // Don't bother running anything that isn't mangled
5213 const char *mangled_cstr = m_mangled.GetCString();
5214 if (cstring_is_mangled(mangled_cstr))
5216 if (!m_mangled.GetMangledCounterpart(m_demangled))
5218 // We didn't already mangle this name, demangle it and if all goes well
5219 // add it to our map.
5220 #ifdef LLDB_USE_BUILTIN_DEMANGLER
5221 // Try to use the fast-path demangler first for the
5222 // performance win, falling back to the full demangler only
5224 char *demangled_name = FastDemangle (mangled_cstr,
5225 m_mangled.GetLength());
5226 if (!demangled_name)
5227 demangled_name = __cxa_demangle (mangled_cstr, NULL, NULL, NULL);
5228 #elif defined(_MSC_VER)
5229 // Cannot demangle on msvc.
5230 char *demangled_name = nullptr;
5232 char *demangled_name = abi::__cxa_demangle (mangled_cstr, NULL, NULL, NULL);
5237 m_demangled.SetCStringWithMangledCounterpart(demangled_name, m_mangled);
5238 free (demangled_name);
5244 // Set the demangled string to the empty string to indicate we
5245 // tried to parse it once and failed.
5246 m_demangled.SetCString("");
5255 Mangled::NameMatches (const RegularExpression& regex) const
5257 if (m_mangled && regex.Execute (m_mangled.AsCString()))
5260 if (GetDemangledName() && regex.Execute (m_demangled.AsCString()))
5265 //----------------------------------------------------------------------
5266 // Get the demangled name if there is one, else return the mangled name.
5267 //----------------------------------------------------------------------
5269 Mangled::GetName (Mangled::NamePreference preference) const
5271 if (preference == ePreferDemangledWithoutArguments)
5273 // Call the accessor to make sure we get a demangled name in case
5274 // it hasn't been demangled yet...
5277 return get_demangled_name_without_arguments (this);
5279 if (preference == ePreferDemangled)
5281 // Call the accessor to make sure we get a demangled name in case
5282 // it hasn't been demangled yet...
5283 if (GetDemangledName())
5291 return GetDemangledName();
5295 //----------------------------------------------------------------------
5296 // Dump a Mangled object to stream "s". We don't force our
5297 // demangled name to be computed currently (we don't use the accessor).
5298 //----------------------------------------------------------------------
5300 Mangled::Dump (Stream *s) const
5304 *s << ", mangled = " << m_mangled;
5308 const char * demangled = m_demangled.AsCString();
5309 s->Printf(", demangled = %s", demangled[0] ? demangled : "<error>");
5313 //----------------------------------------------------------------------
5314 // Dumps a debug version of this string with extra object and state
5315 // information to stream "s".
5316 //----------------------------------------------------------------------
5318 Mangled::DumpDebug (Stream *s) const
5320 s->Printf("%*p: Mangled mangled = ", static_cast<int>(sizeof(void*) * 2),
5321 static_cast<const void*>(this));
5322 m_mangled.DumpDebug(s);
5323 s->Printf(", demangled = ");
5324 m_demangled.DumpDebug(s);
5327 //----------------------------------------------------------------------
5328 // Return the size in byte that this object takes in memory. The size
5329 // includes the size of the objects it owns, and not the strings that
5330 // it references because they are shared strings.
5331 //----------------------------------------------------------------------
5333 Mangled::MemorySize () const
5335 return m_mangled.MemorySize() + m_demangled.MemorySize();
5338 //----------------------------------------------------------------------
5339 // Dump OBJ to the supplied stream S.
5340 //----------------------------------------------------------------------
5342 operator << (Stream& s, const Mangled& obj)
5344 if (obj.GetMangledName())
5345 s << "mangled = '" << obj.GetMangledName() << "'";
5347 const ConstString& demangled = obj.GetDemangledName();
5349 s << ", demangled = '" << demangled << '\'';
5351 s << ", demangled = <error>";