Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / ac501f02507802d6b0e9644c78814fc48555cb9c / . / lldb / source / Core / Mangled.cpp
blob: 8e2479df353638a6c3dddd98c9ac549ee02d671a [file] [log] [blame]
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]1//===-- Mangled.cpp ---------------------------------------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
Greg Claytone9982672012-08-06 15:55:38 +0000[diff] [blame]10
Filipe Cabecinhasdd393952012-09-11 18:11:12 +0000[diff] [blame]11// FreeBSD9-STABLE requires this to know about size_t in cxxabi.h
12#include <cstddef>
Greg Clayton19c8e782013-10-30 18:42:59 +0000[diff] [blame]13#ifdef _MSC_VER
14#define LLDB_USE_BUILTIN_DEMANGLER
15#else
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]16#include <cxxabi.h>
Virgile Bellod0c5c772013-09-18 08:09:31 +0000[diff] [blame]17#endif
Greg Claytone9982672012-08-06 15:55:38 +0000[diff] [blame]18
Greg Clayton19c8e782013-10-30 18:42:59 +0000[diff] [blame]19#ifdef LLDB_USE_BUILTIN_DEMANGLER
20
21#include <vector>
22#include <algorithm>
23#include <string>
24#include <numeric>
25#include <cstdlib>
26#include <cstring>
27#include <cctype>
28
29// Inlined copy of http://llvm.org/svn/llvm-project/libcxxabi/trunk/src/cxa_demangle.cpp
30// with "__cxxabiv1" namespace removed, stripped attributes and extern "C" attributes.
31// Also changed the unnamed namespace to include cxa_demangle function.
32
33namespace
34{
35
36enum
37{
38 unknown_error = -4,
39 invalid_args = -3,
40 invalid_mangled_name,
41 memory_alloc_failure,
42 success
43};
44
45template <class C>
46 const char* parse_type(const char* first, const char* last, C& db);
47template <class C>
48 const char* parse_encoding(const char* first, const char* last, C& db);
49template <class C>
50 const char* parse_name(const char* first, const char* last, C& db);
51template <class C>
52 const char* parse_expression(const char* first, const char* last, C& db);
53template <class C>
54 const char* parse_template_args(const char* first, const char* last, C& db);
55template <class C>
56 const char* parse_operator_name(const char* first, const char* last, C& db);
57template <class C>
58 const char* parse_unqualified_name(const char* first, const char* last, C& db);
59template <class C>
60 const char* parse_decltype(const char* first, const char* last, C& db);
61
62template <class C>
63void
64print_stack(const C& db)
65{
66 printf("---------\n");
67 printf("names:\n");
68 for (auto& s : db.names)
69 printf("{%s#%s}\n", s.first.c_str(), s.second.c_str());
70 int i = -1;
71 printf("subs:\n");
72 for (auto& v : db.subs)
73 {
74 if (i >= 0)
75 printf("S%i_ = {", i);
76 else
77 printf("S_ = {");
78 for (auto& s : v)
79 printf("{%s#%s}", s.first.c_str(), s.second.c_str());
80 printf("}\n");
81 ++i;
82 }
83 printf("template_param:\n");
84 for (auto& t : db.template_param)
85 {
86 printf("--\n");
87 i = -1;
88 for (auto& v : t)
89 {
90 if (i >= 0)
91 printf("T%i_ = {", i);
92 else
93 printf("T_ = {");
94 for (auto& s : v)
95 printf("{%s#%s}", s.first.c_str(), s.second.c_str());
96 printf("}\n");
97 ++i;
98 }
99 }
100 printf("---------\n\n");
101}
102
103template <class C>
104void
105print_state(const char* msg, const char* first, const char* last, const C& db)
106{
107 printf("%s: ", msg);
108 for (; first != last; ++first)
109 printf("%c", *first);
110 printf("\n");
111 print_stack(db);
112}
113
114// <number> ::= [n] <non-negative decimal integer>
115
116const char*
117parse_number(const char* first, const char* last)
118{
119 if (first != last)
120 {
121 const char* t = first;
122 if (*t == 'n')
123 ++t;
124 if (t != last)
125 {
126 if (*t == '0')
127 {
128 first = t+1;
129 }
130 else if ('1' <= *t && *t <= '9')
131 {
132 first = t+1;
133 while (first != last && std::isdigit(*first))
134 ++first;
135 }
136 }
137 }
138 return first;
139}
140
141template <class Float>
142struct float_data;
143
144template <>
145struct float_data<float>
146{
147 static const size_t mangled_size = 8;
148 static const size_t max_demangled_size = 24;
149 static constexpr const char* spec = "%af";
150};
151
152constexpr const char* float_data<float>::spec;
153
154template <>
155struct float_data<double>
156{
157 static const size_t mangled_size = 16;
158 static const size_t max_demangled_size = 32;
159 static constexpr const char* spec = "%a";
160};
161
162constexpr const char* float_data<double>::spec;
163
164template <>
165struct float_data<long double>
166{
167 static const size_t mangled_size = 20; // May need to be adjusted to 16 or 24 on other platforms
168 static const size_t max_demangled_size = 40;
169 static constexpr const char* spec = "%LaL";
170};
171
172constexpr const char* float_data<long double>::spec;
173
174template <class Float, class C>
175const char*
176parse_floating_number(const char* first, const char* last, C& db)
177{
178 const size_t N = float_data<Float>::mangled_size;
179 if (static_cast<std::size_t>(last - first) > N)
180 {
181 last = first + N;
182 union
183 {
184 Float value;
185 char buf[sizeof(Float)];
186 };
187 const char* t = first;
188 char* e = buf;
189 for (; t != last; ++t, ++e)
190 {
191 if (!isxdigit(*t))
192 return first;
193 unsigned d1 = isdigit(*t) ? static_cast<unsigned>(*t - '0') :
194 static_cast<unsigned>(*t - 'a' + 10);
195 ++t;
196 unsigned d0 = isdigit(*t) ? static_cast<unsigned>(*t - '0') :
197 static_cast<unsigned>(*t - 'a' + 10);
198 *e = static_cast<char>((d1 << 4) + d0);
199 }
200 if (*t == 'E')
201 {
202#if __LITTLE_ENDIAN__
203 std::reverse(buf, e);
204#endif
205 char num[float_data<Float>::max_demangled_size] = {0};
206 int n = snprintf(num, sizeof(num), float_data<Float>::spec, value);
207 if (static_cast<std::size_t>(n) >= sizeof(num))
208 return first;
209 db.names.push_back(typename C::String(num, static_cast<std::size_t>(n)));
210 first = t+1;
211 }
212 }
213 return first;
214}
215
216// <source-name> ::= <positive length number> <identifier>
217
218template <class C>
219const char*
220parse_source_name(const char* first, const char* last, C& db)
221{
222 if (first != last)
223 {
224 char c = *first;
225 if (isdigit(c) && first+1 != last)
226 {
227 const char* t = first+1;
228 size_t n = static_cast<size_t>(c - '0');
229 for (c = *t; isdigit(c); c = *t)
230 {
231 n = n * 10 + static_cast<size_t>(c - '0');
232 if (++t == last)
233 return first;
234 }
235 if (static_cast<size_t>(last - t) >= n)
236 {
237 typename C::String r(t, n);
238 if (r.substr(0, 10) == "_GLOBAL__N")
239 db.names.push_back("(anonymous namespace)");
240 else
241 db.names.push_back(std::move(r));
242 first = t + n;
243 }
244 }
245 }
246 return first;
247}
248
249// <substitution> ::= S <seq-id> _
250// ::= S_
251// <substitution> ::= Sa # ::std::allocator
252// <substitution> ::= Sb # ::std::basic_string
253// <substitution> ::= Ss # ::std::basic_string < char,
254// ::std::char_traits<char>,
255// ::std::allocator<char> >
256// <substitution> ::= Si # ::std::basic_istream<char, std::char_traits<char> >
257// <substitution> ::= So # ::std::basic_ostream<char, std::char_traits<char> >
258// <substitution> ::= Sd # ::std::basic_iostream<char, std::char_traits<char> >
259
260template <class C>
261const char*
262parse_substitution(const char* first, const char* last, C& db)
263{
264 if (last - first >= 2)
265 {
266 if (*first == 'S')
267 {
268 switch (first[1])
269 {
270 case 'a':
271 db.names.push_back("std::allocator");
272 first += 2;
273 break;
274 case 'b':
275 db.names.push_back("std::basic_string");
276 first += 2;
277 break;
278 case 's':
279 db.names.push_back("std::string");
280 first += 2;
281 break;
282 case 'i':
283 db.names.push_back("std::istream");
284 first += 2;
285 break;
286 case 'o':
287 db.names.push_back("std::ostream");
288 first += 2;
289 break;
290 case 'd':
291 db.names.push_back("std::iostream");
292 first += 2;
293 break;
294 case '_':
295 if (!db.subs.empty())
296 {
297 for (const auto& n : db.subs.front())
298 db.names.push_back(n);
299 first += 2;
300 }
301 break;
302 default:
303 if (std::isdigit(first[1]) || std::isupper(first[1]))
304 {
305 size_t sub = 0;
306 const char* t = first+1;
307 if (std::isdigit(*t))
308 sub = static_cast<size_t>(*t - '0');
309 else
310 sub = static_cast<size_t>(*t - 'A') + 10;
311 for (++t; t != last && (std::isdigit(*t) || std::isupper(*t)); ++t)
312 {
313 sub *= 36;
314 if (std::isdigit(*t))
315 sub += static_cast<size_t>(*t - '0');
316 else
317 sub += static_cast<size_t>(*t - 'A') + 10;
318 }
319 if (t == last || *t != '_')
320 return first;
321 ++sub;
322 if (sub < db.subs.size())
323 {
324 for (const auto& n : db.subs[sub])
325 db.names.push_back(n);
326 first = t+1;
327 }
328 }
329 break;
330 }
331 }
332 }
333 return first;
334}
335
336// <builtin-type> ::= v # void
337// ::= w # wchar_t
338// ::= b # bool
339// ::= c # char
340// ::= a # signed char
341// ::= h # unsigned char
342// ::= s # short
343// ::= t # unsigned short
344// ::= i # int
345// ::= j # unsigned int
346// ::= l # long
347// ::= m # unsigned long
348// ::= x # long long, __int64
349// ::= y # unsigned long long, __int64
350// ::= n # __int128
351// ::= o # unsigned __int128
352// ::= f # float
353// ::= d # double
354// ::= e # long double, __float80
355// ::= g # __float128
356// ::= z # ellipsis
357// ::= Dd # IEEE 754r decimal floating point (64 bits)
358// ::= De # IEEE 754r decimal floating point (128 bits)
359// ::= Df # IEEE 754r decimal floating point (32 bits)
360// ::= Dh # IEEE 754r half-precision floating point (16 bits)
361// ::= Di # char32_t
362// ::= Ds # char16_t
363// ::= Da # auto (in dependent new-expressions)
364// ::= Dn # std::nullptr_t (i.e., decltype(nullptr))
365// ::= u <source-name> # vendor extended type
366
367template <class C>
368const char*
369parse_builtin_type(const char* first, const char* last, C& db)
370{
371 if (first != last)
372 {
373 switch (*first)
374 {
375 case 'v':
376 db.names.push_back("void");
377 ++first;
378 break;
379 case 'w':
380 db.names.push_back("wchar_t");
381 ++first;
382 break;
383 case 'b':
384 db.names.push_back("bool");
385 ++first;
386 break;
387 case 'c':
388 db.names.push_back("char");
389 ++first;
390 break;
391 case 'a':
392 db.names.push_back("signed char");
393 ++first;
394 break;
395 case 'h':
396 db.names.push_back("unsigned char");
397 ++first;
398 break;
399 case 's':
400 db.names.push_back("short");
401 ++first;
402 break;
403 case 't':
404 db.names.push_back("unsigned short");
405 ++first;
406 break;
407 case 'i':
408 db.names.push_back("int");
409 ++first;
410 break;
411 case 'j':
412 db.names.push_back("unsigned int");
413 ++first;
414 break;
415 case 'l':
416 db.names.push_back("long");
417 ++first;
418 break;
419 case 'm':
420 db.names.push_back("unsigned long");
421 ++first;
422 break;
423 case 'x':
424 db.names.push_back("long long");
425 ++first;
426 break;
427 case 'y':
428 db.names.push_back("unsigned long long");
429 ++first;
430 break;
431 case 'n':
432 db.names.push_back("__int128");
433 ++first;
434 break;
435 case 'o':
436 db.names.push_back("unsigned __int128");
437 ++first;
438 break;
439 case 'f':
440 db.names.push_back("float");
441 ++first;
442 break;
443 case 'd':
444 db.names.push_back("double");
445 ++first;
446 break;
447 case 'e':
448 db.names.push_back("long double");
449 ++first;
450 break;
451 case 'g':
452 db.names.push_back("__float128");
453 ++first;
454 break;
455 case 'z':
456 db.names.push_back("...");
457 ++first;
458 break;
459 case 'u':
460 {
461 const char*t = parse_source_name(first+1, last, db);
462 if (t != first+1)
463 first = t;
464 }
465 break;
466 case 'D':
467 if (first+1 != last)
468 {
469 switch (first[1])
470 {
471 case 'd':
472 db.names.push_back("decimal64");
473 first += 2;
474 break;
475 case 'e':
476 db.names.push_back("decimal128");
477 first += 2;
478 break;
479 case 'f':
480 db.names.push_back("decimal32");
481 first += 2;
482 break;
483 case 'h':
484 db.names.push_back("decimal16");
485 first += 2;
486 break;
487 case 'i':
488 db.names.push_back("char32_t");
489 first += 2;
490 break;
491 case 's':
492 db.names.push_back("char16_t");
493 first += 2;
494 break;
495 case 'a':
496 db.names.push_back("auto");
497 first += 2;
498 break;
499 case 'n':
500 db.names.push_back("std::nullptr_t");
501 first += 2;
502 break;
503 }
504 }
505 break;
506 }
507 }
508 return first;
509}
510
511// <CV-qualifiers> ::= [r] [V] [K]
512
513const char*
514parse_cv_qualifiers(const char* first, const char* last, unsigned& cv)
515{
516 cv = 0;
517 if (first != last)
518 {
519 if (*first == 'r')
520 {
521 cv |= 4;
522 ++first;
523 }
524 if (*first == 'V')
525 {
526 cv |= 2;
527 ++first;
528 }
529 if (*first == 'K')
530 {
531 cv |= 1;
532 ++first;
533 }
534 }
535 return first;
536}
537
538// <template-param> ::= T_ # first template parameter
539// ::= T <parameter-2 non-negative number> _
540
541template <class C>
542const char*
543parse_template_param(const char* first, const char* last, C& db)
544{
545 if (last - first >= 2)
546 {
547 if (*first == 'T')
548 {
549 if (first[1] == '_')
550 {
551 if (!db.template_param.back().empty())
552 {
553 for (auto& t : db.template_param.back().front())
554 db.names.push_back(t);
555 first += 2;
556 }
557 else
558 {
559 db.names.push_back("T_");
560 first += 2;
561 db.fix_forward_references = true;
562 }
563 }
564 else if (isdigit(first[1]))
565 {
566 const char* t = first+1;
567 size_t sub = static_cast<size_t>(*t - '0');
568 for (++t; t != last && isdigit(*t); ++t)
569 {
570 sub *= 10;
571 sub += static_cast<size_t>(*t - '0');
572 }
573 if (t == last || *t != '_')
574 return first;
575 ++sub;
576 if (sub < db.template_param.back().size())
577 {
578 for (auto& temp : db.template_param.back()[sub])
579 db.names.push_back(temp);
580 first = t+1;
581 }
582 else
583 {
584 db.names.push_back(typename C::String(first, t+1));
585 first = t+1;
586 db.fix_forward_references = true;
587 }
588 }
589 }
590 }
591 return first;
592}
593
594// cc <type> <expression> # const_cast<type> (expression)
595
596template <class C>
597const char*
598parse_const_cast_expr(const char* first, const char* last, C& db)
599{
600 if (last - first >= 3 && first[0] == 'c' && first[1] == 'c')
601 {
602 const char* t = parse_type(first+2, last, db);
603 if (t != first+2)
604 {
605 const char* t1 = parse_expression(t, last, db);
606 if (t1 != t)
607 {
608 auto expr = db.names.back().move_full();
609 db.names.pop_back();
610 db.names.back() = "const_cast<" + db.names.back().move_full() + ">(" + expr + ")";
611 first = t1;
612 }
613 }
614 }
615 return first;
616}
617
618// dc <type> <expression> # dynamic_cast<type> (expression)
619
620template <class C>
621const char*
622parse_dynamic_cast_expr(const char* first, const char* last, C& db)
623{
624 if (last - first >= 3 && first[0] == 'd' && first[1] == 'c')
625 {
626 const char* t = parse_type(first+2, last, db);
627 if (t != first+2)
628 {
629 const char* t1 = parse_expression(t, last, db);
630 if (t1 != t)
631 {
632 auto expr = db.names.back().move_full();
633 db.names.pop_back();
634 db.names.back() = "dynamic_cast<" + db.names.back().move_full() + ">(" + expr + ")";
635 first = t1;
636 }
637 }
638 }
639 return first;
640}
641
642// rc <type> <expression> # reinterpret_cast<type> (expression)
643
644template <class C>
645const char*
646parse_reinterpret_cast_expr(const char* first, const char* last, C& db)
647{
648 if (last - first >= 3 && first[0] == 'r' && first[1] == 'c')
649 {
650 const char* t = parse_type(first+2, last, db);
651 if (t != first+2)
652 {
653 const char* t1 = parse_expression(t, last, db);
654 if (t1 != t)
655 {
656 auto expr = db.names.back().move_full();
657 db.names.pop_back();
658 db.names.back() = "reinterpret_cast<" + db.names.back().move_full() + ">(" + expr + ")";
659 first = t1;
660 }
661 }
662 }
663 return first;
664}
665
666// sc <type> <expression> # static_cast<type> (expression)
667
668template <class C>
669const char*
670parse_static_cast_expr(const char* first, const char* last, C& db)
671{
672 if (last - first >= 3 && first[0] == 's' && first[1] == 'c')
673 {
674 const char* t = parse_type(first+2, last, db);
675 if (t != first+2)
676 {
677 const char* t1 = parse_expression(t, last, db);
678 if (t1 != t)
679 {
680 auto expr = db.names.back().move_full();
681 db.names.pop_back();
682 db.names.back() = "static_cast<" + db.names.back().move_full() + ">(" + expr + ")";
683 first = t1;
684 }
685 }
686 }
687 return first;
688}
689
690// sp <expression> # pack expansion
691
692template <class C>
693const char*
694parse_pack_expansion(const char* first, const char* last, C& db)
695{
696 if (last - first >= 3 && first[0] == 's' && first[1] == 'p')
697 {
698 const char* t = parse_expression(first+2, last, db);
699 if (t != first+2)
700 first = t;
701 }
702 return first;
703}
704
705// st <type> # sizeof (a type)
706
707template <class C>
708const char*
709parse_sizeof_type_expr(const char* first, const char* last, C& db)
710{
711 if (last - first >= 3 && first[0] == 's' && first[1] == 't')
712 {
713 const char* t = parse_type(first+2, last, db);
714 if (t != first+2)
715 {
716 db.names.back() = "sizeof (" + db.names.back().move_full() + ")";
717 first = t;
718 }
719 }
720 return first;
721}
722
723// sz <expr> # sizeof (a expression)
724
725template <class C>
726const char*
727parse_sizeof_expr_expr(const char* first, const char* last, C& db)
728{
729 if (last - first >= 3 && first[0] == 's' && first[1] == 'z')
730 {
731 const char* t = parse_expression(first+2, last, db);
732 if (t != first+2)
733 {
734 db.names.back() = "sizeof (" + db.names.back().move_full() + ")";
735 first = t;
736 }
737 }
738 return first;
739}
740
741// sZ <template-param> # size of a parameter pack
742
743template <class C>
744const char*
745parse_sizeof_param_pack_expr(const char* first, const char* last, C& db)
746{
747 if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'T')
748 {
749 size_t k0 = db.names.size();
750 const char* t = parse_template_param(first+2, last, db);
751 size_t k1 = db.names.size();
752 if (t != first+2)
753 {
754 typename C::String tmp("sizeof...(");
755 size_t k = k0;
756 if (k != k1)
757 {
758 tmp += db.names[k].move_full();
759 for (++k; k != k1; ++k)
760 tmp += ", " + db.names[k].move_full();
761 }
762 tmp += ")";
763 for (; k1 != k0; --k1)
764 db.names.pop_back();
765 db.names.push_back(std::move(tmp));
766 first = t;
767 }
768 }
769 return first;
770}
771
772// <function-param> ::= fp <top-level CV-qualifiers> _ # L == 0, first parameter
773// ::= fp <top-level CV-qualifiers> <parameter-2 non-negative number> _ # L == 0, second and later parameters
774// ::= fL <L-1 non-negative number> p <top-level CV-qualifiers> _ # L > 0, first parameter
775// ::= fL <L-1 non-negative number> p <top-level CV-qualifiers> <parameter-2 non-negative number> _ # L > 0, second and later parameters
776
777template <class C>
778const char*
779parse_function_param(const char* first, const char* last, C& db)
780{
781 if (last - first >= 3 && *first == 'f')
782 {
783 if (first[1] == 'p')
784 {
785 unsigned cv;
786 const char* t = parse_cv_qualifiers(first+2, last, cv);
787 const char* t1 = parse_number(t, last);
788 if (t1 != last && *t1 == '_')
789 {
790 db.names.push_back("fp" + typename C::String(t, t1));
791 first = t1+1;
792 }
793 }
794 else if (first[1] == 'L')
795 {
796 unsigned cv;
797 const char* t0 = parse_number(first+2, last);
798 if (t0 != last && *t0 == 'p')
799 {
800 ++t0;
801 const char* t = parse_cv_qualifiers(t0, last, cv);
802 const char* t1 = parse_number(t, last);
803 if (t1 != last && *t1 == '_')
804 {
805 db.names.push_back("fp" + typename C::String(t, t1));
806 first = t1+1;
807 }
808 }
809 }
810 }
811 return first;
812}
813
814// sZ <function-param> # size of a function parameter pack
815
816template <class C>
817const char*
818parse_sizeof_function_param_pack_expr(const char* first, const char* last, C& db)
819{
820 if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'f')
821 {
822 const char* t = parse_function_param(first+2, last, db);
823 if (t != first+2)
824 {
825 db.names.back() = "sizeof...(" + db.names.back().move_full() + ")";
826 first = t;
827 }
828 }
829 return first;
830}
831
832// te <expression> # typeid (expression)
833// ti <type> # typeid (type)
834
835template <class C>
836const char*
837parse_typeid_expr(const char* first, const char* last, C& db)
838{
839 if (last - first >= 3 && first[0] == 't' && (first[1] == 'e' || first[1] == 'i'))
840 {
841 const char* t;
842 if (first[1] == 'e')
843 t = parse_expression(first+2, last, db);
844 else
845 t = parse_type(first+2, last, db);
846 if (t != first+2)
847 {
848 db.names.back() = "typeid(" + db.names.back().move_full() + ")";
849 first = t;
850 }
851 }
852 return first;
853}
854
855// tw <expression> # throw expression
856
857template <class C>
858const char*
859parse_throw_expr(const char* first, const char* last, C& db)
860{
861 if (last - first >= 3 && first[0] == 't' && first[1] == 'w')
862 {
863 const char* t = parse_expression(first+2, last, db);
864 if (t != first+2)
865 {
866 db.names.back() = "throw " + db.names.back().move_full();
867 first = t;
868 }
869 }
870 return first;
871}
872
873// ds <expression> <expression> # expr.*expr
874
875template <class C>
876const char*
877parse_dot_star_expr(const char* first, const char* last, C& db)
878{
879 if (last - first >= 3 && first[0] == 'd' && first[1] == 's')
880 {
881 const char* t = parse_expression(first+2, last, db);
882 if (t != first+2)
883 {
884 const char* t1 = parse_expression(t, last, db);
885 if (t1 != t)
886 {
887 auto expr = db.names.back().move_full();
888 db.names.pop_back();
889 db.names.back().first += ".*" + expr;
890 first = t1;
891 }
892 }
893 }
894 return first;
895}
896
897// <simple-id> ::= <source-name> [ <template-args> ]
898
899template <class C>
900const char*
901parse_simple_id(const char* first, const char* last, C& db)
902{
903 if (first != last)
904 {
905 const char* t = parse_source_name(first, last, db);
906 if (t != first)
907 {
908 const char* t1 = parse_template_args(t, last, db);
909 if (t1 != t)
910 {
911 auto args = db.names.back().move_full();
912 db.names.pop_back();
913 db.names.back().first += std::move(args);
914 }
915 first = t1;
916 }
917 else
918 first = t;
919 }
920 return first;
921}
922
923// <unresolved-type> ::= <template-param>
924// ::= <decltype>
925// ::= <substitution>
926
927template <class C>
928const char*
929parse_unresolved_type(const char* first, const char* last, C& db)
930{
931 if (first != last)
932 {
933 const char* t = first;
934 switch (*first)
935 {
936 case 'T':
937 {
938 size_t k0 = db.names.size();
939 t = parse_template_param(first, last, db);
940 size_t k1 = db.names.size();
941 if (t != first && k1 == k0 + 1)
942 {
943 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
944 first = t;
945 }
946 else
947 {
948 for (; k1 != k0; --k1)
949 db.names.pop_back();
950 }
951 break;
952 }
953 case 'D':
954 t = parse_decltype(first, last, db);
955 if (t != first)
956 {
957 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
958 first = t;
959 }
960 break;
961 case 'S':
962 t = parse_substitution(first, last, db);
963 if (t != first)
964 first = t;
965 else
966 {
967 if (last - first > 2 && first[1] == 't')
968 {
969 t = parse_unqualified_name(first+2, last, db);
970 if (t != first+2)
971 {
972 db.names.back().first.insert(0, "std::");
973 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
974 first = t;
975 }
976 }
977 }
978 break;
979 }
980 }
981 return first;
982}
983
984// <destructor-name> ::= <unresolved-type> # e.g., ~T or ~decltype(f())
985// ::= <simple-id> # e.g., ~A<2*N>
986
987template <class C>
988const char*
989parse_destructor_name(const char* first, const char* last, C& db)
990{
991 if (first != last)
992 {
993 const char* t = parse_unresolved_type(first, last, db);
994 if (t == first)
995 t = parse_simple_id(first, last, db);
996 if (t != first)
997 {
998 db.names.back().first.insert(0, "~");
999 first = t;
1000 }
1001 }
1002 return first;
1003}
1004
1005// <base-unresolved-name> ::= <simple-id> # unresolved name
1006// extension ::= <operator-name> # unresolved operator-function-id
1007// extension ::= <operator-name> <template-args> # unresolved operator template-id
1008// ::= on <operator-name> # unresolved operator-function-id
1009// ::= on <operator-name> <template-args> # unresolved operator template-id
1010// ::= dn <destructor-name> # destructor or pseudo-destructor;
1011// # e.g. ~X or ~X<N-1>
1012
1013template <class C>
1014const char*
1015parse_base_unresolved_name(const char* first, const char* last, C& db)
1016{
1017 if (last - first >= 2)
1018 {
1019 if ((first[0] == 'o' || first[0] == 'd') && first[1] == 'n')
1020 {
1021 if (first[0] == 'o')
1022 {
1023 const char* t = parse_operator_name(first+2, last, db);
1024 if (t != first+2)
1025 {
1026 first = parse_template_args(t, last, db);
1027 if (first != t)
1028 {
1029 auto args = db.names.back().move_full();
1030 db.names.pop_back();
1031 db.names.back().first += std::move(args);
1032 }
1033 }
1034 }
1035 else
1036 {
1037 const char* t = parse_destructor_name(first+2, last, db);
1038 if (t != first+2)
1039 first = t;
1040 }
1041 }
1042 else
1043 {
1044 const char* t = parse_simple_id(first, last, db);
1045 if (t == first)
1046 {
1047 t = parse_operator_name(first, last, db);
1048 if (t != first)
1049 {
1050 first = parse_template_args(t, last, db);
1051 if (first != t)
1052 {
1053 auto args = db.names.back().move_full();
1054 db.names.pop_back();
1055 db.names.back().first += std::move(args);
1056 }
1057 }
1058 }
1059 else
1060 first = t;
1061 }
1062 }
1063 return first;
1064}
1065
1066// <unresolved-qualifier-level> ::= <simple-id>
1067
1068template <class C>
1069const char*
1070parse_unresolved_qualifier_level(const char* first, const char* last, C& db)
1071{
1072 return parse_simple_id(first, last, db);
1073}
1074
1075// <unresolved-name>
1076// extension ::= srN <unresolved-type> [<template-args>] <unresolved-qualifier-level>* E <base-unresolved-name>
1077// ::= [gs] <base-unresolved-name> # x or (with "gs") ::x
1078// ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name>
1079// # A::x, N::y, A<T>::z; "gs" means leading "::"
1080// ::= sr <unresolved-type> <base-unresolved-name> # T::x / decltype(p)::x
1081// extension ::= sr <unresolved-type> <template-args> <base-unresolved-name>
1082// # T::N::x /decltype(p)::N::x
1083// (ignored) ::= srN <unresolved-type> <unresolved-qualifier-level>+ E <base-unresolved-name>
1084
1085template <class C>
1086const char*
1087parse_unresolved_name(const char* first, const char* last, C& db)
1088{
1089 if (last - first > 2)
1090 {
1091 const char* t = first;
1092 bool global = false;
1093 if (t[0] == 'g' && t[1] == 's')
1094 {
1095 global = true;
1096 t += 2;
1097 }
1098 const char* t2 = parse_base_unresolved_name(t, last, db);
1099 if (t2 != t)
1100 {
1101 if (global)
1102 db.names.back().first.insert(0, "::");
1103 first = t2;
1104 }
1105 else if (last - t > 2 && t[0] == 's' && t[1] == 'r')
1106 {
1107 if (t[2] == 'N')
1108 {
1109 t += 3;
1110 const char* t1 = parse_unresolved_type(t, last, db);
1111 if (t1 == t || t1 == last)
1112 return first;
1113 t = t1;
1114 t1 = parse_template_args(t, last, db);
1115 if (t1 != t)
1116 {
1117 auto args = db.names.back().move_full();
1118 db.names.pop_back();
1119 db.names.back().first += std::move(args);
1120 t = t1;
1121 if (t == last)
1122 {
1123 db.names.pop_back();
1124 return first;
1125 }
1126 }
1127 while (*t != 'E')
1128 {
1129 t1 = parse_unresolved_qualifier_level(t, last, db);
1130 if (t1 == t || t1 == last)
1131 return first;
1132 auto s = db.names.back().move_full();
1133 db.names.pop_back();
1134 db.names.back().first += "::" + std::move(s);
1135 t = t1;
1136 }
1137 ++t;
1138 t1 = parse_base_unresolved_name(t, last, db);
1139 if (t1 == t)
1140 {
1141 db.names.pop_back();
1142 return first;
1143 }
1144 auto s = db.names.back().move_full();
1145 db.names.pop_back();
1146 db.names.back().first += "::" + std::move(s);
1147 first = t1;
1148 }
1149 else
1150 {
1151 t += 2;
1152 const char* t1 = parse_unresolved_type(t, last, db);
1153 if (t1 != t)
1154 {
1155 t = t1;
1156 t1 = parse_template_args(t, last, db);
1157 if (t1 != t)
1158 {
1159 auto args = db.names.back().move_full();
1160 db.names.pop_back();
1161 db.names.back().first += std::move(args);
1162 t = t1;
1163 }
1164 t1 = parse_base_unresolved_name(t, last, db);
1165 if (t1 == t)
1166 {
1167 db.names.pop_back();
1168 return first;
1169 }
1170 auto s = db.names.back().move_full();
1171 db.names.pop_back();
1172 db.names.back().first += "::" + std::move(s);
1173 first = t1;
1174 }
1175 else
1176 {
1177 t1 = parse_unresolved_qualifier_level(t, last, db);
1178 if (t1 == t || t1 == last)
1179 return first;
1180 t = t1;
1181 if (global)
1182 db.names.back().first.insert(0, "::");
1183 while (*t != 'E')
1184 {
1185 t1 = parse_unresolved_qualifier_level(t, last, db);
1186 if (t1 == t || t1 == last)
1187 return first;
1188 auto s = db.names.back().move_full();
1189 db.names.pop_back();
1190 db.names.back().first += "::" + std::move(s);
1191 t = t1;
1192 }
1193 ++t;
1194 t1 = parse_base_unresolved_name(t, last, db);
1195 if (t1 == t)
1196 {
1197 db.names.pop_back();
1198 return first;
1199 }
1200 auto s = db.names.back().move_full();
1201 db.names.pop_back();
1202 db.names.back().first += "::" + std::move(s);
1203 first = t1;
1204 }
1205 }
1206 }
1207 }
1208 return first;
1209}
1210
1211// dt <expression> <unresolved-name> # expr.name
1212
1213template <class C>
1214const char*
1215parse_dot_expr(const char* first, const char* last, C& db)
1216{
1217 if (last - first >= 3 && first[0] == 'd' && first[1] == 't')
1218 {
1219 const char* t = parse_expression(first+2, last, db);
1220 if (t != first+2)
1221 {
1222 const char* t1 = parse_unresolved_name(t, last, db);
1223 if (t1 != t)
1224 {
1225 auto name = db.names.back().move_full();
1226 db.names.pop_back();
1227 db.names.back().first += "." + name;
1228 first = t1;
1229 }
1230 }
1231 }
1232 return first;
1233}
1234
1235// cl <expression>+ E # call
1236
1237template <class C>
1238const char*
1239parse_call_expr(const char* first, const char* last, C& db)
1240{
1241 if (last - first >= 4 && first[0] == 'c' && first[1] == 'l')
1242 {
1243 const char* t = parse_expression(first+2, last, db);
1244 if (t != first+2)
1245 {
1246 if (t == last)
1247 return first;
1248 db.names.back().first += db.names.back().second;
1249 db.names.back().second = typename C::String();
1250 db.names.back().first.append("(");
1251 bool first_expr = true;
1252 while (*t != 'E')
1253 {
1254 const char* t1 = parse_expression(t, last, db);
1255 if (t1 == t || t1 == last)
1256 return first;
1257 auto tmp = db.names.back().move_full();
1258 db.names.pop_back();
1259 if (!tmp.empty())
1260 {
1261 if (!first_expr)
1262 {
1263 db.names.back().first.append(", ");
1264 first_expr = false;
1265 }
1266 db.names.back().first.append(tmp);
1267 }
1268 t = t1;
1269 }
1270 ++t;
1271 db.names.back().first.append(")");
1272 first = t;
1273 }
1274 }
1275 return first;
1276}
1277
1278// [gs] nw <expression>* _ <type> E # new (expr-list) type
1279// [gs] nw <expression>* _ <type> <initializer> # new (expr-list) type (init)
1280// [gs] na <expression>* _ <type> E # new[] (expr-list) type
1281// [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type (init)
1282// <initializer> ::= pi <expression>* E # parenthesized initialization
1283
1284template <class C>
1285const char*
1286parse_new_expr(const char* first, const char* last, C& db)
1287{
1288 if (last - first >= 4)
1289 {
1290 const char* t = first;
1291 bool parsed_gs = false;
1292 if (t[0] == 'g' && t[1] == 's')
1293 {
1294 t += 2;
1295 parsed_gs = true;
1296 }
1297 if (t[0] == 'n' && (t[1] == 'w' || t[1] == 'a'))
1298 {
1299 bool is_array = t[1] == 'a';
1300 t += 2;
1301 if (t == last)
1302 return first;
1303 bool has_expr_list = false;
1304 bool first_expr = true;
1305 while (*t != '_')
1306 {
1307 const char* t1 = parse_expression(t, last, db);
1308 if (t1 == t || t1 == last)
1309 return first;
1310 has_expr_list = true;
1311 if (!first_expr)
1312 {
1313 auto tmp = db.names.back().move_full();
1314 db.names.pop_back();
1315 if (!tmp.empty())
1316 {
1317 db.names.back().first.append(", ");
1318 db.names.back().first.append(tmp);
1319 first_expr = false;
1320 }
1321 }
1322 t = t1;
1323 }
1324 ++t;
1325 const char* t1 = parse_type(t, last, db);
1326 if (t1 == t || t1 == last)
1327 return first;
1328 t = t1;
1329 bool has_init = false;
1330 if (last - t >= 3 && t[0] == 'p' && t[1] == 'i')
1331 {
1332 t += 2;
1333 has_init = true;
1334 first_expr = true;
1335 while (*t != 'E')
1336 {
1337 t1 = parse_expression(t, last, db);
1338 if (t1 == t || t1 == last)
1339 return first;
1340 if (!first_expr)
1341 {
1342 auto tmp = db.names.back().move_full();
1343 db.names.pop_back();
1344 if (!tmp.empty())
1345 {
1346 db.names.back().first.append(", ");
1347 db.names.back().first.append(tmp);
1348 first_expr = false;
1349 }
1350 }
1351 t = t1;
1352 }
1353 }
1354 if (*t != 'E')
1355 return first;
1356 typename C::String init_list;
1357 if (has_init)
1358 {
1359 init_list = db.names.back().move_full();
1360 db.names.pop_back();
1361 }
1362 auto type = db.names.back().move_full();
1363 db.names.pop_back();
1364 typename C::String expr_list;
1365 if (has_expr_list)
1366 {
1367 expr_list = db.names.back().move_full();
1368 db.names.pop_back();
1369 }
1370 typename C::String r;
1371 if (parsed_gs)
1372 r = "::";
1373 if (is_array)
1374 r += "[] ";
1375 else
1376 r += " ";
1377 if (has_expr_list)
1378 r += "(" + expr_list + ") ";
1379 r += type;
1380 if (has_init)
1381 r += " (" + init_list + ")";
1382 db.names.push_back(std::move(r));
1383 first = t+1;
1384 }
1385 }
1386 return first;
1387}
1388
1389// cv <type> <expression> # conversion with one argument
1390// cv <type> _ <expression>* E # conversion with a different number of arguments
1391
1392template <class C>
1393const char*
1394parse_conversion_expr(const char* first, const char* last, C& db)
1395{
1396 if (last - first >= 3 && first[0] == 'c' && first[1] == 'v')
1397 {
1398 bool try_to_parse_template_args = db.try_to_parse_template_args;
1399 db.try_to_parse_template_args = false;
1400 const char* t = parse_type(first+2, last, db);
1401 db.try_to_parse_template_args = try_to_parse_template_args;
1402 if (t != first+2 && t != last)
1403 {
1404 if (*t != '_')
1405 {
1406 const char* t1 = parse_expression(t, last, db);
1407 if (t1 == t)
1408 return first;
1409 t = t1;
1410 }
1411 else
1412 {
1413 ++t;
1414 if (t == last)
1415 return first;
1416 if (*t == 'E')
1417 db.names.emplace_back();
1418 else
1419 {
1420 bool first_expr = true;
1421 while (*t != 'E')
1422 {
1423 const char* t1 = parse_expression(t, last, db);
1424 if (t1 == t || t1 == last)
1425 return first;
1426 if (!first_expr)
1427 {
1428 auto tmp = db.names.back().move_full();
1429 db.names.pop_back();
1430 if (!tmp.empty())
1431 {
1432 db.names.back().first.append(", ");
1433 db.names.back().first.append(tmp);
1434 first_expr = false;
1435 }
1436 }
1437 t = t1;
1438 }
1439 }
1440 ++t;
1441 }
1442 auto tmp = db.names.back().move_full();
1443 db.names.pop_back();
1444 db.names.back() = "(" + db.names.back().move_full() + ")(" + tmp + ")";
1445 first = t;
1446 }
1447 }
1448 return first;
1449}
1450
1451// pt <expression> <expression> # expr->name
1452
1453template <class C>
1454const char*
1455parse_arrow_expr(const char* first, const char* last, C& db)
1456{
1457 if (last - first >= 3 && first[0] == 'p' && first[1] == 't')
1458 {
1459 const char* t = parse_expression(first+2, last, db);
1460 if (t != first+2)
1461 {
1462 const char* t1 = parse_expression(t, last, db);
1463 if (t1 != t)
1464 {
1465 auto tmp = db.names.back().move_full();
1466 db.names.pop_back();
1467 db.names.back().first += "->";
1468 db.names.back().first += tmp;
1469 first = t1;
1470 }
1471 }
1472 }
1473 return first;
1474}
1475
1476// <ref-qualifier> ::= R # & ref-qualifier
1477// <ref-qualifier> ::= O # && ref-qualifier
1478
1479// <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E
1480
1481template <class C>
1482const char*
1483parse_function_type(const char* first, const char* last, C& db)
1484{
1485 if (first != last && *first == 'F')
1486 {
1487 const char* t = first+1;
1488 if (t != last)
1489 {
1490 bool externC = false;
1491 if (*t == 'Y')
1492 {
1493 externC = true;
1494 if (++t == last)
1495 return first;
1496 }
1497 const char* t1 = parse_type(t, last, db);
1498 if (t1 != t)
1499 {
1500 t = t1;
1501 typename C::String sig("(");
1502 int ref_qual = 0;
1503 while (true)
1504 {
1505 if (t == last)
1506 {
1507 db.names.pop_back();
1508 return first;
1509 }
1510 if (*t == 'E')
1511 {
1512 ++t;
1513 break;
1514 }
1515 if (*t == 'v')
1516 {
1517 ++t;
1518 continue;
1519 }
1520 if (*t == 'R' && t+1 != last && t[1] == 'E')
1521 {
1522 ref_qual = 1;
1523 ++t;
1524 continue;
1525 }
1526 if (*t == 'O' && t+1 != last && t[1] == 'E')
1527 {
1528 ref_qual = 2;
1529 ++t;
1530 continue;
1531 }
1532 size_t k0 = db.names.size();
1533 t1 = parse_type(t, last, db);
1534 size_t k1 = db.names.size();
1535 if (t1 == t || t1 == last)
1536 return first;
1537 for (size_t k = k0; k < k1; ++k)
1538 {
1539 if (sig.size() > 1)
1540 sig += ", ";
1541 sig += db.names[k].move_full();
1542 }
1543 for (size_t k = k0; k < k1; ++k)
1544 db.names.pop_back();
1545 t = t1;
1546 }
1547 sig += ")";
1548 switch (ref_qual)
1549 {
1550 case 1:
1551 sig += " &";
1552 break;
1553 case 2:
1554 sig += " &&";
1555 break;
1556 }
1557 db.names.back().first += " ";
1558 db.names.back().second.insert(0, sig);
1559 first = t;
1560 }
1561 }
1562 }
1563 return first;
1564}
1565
1566// <pointer-to-member-type> ::= M <class type> <member type>
1567
1568template <class C>
1569const char*
1570parse_pointer_to_member_type(const char* first, const char* last, C& db)
1571{
1572 if (first != last && *first == 'M')
1573 {
1574 const char* t = parse_type(first+1, last, db);
1575 if (t != first+1)
1576 {
1577 const char* t2 = parse_type(t, last, db);
1578 if (t2 != t)
1579 {
1580 auto func = std::move(db.names.back());
1581 db.names.pop_back();
1582 auto class_type = std::move(db.names.back());
1583 if (func.second.front() == '(')
1584 {
1585 db.names.back().first = std::move(func.first) + "(" + class_type.move_full() + "::*";
1586 db.names.back().second = ")" + std::move(func.second);
1587 }
1588 else
1589 {
1590 db.names.back().first = std::move(func.first) + " " + class_type.move_full() + "::*";
1591 db.names.back().second = std::move(func.second);
1592 }
1593 first = t2;
1594 }
1595 }
1596 }
1597 return first;
1598}
1599
1600// <array-type> ::= A <positive dimension number> _ <element type>
1601// ::= A [<dimension expression>] _ <element type>
1602
1603template <class C>
1604const char*
1605parse_array_type(const char* first, const char* last, C& db)
1606{
1607 if (first != last && *first == 'A' && first+1 != last)
1608 {
1609 if (first[1] == '_')
1610 {
1611 const char* t = parse_type(first+2, last, db);
1612 if (t != first+2)
1613 {
1614 if (db.names.back().second.substr(0, 2) == " [")
1615 db.names.back().second.erase(0, 1);
1616 db.names.back().second.insert(0, " []");
1617 first = t;
1618 }
1619 }
1620 else if ('1' <= first[1] && first[1] <= '9')
1621 {
1622 const char* t = parse_number(first+1, last);
1623 if (t != last && *t == '_')
1624 {
1625 const char* t2 = parse_type(t+1, last, db);
1626 if (t2 != t+1)
1627 {
1628 if (db.names.back().second.substr(0, 2) == " [")
1629 db.names.back().second.erase(0, 1);
1630 db.names.back().second.insert(0, " [" + typename C::String(first+1, t) + "]");
1631 first = t2;
1632 }
1633 }
1634 }
1635 else
1636 {
1637 const char* t = parse_expression(first+1, last, db);
1638 if (t != first+1 && t != last && *t == '_')
1639 {
1640 const char* t2 = parse_type(++t, last, db);
1641 if (t2 != t)
1642 {
1643 auto type = std::move(db.names.back());
1644 db.names.pop_back();
1645 auto expr = std::move(db.names.back());
1646 db.names.back().first = std::move(type.first);
1647 if (type.second.substr(0, 2) == " [")
1648 type.second.erase(0, 1);
1649 db.names.back().second = " [" + expr.move_full() + "]" + std::move(type.second);
1650 first = t2;
1651 }
1652 }
1653 }
1654 }
1655 return first;
1656}
1657
1658// <decltype> ::= Dt <expression> E # decltype of an id-expression or class member access (C++0x)
1659// ::= DT <expression> E # decltype of an expression (C++0x)
1660
1661template <class C>
1662const char*
1663parse_decltype(const char* first, const char* last, C& db)
1664{
1665 if (last - first >= 4 && first[0] == 'D')
1666 {
1667 switch (first[1])
1668 {
1669 case 't':
1670 case 'T':
1671 {
1672 const char* t = parse_expression(first+2, last, db);
1673 if (t != first+2 && t != last && *t == 'E')
1674 {
1675 db.names.back() = "decltype(" + db.names.back().move_full() + ")";
1676 first = t+1;
1677 }
1678 }
1679 break;
1680 }
1681 }
1682 return first;
1683}
1684
1685// extension:
1686// <vector-type> ::= Dv <positive dimension number> _
1687// <extended element type>
1688// ::= Dv [<dimension expression>] _ <element type>
1689// <extended element type> ::= <element type>
1690// ::= p # AltiVec vector pixel
1691
1692template <class C>
1693const char*
1694parse_vector_type(const char* first, const char* last, C& db)
1695{
1696 if (last - first > 3 && first[0] == 'D' && first[1] == 'v')
1697 {
1698 if ('1' <= first[2] && first[2] <= '9')
1699 {
1700 const char* t = parse_number(first+2, last);
1701 if (t == last || *t != '_')
1702 return first;
1703 const char* num = first + 2;
1704 size_t sz = static_cast<size_t>(t - num);
1705 if (++t != last)
1706 {
1707 if (*t != 'p')
1708 {
1709 const char* t1 = parse_type(t, last, db);
1710 if (t1 != t)
1711 {
1712 db.names.back().first += " vector[" + typename C::String(num, sz) + "]";
1713 first = t1;
1714 }
1715 }
1716 else
1717 {
1718 ++t;
1719 db.names.push_back("pixel vector[" + typename C::String(num, sz) + "]");
1720 first = t;
1721 }
1722 }
1723 }
1724 else
1725 {
1726 typename C::String num;
1727 const char* t1 = first+2;
1728 if (*t1 != '_')
1729 {
1730 const char* t = parse_expression(t1, last, db);
1731 if (t != t1)
1732 {
1733 num = db.names.back().move_full();
1734 db.names.pop_back();
1735 t1 = t;
1736 }
1737 }
1738 if (t1 != last && *t1 == '_' && ++t1 != last)
1739 {
1740 const char* t = parse_type(t1, last, db);
1741 if (t != t1)
1742 {
1743 db.names.back().first += " vector[" + num + "]";
1744 first = t;
1745 }
1746 }
1747 }
1748 }
1749 return first;
1750}
1751
1752// <type> ::= <builtin-type>
1753// ::= <function-type>
1754// ::= <class-enum-type>
1755// ::= <array-type>
1756// ::= <pointer-to-member-type>
1757// ::= <template-param>
1758// ::= <template-template-param> <template-args>
1759// ::= <decltype>
1760// ::= <substitution>
1761// ::= <CV-qualifiers> <type>
1762// ::= P <type> # pointer-to
1763// ::= R <type> # reference-to
1764// ::= O <type> # rvalue reference-to (C++0x)
1765// ::= C <type> # complex pair (C 2000)
1766// ::= G <type> # imaginary (C 2000)
1767// ::= Dp <type> # pack expansion (C++0x)
1768// ::= U <source-name> <type> # vendor extended type qualifier
1769// extension := U <objc-name> <objc-type> # objc-type<identifier>
1770// extension := <vector-type> # <vector-type> starts with Dv
1771
1772// <objc-name> ::= <k0 number> objcproto <k1 number> <identifier> # k0 = 9 + <number of digits in k1> + k1
1773// <objc-type> := <source-name> # PU<11+>objcproto 11objc_object<source-name> 11objc_object -> id<source-name>
1774
1775template <class C>
1776const char*
1777parse_type(const char* first, const char* last, C& db)
1778{
1779 if (first != last)
1780 {
1781 switch (*first)
1782 {
1783 case 'r':
1784 case 'V':
1785 case 'K':
1786 {
1787 unsigned cv = 0;
1788 const char* t = parse_cv_qualifiers(first, last, cv);
1789 if (t != first)
1790 {
1791 bool is_function = *t == 'F';
1792 size_t k0 = db.names.size();
1793 const char* t1 = parse_type(t, last, db);
1794 size_t k1 = db.names.size();
1795 if (t1 != t)
1796 {
1797 if (is_function)
1798 db.subs.pop_back();
1799 db.subs.emplace_back(db.names.get_allocator());
1800 for (size_t k = k0; k < k1; ++k)
1801 {
1802 if (is_function)
1803 {
1804 size_t p = db.names[k].second.size();
1805 if (db.names[k].second[p-2] == '&')
1806 p -= 3;
1807 else if (db.names[k].second.back() == '&')
1808 p -= 2;
1809 if (cv & 1)
1810 {
1811 db.names[k].second.insert(p, " const");
1812 p += 6;
1813 }
1814 if (cv & 2)
1815 {
1816 db.names[k].second.insert(p, " volatile");
1817 p += 9;
1818 }
1819 if (cv & 4)
1820 db.names[k].second.insert(p, " restrict");
1821 }
1822 else
1823 {
1824 if (cv & 1)
1825 db.names[k].first.append(" const");
1826 if (cv & 2)
1827 db.names[k].first.append(" volatile");
1828 if (cv & 4)
1829 db.names[k].first.append(" restrict");
1830 }
1831 db.subs.back().push_back(db.names[k]);
1832 }
1833 first = t1;
1834 }
1835 }
1836 }
1837 break;
1838 default:
1839 {
1840 const char* t = parse_builtin_type(first, last, db);
1841 if (t != first)
1842 {
1843 first = t;
1844 }
1845 else
1846 {
1847 switch (*first)
1848 {
1849 case 'A':
1850 t = parse_array_type(first, last, db);
1851 if (t != first)
1852 {
1853 first = t;
1854 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
1855 }
1856 break;
1857 case 'C':
1858 t = parse_type(first+1, last, db);
1859 if (t != first+1)
1860 {
1861 db.names.back().first.append(" complex");
1862 first = t;
1863 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
1864 }
1865 break;
1866 case 'F':
1867 t = parse_function_type(first, last, db);
1868 if (t != first)
1869 {
1870 first = t;
1871 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
1872 }
1873 break;
1874 case 'G':
1875 t = parse_type(first+1, last, db);
1876 if (t != first+1)
1877 {
1878 db.names.back().first.append(" imaginary");
1879 first = t;
1880 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
1881 }
1882 break;
1883 case 'M':
1884 t = parse_pointer_to_member_type(first, last, db);
1885 if (t != first)
1886 {
1887 first = t;
1888 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
1889 }
1890 break;
1891 case 'O':
1892 {
1893 size_t k0 = db.names.size();
1894 t = parse_type(first+1, last, db);
1895 size_t k1 = db.names.size();
1896 if (t != first+1)
1897 {
1898 db.subs.emplace_back(db.names.get_allocator());
1899 for (size_t k = k0; k < k1; ++k)
1900 {
1901 if (db.names[k].second.substr(0, 2) == " [")
1902 {
1903 db.names[k].first += " (";
1904 db.names[k].second.insert(0, ")");
1905 }
1906 else if (db.names[k].second.front() == '(')
1907 {
1908 db.names[k].first += "(";
1909 db.names[k].second.insert(0, ")");
1910 }
1911 db.names[k].first.append("&&");
1912 db.subs.back().push_back(db.names[k]);
1913 }
1914 first = t;
1915 }
1916 break;
1917 }
1918 case 'P':
1919 {
1920 size_t k0 = db.names.size();
1921 t = parse_type(first+1, last, db);
1922 size_t k1 = db.names.size();
1923 if (t != first+1)
1924 {
1925 db.subs.emplace_back(db.names.get_allocator());
1926 for (size_t k = k0; k < k1; ++k)
1927 {
1928 if (db.names[k].second.substr(0, 2) == " [")
1929 {
1930 db.names[k].first += " (";
1931 db.names[k].second.insert(0, ")");
1932 }
1933 else if (db.names[k].second.front() == '(')
1934 {
1935 db.names[k].first += "(";
1936 db.names[k].second.insert(0, ")");
1937 }
1938 if (first[1] != 'U' || db.names[k].first.substr(0, 12) != "objc_object<")
1939 {
1940 db.names[k].first.append("*");
1941 }
1942 else
1943 {
1944 db.names[k].first.replace(0, 11, "id");
1945 }
1946 db.subs.back().push_back(db.names[k]);
1947 }
1948 first = t;
1949 }
1950 break;
1951 }
1952 case 'R':
1953 {
1954 size_t k0 = db.names.size();
1955 t = parse_type(first+1, last, db);
1956 size_t k1 = db.names.size();
1957 if (t != first+1)
1958 {
1959 db.subs.emplace_back(db.names.get_allocator());
1960 for (size_t k = k0; k < k1; ++k)
1961 {
1962 if (db.names[k].second.substr(0, 2) == " [")
1963 {
1964 db.names[k].first += " (";
1965 db.names[k].second.insert(0, ")");
1966 }
1967 else if (db.names[k].second.front() == '(')
1968 {
1969 db.names[k].first += "(";
1970 db.names[k].second.insert(0, ")");
1971 }
1972 db.names[k].first.append("&");
1973 db.subs.back().push_back(db.names[k]);
1974 }
1975 first = t;
1976 }
1977 break;
1978 }
1979 case 'T':
1980 {
1981 size_t k0 = db.names.size();
1982 t = parse_template_param(first, last, db);
1983 size_t k1 = db.names.size();
1984 if (t != first)
1985 {
1986 db.subs.emplace_back(db.names.get_allocator());
1987 for (size_t k = k0; k < k1; ++k)
1988 db.subs.back().push_back(db.names[k]);
1989 if (db.try_to_parse_template_args && k1 == k0+1)
1990 {
1991 const char* t1 = parse_template_args(t, last, db);
1992 if (t1 != t)
1993 {
1994 auto args = db.names.back().move_full();
1995 db.names.pop_back();
1996 db.names.back().first += std::move(args);
1997 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
1998 t = t1;
1999 }
2000 }
2001 first = t;
2002 }
2003 break;
2004 }
2005 case 'U':
2006 if (first+1 != last)
2007 {
2008 t = parse_source_name(first+1, last, db);
2009 if (t != first+1)
2010 {
2011 const char* t2 = parse_type(t, last, db);
2012 if (t2 != t)
2013 {
2014 auto type = db.names.back().move_full();
2015 db.names.pop_back();
2016 if (db.names.back().first.substr(0, 9) != "objcproto")
2017 {
2018 db.names.back() = type + " " + db.names.back().move_full();
2019 }
2020 else
2021 {
2022 auto proto = db.names.back().move_full();
2023 db.names.pop_back();
2024 t = parse_source_name(proto.data() + 9, proto.data() + proto.size(), db);
2025 if (t != proto.data() + 9)
2026 {
2027 db.names.back() = type + "<" + db.names.back().move_full() + ">";
2028 }
2029 else
2030 {
2031 db.names.push_back(type + " " + proto);
2032 }
2033 }
2034 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2035 first = t2;
2036 }
2037 }
2038 }
2039 break;
2040 case 'S':
2041 if (first+1 != last && first[1] == 't')
2042 {
2043 t = parse_name(first, last, db);
2044 if (t != first)
2045 {
2046 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2047 first = t;
2048 }
2049 }
2050 else
2051 {
2052 t = parse_substitution(first, last, db);
2053 if (t != first)
2054 {
2055 first = t;
2056 // Parsed a substitution. If the substitution is a
2057 // <template-param> it might be followed by <template-args>.
2058 t = parse_template_args(first, last, db);
2059 if (t != first)
2060 {
2061 auto template_args = db.names.back().move_full();
2062 db.names.pop_back();
2063 db.names.back().first += template_args;
2064 // Need to create substitution for <template-template-param> <template-args>
2065 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2066 first = t;
2067 }
2068 }
2069 }
2070 break;
2071 case 'D':
2072 if (first+1 != last)
2073 {
2074 switch (first[1])
2075 {
2076 case 'p':
2077 {
2078 size_t k0 = db.names.size();
2079 t = parse_type(first+2, last, db);
2080 size_t k1 = db.names.size();
2081 if (t != first+2)
2082 {
2083 db.subs.emplace_back(db.names.get_allocator());
2084 for (size_t k = k0; k < k1; ++k)
2085 db.subs.back().push_back(db.names[k]);
2086 first = t;
2087 return first;
2088 }
2089 break;
2090 }
2091 case 't':
2092 case 'T':
2093 t = parse_decltype(first, last, db);
2094 if (t != first)
2095 {
2096 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2097 first = t;
2098 return first;
2099 }
2100 break;
2101 case 'v':
2102 t = parse_vector_type(first, last, db);
2103 if (t != first)
2104 {
2105 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2106 first = t;
2107 return first;
2108 }
2109 break;
2110 }
2111 }
2112 // drop through
2113 default:
2114 // must check for builtin-types before class-enum-types to avoid
2115 // ambiguities with operator-names
2116 t = parse_builtin_type(first, last, db);
2117 if (t != first)
2118 {
2119 first = t;
2120 }
2121 else
2122 {
2123 t = parse_name(first, last, db);
2124 if (t != first)
2125 {
2126 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
2127 first = t;
2128 }
2129 }
2130 break;
2131 }
2132 }
2133 break;
2134 }
2135 }
2136 }
2137 return first;
2138}
2139
2140// <operator-name>
2141// ::= aa # &&
2142// ::= ad # & (unary)
2143// ::= an # &
2144// ::= aN # &=
2145// ::= aS # =
2146// ::= cl # ()
2147// ::= cm # ,
2148// ::= co # ~
2149// ::= cv <type> # (cast)
2150// ::= da # delete[]
2151// ::= de # * (unary)
2152// ::= dl # delete
2153// ::= dv # /
2154// ::= dV # /=
2155// ::= eo # ^
2156// ::= eO # ^=
2157// ::= eq # ==
2158// ::= ge # >=
2159// ::= gt # >
2160// ::= ix # []
2161// ::= le # <=
2162// ::= ls # <<
2163// ::= lS # <<=
2164// ::= lt # <
2165// ::= mi # -
2166// ::= mI # -=
2167// ::= ml # *
2168// ::= mL # *=
2169// ::= mm # -- (postfix in <expression> context)
2170// ::= na # new[]
2171// ::= ne # !=
2172// ::= ng # - (unary)
2173// ::= nt # !
2174// ::= nw # new
2175// ::= oo # ||
2176// ::= or # |
2177// ::= oR # |=
2178// ::= pm # ->*
2179// ::= pl # +
2180// ::= pL # +=
2181// ::= pp # ++ (postfix in <expression> context)
2182// ::= ps # + (unary)
2183// ::= pt # ->
2184// ::= qu # ?
2185// ::= rm # %
2186// ::= rM # %=
2187// ::= rs # >>
2188// ::= rS # >>=
2189// ::= v <digit> <source-name> # vendor extended operator
2190
2191template <class C>
2192const char*
2193parse_operator_name(const char* first, const char* last, C& db)
2194{
2195 if (last - first >= 2)
2196 {
2197 switch (first[0])
2198 {
2199 case 'a':
2200 switch (first[1])
2201 {
2202 case 'a':
2203 db.names.push_back("operator&&");
2204 first += 2;
2205 break;
2206 case 'd':
2207 case 'n':
2208 db.names.push_back("operator&");
2209 first += 2;
2210 break;
2211 case 'N':
2212 db.names.push_back("operator&=");
2213 first += 2;
2214 break;
2215 case 'S':
2216 db.names.push_back("operator=");
2217 first += 2;
2218 break;
2219 }
2220 break;
2221 case 'c':
2222 switch (first[1])
2223 {
2224 case 'l':
2225 db.names.push_back("operator()");
2226 first += 2;
2227 break;
2228 case 'm':
2229 db.names.push_back("operator,");
2230 first += 2;
2231 break;
2232 case 'o':
2233 db.names.push_back("operator~");
2234 first += 2;
2235 break;
2236 case 'v':
2237 {
2238 bool try_to_parse_template_args = db.try_to_parse_template_args;
2239 db.try_to_parse_template_args = false;
2240 const char* t = parse_type(first+2, last, db);
2241 db.try_to_parse_template_args = try_to_parse_template_args;
2242 if (t != first+2)
2243 {
2244 db.names.back().first.insert(0, "operator ");
2245 db.parsed_ctor_dtor_cv = true;
2246 first = t;
2247 }
2248 }
2249 break;
2250 }
2251 break;
2252 case 'd':
2253 switch (first[1])
2254 {
2255 case 'a':
2256 db.names.push_back("operator delete[]");
2257 first += 2;
2258 break;
2259 case 'e':
2260 db.names.push_back("operator*");
2261 first += 2;
2262 break;
2263 case 'l':
2264 db.names.push_back("operator delete");
2265 first += 2;
2266 break;
2267 case 'v':
2268 db.names.push_back("operator/");
2269 first += 2;
2270 break;
2271 case 'V':
2272 db.names.push_back("operator/=");
2273 first += 2;
2274 break;
2275 }
2276 break;
2277 case 'e':
2278 switch (first[1])
2279 {
2280 case 'o':
2281 db.names.push_back("operator^");
2282 first += 2;
2283 break;
2284 case 'O':
2285 db.names.push_back("operator^=");
2286 first += 2;
2287 break;
2288 case 'q':
2289 db.names.push_back("operator==");
2290 first += 2;
2291 break;
2292 }
2293 break;
2294 case 'g':
2295 switch (first[1])
2296 {
2297 case 'e':
2298 db.names.push_back("operator>=");
2299 first += 2;
2300 break;
2301 case 't':
2302 db.names.push_back("operator>");
2303 first += 2;
2304 break;
2305 }
2306 break;
2307 case 'i':
2308 if (first[1] == 'x')
2309 {
2310 db.names.push_back("operator[]");
2311 first += 2;
2312 }
2313 break;
2314 case 'l':
2315 switch (first[1])
2316 {
2317 case 'e':
2318 db.names.push_back("operator<=");
2319 first += 2;
2320 break;
2321 case 's':
2322 db.names.push_back("operator<<");
2323 first += 2;
2324 break;
2325 case 'S':
2326 db.names.push_back("operator<<=");
2327 first += 2;
2328 break;
2329 case 't':
2330 db.names.push_back("operator<");
2331 first += 2;
2332 break;
2333 }
2334 break;
2335 case 'm':
2336 switch (first[1])
2337 {
2338 case 'i':
2339 db.names.push_back("operator-");
2340 first += 2;
2341 break;
2342 case 'I':
2343 db.names.push_back("operator-=");
2344 first += 2;
2345 break;
2346 case 'l':
2347 db.names.push_back("operator*");
2348 first += 2;
2349 break;
2350 case 'L':
2351 db.names.push_back("operator*=");
2352 first += 2;
2353 break;
2354 case 'm':
2355 db.names.push_back("operator--");
2356 first += 2;
2357 break;
2358 }
2359 break;
2360 case 'n':
2361 switch (first[1])
2362 {
2363 case 'a':
2364 db.names.push_back("operator new[]");
2365 first += 2;
2366 break;
2367 case 'e':
2368 db.names.push_back("operator!=");
2369 first += 2;
2370 break;
2371 case 'g':
2372 db.names.push_back("operator-");
2373 first += 2;
2374 break;
2375 case 't':
2376 db.names.push_back("operator!");
2377 first += 2;
2378 break;
2379 case 'w':
2380 db.names.push_back("operator new");
2381 first += 2;
2382 break;
2383 }
2384 break;
2385 case 'o':
2386 switch (first[1])
2387 {
2388 case 'o':
2389 db.names.push_back("operator||");
2390 first += 2;
2391 break;
2392 case 'r':
2393 db.names.push_back("operator|");
2394 first += 2;
2395 break;
2396 case 'R':
2397 db.names.push_back("operator|=");
2398 first += 2;
2399 break;
2400 }
2401 break;
2402 case 'p':
2403 switch (first[1])
2404 {
2405 case 'm':
2406 db.names.push_back("operator->*");
2407 first += 2;
2408 break;
2409 case 'l':
2410 db.names.push_back("operator+");
2411 first += 2;
2412 break;
2413 case 'L':
2414 db.names.push_back("operator+=");
2415 first += 2;
2416 break;
2417 case 'p':
2418 db.names.push_back("operator++");
2419 first += 2;
2420 break;
2421 case 's':
2422 db.names.push_back("operator+");
2423 first += 2;
2424 break;
2425 case 't':
2426 db.names.push_back("operator->");
2427 first += 2;
2428 break;
2429 }
2430 break;
2431 case 'q':
2432 if (first[1] == 'u')
2433 {
2434 db.names.push_back("operator?");
2435 first += 2;
2436 }
2437 break;
2438 case 'r':
2439 switch (first[1])
2440 {
2441 case 'm':
2442 db.names.push_back("operator%");
2443 first += 2;
2444 break;
2445 case 'M':
2446 db.names.push_back("operator%=");
2447 first += 2;
2448 break;
2449 case 's':
2450 db.names.push_back("operator>>");
2451 first += 2;
2452 break;
2453 case 'S':
2454 db.names.push_back("operator>>=");
2455 first += 2;
2456 break;
2457 }
2458 break;
2459 case 'v':
2460 if (std::isdigit(first[1]))
2461 {
2462 const char* t = parse_source_name(first+2, last, db);
2463 if (t != first+2)
2464 {
2465 db.names.back().first.insert(0, "operator ");
2466 first = t;
2467 }
2468 }
2469 break;
2470 }
2471 }
2472 return first;
2473}
2474
2475template <class C>
2476const char*
2477parse_integer_literal(const char* first, const char* last, const typename C::String& lit, C& db)
2478{
2479 const char* t = parse_number(first, last);
2480 if (t != first && t != last && *t == 'E')
2481 {
2482 if (lit.size() > 3)
2483 db.names.push_back("(" + lit + ")");
2484 else
2485 db.names.emplace_back();
2486 if (*first == 'n')
2487 {
2488 db.names.back().first += '-';
2489 ++first;
2490 }
2491 db.names.back().first.append(first, t);
2492 if (lit.size() <= 3)
2493 db.names.back().first += lit;
2494 first = t+1;
2495 }
2496 return first;
2497}
2498
2499// <expr-primary> ::= L <type> <value number> E # integer literal
2500// ::= L <type> <value float> E # floating literal
2501// ::= L <string type> E # string literal
2502// ::= L <nullptr type> E # nullptr literal (i.e., "LDnE")
2503// ::= L <type> <real-part float> _ <imag-part float> E # complex floating point literal (C 2000)
2504// ::= L <mangled-name> E # external name
2505
2506template <class C>
2507const char*
2508parse_expr_primary(const char* first, const char* last, C& db)
2509{
2510 if (last - first >= 4 && *first == 'L')
2511 {
2512 switch (first[1])
2513 {
2514 case 'w':
2515 {
2516 const char* t = parse_integer_literal(first+2, last, "wchar_t", db);
2517 if (t != first+2)
2518 first = t;
2519 }
2520 break;
2521 case 'b':
2522 if (first[3] == 'E')
2523 {
2524 switch (first[2])
2525 {
2526 case '0':
2527 db.names.push_back("false");
2528 first += 4;
2529 break;
2530 case '1':
2531 db.names.push_back("true");
2532 first += 4;
2533 break;
2534 }
2535 }
2536 break;
2537 case 'c':
2538 {
2539 const char* t = parse_integer_literal(first+2, last, "char", db);
2540 if (t != first+2)
2541 first = t;
2542 }
2543 break;
2544 case 'a':
2545 {
2546 const char* t = parse_integer_literal(first+2, last, "signed char", db);
2547 if (t != first+2)
2548 first = t;
2549 }
2550 break;
2551 case 'h':
2552 {
2553 const char* t = parse_integer_literal(first+2, last, "unsigned char", db);
2554 if (t != first+2)
2555 first = t;
2556 }
2557 break;
2558 case 's':
2559 {
2560 const char* t = parse_integer_literal(first+2, last, "short", db);
2561 if (t != first+2)
2562 first = t;
2563 }
2564 break;
2565 case 't':
2566 {
2567 const char* t = parse_integer_literal(first+2, last, "unsigned short", db);
2568 if (t != first+2)
2569 first = t;
2570 }
2571 break;
2572 case 'i':
2573 {
2574 const char* t = parse_integer_literal(first+2, last, "", db);
2575 if (t != first+2)
2576 first = t;
2577 }
2578 break;
2579 case 'j':
2580 {
2581 const char* t = parse_integer_literal(first+2, last, "u", db);
2582 if (t != first+2)
2583 first = t;
2584 }
2585 break;
2586 case 'l':
2587 {
2588 const char* t = parse_integer_literal(first+2, last, "l", db);
2589 if (t != first+2)
2590 first = t;
2591 }
2592 break;
2593 case 'm':
2594 {
2595 const char* t = parse_integer_literal(first+2, last, "ul", db);
2596 if (t != first+2)
2597 first = t;
2598 }
2599 break;
2600 case 'x':
2601 {
2602 const char* t = parse_integer_literal(first+2, last, "ll", db);
2603 if (t != first+2)
2604 first = t;
2605 }
2606 break;
2607 case 'y':
2608 {
2609 const char* t = parse_integer_literal(first+2, last, "ull", db);
2610 if (t != first+2)
2611 first = t;
2612 }
2613 break;
2614 case 'n':
2615 {
2616 const char* t = parse_integer_literal(first+2, last, "__int128", db);
2617 if (t != first+2)
2618 first = t;
2619 }
2620 break;
2621 case 'o':
2622 {
2623 const char* t = parse_integer_literal(first+2, last, "unsigned __int128", db);
2624 if (t != first+2)
2625 first = t;
2626 }
2627 break;
2628 case 'f':
2629 {
2630 const char* t = parse_floating_number<float>(first+2, last, db);
2631 if (t != first+2)
2632 first = t;
2633 }
2634 break;
2635 case 'd':
2636 {
2637 const char* t = parse_floating_number<double>(first+2, last, db);
2638 if (t != first+2)
2639 first = t;
2640 }
2641 break;
2642 case 'e':
2643 {
2644 const char* t = parse_floating_number<long double>(first+2, last, db);
2645 if (t != first+2)
2646 first = t;
2647 }
2648 break;
2649 case '_':
2650 if (first[2] == 'Z')
2651 {
2652 const char* t = parse_encoding(first+3, last, db);
2653 if (t != first+3 && t != last && *t == 'E')
2654 first = t+1;
2655 }
2656 break;
2657 case 'T':
2658 // Invalid mangled name per
2659 // http://sourcerytools.com/pipermail/cxx-abi-dev/2011-August/002422.html
2660 break;
2661 default:
2662 {
2663 // might be named type
2664 const char* t = parse_type(first+1, last, db);
2665 if (t != first+1 && t != last)
2666 {
2667 if (*t != 'E')
2668 {
2669 const char* n = t;
2670 for (; n != last && isdigit(*n); ++n)
2671 ;
2672 if (n != t && n != last && *n == 'E')
2673 {
2674 db.names.back() = "(" + db.names.back().move_full() + ")" + typename C::String(t, n);
2675 first = n+1;
2676 break;
2677 }
2678 }
2679 else
2680 {
2681 first = t+1;
2682 break;
2683 }
2684 }
2685 }
2686 }
2687 }
2688 return first;
2689}
2690
2691template <class String>
2692String
2693base_name(String& s)
2694{
2695 if (s.empty())
2696 return s;
2697 if (s == "std::string")
2698 {
2699 s = "std::basic_string<char, std::char_traits<char>, std::allocator<char> >";
2700 return "basic_string";
2701 }
2702 if (s == "std::istream")
2703 {
2704 s = "std::basic_istream<char, std::char_traits<char> >";
2705 return "basic_istream";
2706 }
2707 if (s == "std::ostream")
2708 {
2709 s = "std::basic_ostream<char, std::char_traits<char> >";
2710 return "basic_ostream";
2711 }
2712 if (s == "std::iostream")
2713 {
2714 s = "std::basic_iostream<char, std::char_traits<char> >";
2715 return "basic_iostream";
2716 }
2717 const char* const pf = s.data();
2718 const char* pe = pf + s.size();
2719 if (pe[-1] == '>')
2720 {
2721 unsigned c = 1;
2722 while (true)
2723 {
2724 if (--pe == pf)
2725 return String();
2726 if (pe[-1] == '<')
2727 {
2728 if (--c == 0)
2729 {
2730 --pe;
2731 break;
2732 }
2733 }
2734 else if (pe[-1] == '>')
2735 ++c;
2736 }
2737 }
2738 const char* p0 = pe - 1;
2739 for (; p0 != pf; --p0)
2740 {
2741 if (*p0 == ':')
2742 {
2743 ++p0;
2744 break;
2745 }
2746 }
2747 return String(p0, pe);
2748}
2749
2750// <ctor-dtor-name> ::= C1 # complete object constructor
2751// ::= C2 # base object constructor
2752// ::= C3 # complete object allocating constructor
2753// extension ::= C5 # ?
2754// ::= D0 # deleting destructor
2755// ::= D1 # complete object destructor
2756// ::= D2 # base object destructor
2757// extension ::= D5 # ?
2758
2759template <class C>
2760const char*
2761parse_ctor_dtor_name(const char* first, const char* last, C& db)
2762{
2763 if (last-first >= 2 && !db.names.empty())
2764 {
2765 switch (first[0])
2766 {
2767 case 'C':
2768 switch (first[1])
2769 {
2770 case '1':
2771 case '2':
2772 case '3':
2773 case '5':
2774 db.names.push_back(base_name(db.names.back().first));
2775 first += 2;
2776 db.parsed_ctor_dtor_cv = true;
2777 break;
2778 }
2779 break;
2780 case 'D':
2781 switch (first[1])
2782 {
2783 case '0':
2784 case '1':
2785 case '2':
2786 case '5':
2787 db.names.push_back("~" + base_name(db.names.back().first));
2788 first += 2;
2789 db.parsed_ctor_dtor_cv = true;
2790 break;
2791 }
2792 break;
2793 }
2794 }
2795 return first;
2796}
2797
2798// <unnamed-type-name> ::= Ut [ <nonnegative number> ] _
2799// ::= <closure-type-name>
2800//
2801// <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
2802//
2803// <lambda-sig> ::= <parameter type>+ # Parameter types or "v" if the lambda has no parameters
2804
2805template <class C>
2806const char*
2807parse_unnamed_type_name(const char* first, const char* last, C& db)
2808{
2809 if (last - first > 2 && first[0] == 'U')
2810 {
2811 char type = first[1];
2812 switch (type)
2813 {
2814 case 't':
2815 {
2816 db.names.push_back(typename C::String("'unnamed"));
2817 const char* t0 = first+2;
2818 if (t0 == last)
2819 {
2820 db.names.pop_back();
2821 return first;
2822 }
2823 if (std::isdigit(*t0))
2824 {
2825 const char* t1 = t0 + 1;
2826 while (t1 != last && std::isdigit(*t1))
2827 ++t1;
2828 db.names.back().first.append(t0, t1);
2829 t0 = t1;
2830 }
2831 db.names.back().first.push_back('\'');
2832 if (t0 == last || *t0 != '_')
2833 {
2834 db.names.pop_back();
2835 return first;
2836 }
2837 first = t0 + 1;
2838 }
2839 break;
2840 case 'l':
2841 {
2842 db.names.push_back(typename C::String("'lambda'("));
2843 const char* t0 = first+2;
2844 if (first[2] == 'v')
2845 {
2846 db.names.back().first += ')';
2847 ++t0;
2848 }
2849 else
2850 {
2851 const char* t1 = parse_type(t0, last, db);
2852 if (t1 == t0)
2853 {
2854 db.names.pop_back();
2855 return first;
2856 }
2857 auto tmp = db.names.back().move_full();
2858 db.names.pop_back();
2859 db.names.back().first.append(tmp);
2860 t0 = t1;
2861 while (true)
2862 {
2863 t1 = parse_type(t0, last, db);
2864 if (t1 == t0)
2865 break;
2866 tmp = db.names.back().move_full();
2867 db.names.pop_back();
2868 if (!tmp.empty())
2869 {
2870 db.names.back().first.append(", ");
2871 db.names.back().first.append(tmp);
2872 }
2873 t0 = t1;
2874 }
2875 db.names.back().first.append(")");
2876 }
2877 if (t0 == last || *t0 != 'E')
2878 {
2879 db.names.pop_back();
2880 return first;
2881 }
2882 ++t0;
2883 if (t0 == last)
2884 {
2885 db.names.pop_back();
2886 return first;
2887 }
2888 if (std::isdigit(*t0))
2889 {
2890 const char* t1 = t0 + 1;
2891 while (t1 != last && std::isdigit(*t1))
2892 ++t1;
2893 db.names.back().first.insert(db.names.back().first.begin()+7, t0, t1);
2894 t0 = t1;
2895 }
2896 if (t0 == last || *t0 != '_')
2897 {
2898 db.names.pop_back();
2899 return first;
2900 }
2901 first = t0 + 1;
2902 }
2903 break;
2904 }
2905 }
2906 return first;
2907}
2908
2909// <unqualified-name> ::= <operator-name>
2910// ::= <ctor-dtor-name>
2911// ::= <source-name>
2912// ::= <unnamed-type-name>
2913
2914template <class C>
2915const char*
2916parse_unqualified_name(const char* first, const char* last, C& db)
2917{
2918 if (first != last)
2919 {
2920 const char* t;
2921 switch (*first)
2922 {
2923 case 'C':
2924 case 'D':
2925 t = parse_ctor_dtor_name(first, last, db);
2926 if (t != first)
2927 first = t;
2928 break;
2929 case 'U':
2930 t = parse_unnamed_type_name(first, last, db);
2931 if (t != first)
2932 first = t;
2933 break;
2934 case '1':
2935 case '2':
2936 case '3':
2937 case '4':
2938 case '5':
2939 case '6':
2940 case '7':
2941 case '8':
2942 case '9':
2943 t = parse_source_name(first, last, db);
2944 if (t != first)
2945 first = t;
2946 break;
2947 default:
2948 t = parse_operator_name(first, last, db);
2949 if (t != first)
2950 first = t;
2951 break;
2952 };
2953 }
2954 return first;
2955}
2956
2957// <unscoped-name> ::= <unqualified-name>
2958// ::= St <unqualified-name> # ::std::
2959// extension ::= StL<unqualified-name>
2960
2961template <class C>
2962const char*
2963parse_unscoped_name(const char* first, const char* last, C& db)
2964{
2965 if (last - first >= 2)
2966 {
2967 const char* t0 = first;
2968 bool St = false;
2969 if (first[0] == 'S' && first[1] == 't')
2970 {
2971 t0 += 2;
2972 St = true;
2973 if (t0 != last && *t0 == 'L')
2974 ++t0;
2975 }
2976 const char* t1 = parse_unqualified_name(t0, last, db);
2977 if (t1 != t0)
2978 {
2979 if (St)
2980 db.names.back().first.insert(0, "std::");
2981 first = t1;
2982 }
2983 }
2984 return first;
2985}
2986
2987// at <type> # alignof (a type)
2988
2989template <class C>
2990const char*
2991parse_alignof_type(const char* first, const char* last, C& db)
2992{
2993 if (last - first >= 3 && first[0] == 'a' && first[1] == 't')
2994 {
2995 const char* t = parse_type(first+2, last, db);
2996 if (t != first+2)
2997 {
2998 db.names.back().first = "alignof (" + db.names.back().move_full() + ")";
2999 first = t;
3000 }
3001 }
3002 return first;
3003}
3004
3005// az <expression> # alignof (a expression)
3006
3007template <class C>
3008const char*
3009parse_alignof_expr(const char* first, const char* last, C& db)
3010{
3011 if (last - first >= 3 && first[0] == 'a' && first[1] == 'z')
3012 {
3013 const char* t = parse_expression(first+2, last, db);
3014 if (t != first+2)
3015 {
3016 db.names.back().first = "alignof (" + db.names.back().move_full() + ")";
3017 first = t;
3018 }
3019 }
3020 return first;
3021}
3022
3023template <class C>
3024const char*
3025parse_noexcept_expression(const char* first, const char* last, C& db)
3026{
3027 const char* t1 = parse_expression(first, last, db);
3028 if (t1 != first)
3029 {
3030 db.names.back().first = "noexcept (" + db.names.back().move_full() + ")";
3031 first = t1;
3032 }
3033 return first;
3034}
3035
3036template <class C>
3037const char*
3038parse_prefix_expression(const char* first, const char* last, const typename C::String& op, C& db)
3039{
3040 const char* t1 = parse_expression(first, last, db);
3041 if (t1 != first)
3042 {
3043 db.names.back().first = op + "(" + db.names.back().move_full() + ")";
3044 first = t1;
3045 }
3046 return first;
3047}
3048
3049template <class C>
3050const char*
3051parse_binary_expression(const char* first, const char* last, const typename C::String& op, C& db)
3052{
3053 const char* t1 = parse_expression(first, last, db);
3054 if (t1 != first)
3055 {
3056 const char* t2 = parse_expression(t1, last, db);
3057 if (t2 != t1)
3058 {
3059 auto op2 = db.names.back().move_full();
3060 db.names.pop_back();
3061 auto op1 = db.names.back().move_full();
3062 auto& nm = db.names.back().first;
3063 nm.clear();
3064 if (op == ">")
3065 nm += '(';
3066 nm += "(" + op1 + ") " + op + " (" + op2 + ")";
3067 if (op == ">")
3068 nm += ')';
3069 first = t2;
3070 }
3071 else
3072 db.names.pop_back();
3073 }
3074 return first;
3075}
3076
3077// <expression> ::= <unary operator-name> <expression>
3078// ::= <binary operator-name> <expression> <expression>
3079// ::= <ternary operator-name> <expression> <expression> <expression>
3080// ::= cl <expression>+ E # call
3081// ::= cv <type> <expression> # conversion with one argument
3082// ::= cv <type> _ <expression>* E # conversion with a different number of arguments
3083// ::= [gs] nw <expression>* _ <type> E # new (expr-list) type
3084// ::= [gs] nw <expression>* _ <type> <initializer> # new (expr-list) type (init)
3085// ::= [gs] na <expression>* _ <type> E # new[] (expr-list) type
3086// ::= [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type (init)
3087// ::= [gs] dl <expression> # delete expression
3088// ::= [gs] da <expression> # delete[] expression
3089// ::= pp_ <expression> # prefix ++
3090// ::= mm_ <expression> # prefix --
3091// ::= ti <type> # typeid (type)
3092// ::= te <expression> # typeid (expression)
3093// ::= dc <type> <expression> # dynamic_cast<type> (expression)
3094// ::= sc <type> <expression> # static_cast<type> (expression)
3095// ::= cc <type> <expression> # const_cast<type> (expression)
3096// ::= rc <type> <expression> # reinterpret_cast<type> (expression)
3097// ::= st <type> # sizeof (a type)
3098// ::= sz <expression> # sizeof (an expression)
3099// ::= at <type> # alignof (a type)
3100// ::= az <expression> # alignof (an expression)
3101// ::= nx <expression> # noexcept (expression)
3102// ::= <template-param>
3103// ::= <function-param>
3104// ::= dt <expression> <unresolved-name> # expr.name
3105// ::= pt <expression> <unresolved-name> # expr->name
3106// ::= ds <expression> <expression> # expr.*expr
3107// ::= sZ <template-param> # size of a parameter pack
3108// ::= sZ <function-param> # size of a function parameter pack
3109// ::= sp <expression> # pack expansion
3110// ::= tw <expression> # throw expression
3111// ::= tr # throw with no operand (rethrow)
3112// ::= <unresolved-name> # f(p), N::f(p), ::f(p),
3113// # freestanding dependent name (e.g., T::x),
3114// # objectless nonstatic member reference
3115// ::= <expr-primary>
3116
3117template <class C>
3118const char*
3119parse_expression(const char* first, const char* last, C& db)
3120{
3121 if (last - first >= 2)
3122 {
3123 const char* t = first;
3124 bool parsed_gs = false;
3125 if (last - first >= 4 && t[0] == 'g' && t[1] == 's')
3126 {
3127 t += 2;
3128 parsed_gs = true;
3129 }
3130 switch (*t)
3131 {
3132 case 'L':
3133 first = parse_expr_primary(first, last, db);
3134 break;
3135 case 'T':
3136 first = parse_template_param(first, last, db);
3137 break;
3138 case 'f':
3139 first = parse_function_param(first, last, db);
3140 break;
3141 case 'a':
3142 switch (t[1])
3143 {
3144 case 'a':
3145 t = parse_binary_expression(first+2, last, "&&", db);
3146 if (t != first+2)
3147 first = t;
3148 break;
3149 case 'd':
3150 t = parse_prefix_expression(first+2, last, "&", db);
3151 if (t != first+2)
3152 first = t;
3153 break;
3154 case 'n':
3155 t = parse_binary_expression(first+2, last, "&", db);
3156 if (t != first+2)
3157 first = t;
3158 break;
3159 case 'N':
3160 t = parse_binary_expression(first+2, last, "&=", db);
3161 if (t != first+2)
3162 first = t;
3163 break;
3164 case 'S':
3165 t = parse_binary_expression(first+2, last, "=", db);
3166 if (t != first+2)
3167 first = t;
3168 break;
3169 case 't':
3170 first = parse_alignof_type(first, last, db);
3171 break;
3172 case 'z':
3173 first = parse_alignof_expr(first, last, db);
3174 break;
3175 }
3176 break;
3177 case 'c':
3178 switch (t[1])
3179 {
3180 case 'c':
3181 first = parse_const_cast_expr(first, last, db);
3182 break;
3183 case 'l':
3184 first = parse_call_expr(first, last, db);
3185 break;
3186 case 'm':
3187 t = parse_binary_expression(first+2, last, ",", db);
3188 if (t != first+2)
3189 first = t;
3190 break;
3191 case 'o':
3192 t = parse_prefix_expression(first+2, last, "~", db);
3193 if (t != first+2)
3194 first = t;
3195 break;
3196 case 'v':
3197 first = parse_conversion_expr(first, last, db);
3198 break;
3199 }
3200 break;
3201 case 'd':
3202 switch (t[1])
3203 {
3204 case 'a':
3205 {
3206 const char* t1 = parse_expression(t+2, last, db);
3207 if (t1 != t+2)
3208 {
3209 db.names.back().first = (parsed_gs ? typename C::String("::") : typename C::String()) +
3210 "delete[] " + db.names.back().move_full();
3211 first = t1;
3212 }
3213 }
3214 break;
3215 case 'c':
3216 first = parse_dynamic_cast_expr(first, last, db);
3217 break;
3218 case 'e':
3219 t = parse_prefix_expression(first+2, last, "*", db);
3220 if (t != first+2)
3221 first = t;
3222 break;
3223 case 'l':
3224 {
3225 const char* t1 = parse_expression(t+2, last, db);
3226 if (t1 != t+2)
3227 {
3228 db.names.back().first = (parsed_gs ? typename C::String("::") : typename C::String()) +
3229 "delete " + db.names.back().move_full();
3230 first = t1;
3231 }
3232 }
3233 break;
3234 case 'n':
3235 return parse_unresolved_name(first, last, db);
3236 case 's':
3237 first = parse_dot_star_expr(first, last, db);
3238 break;
3239 case 't':
3240 first = parse_dot_expr(first, last, db);
3241 break;
3242 case 'v':
3243 t = parse_binary_expression(first+2, last, "/", db);
3244 if (t != first+2)
3245 first = t;
3246 break;
3247 case 'V':
3248 t = parse_binary_expression(first+2, last, "/=", db);
3249 if (t != first+2)
3250 first = t;
3251 break;
3252 }
3253 break;
3254 case 'e':
3255 switch (t[1])
3256 {
3257 case 'o':
3258 t = parse_binary_expression(first+2, last, "^", db);
3259 if (t != first+2)
3260 first = t;
3261 break;
3262 case 'O':
3263 t = parse_binary_expression(first+2, last, "^=", db);
3264 if (t != first+2)
3265 first = t;
3266 break;
3267 case 'q':
3268 t = parse_binary_expression(first+2, last, "==", db);
3269 if (t != first+2)
3270 first = t;
3271 break;
3272 }
3273 break;
3274 case 'g':
3275 switch (t[1])
3276 {
3277 case 'e':
3278 t = parse_binary_expression(first+2, last, ">=", db);
3279 if (t != first+2)
3280 first = t;
3281 break;
3282 case 't':
3283 t = parse_binary_expression(first+2, last, ">", db);
3284 if (t != first+2)
3285 first = t;
3286 break;
3287 }
3288 break;
3289 case 'i':
3290 if (t[1] == 'x')
3291 {
3292 const char* t1 = parse_expression(first+2, last, db);
3293 if (t1 != first+2)
3294 {
3295 const char* t2 = parse_expression(t1, last, db);
3296 if (t2 != t1)
3297 {
3298 auto op2 = db.names.back().move_full();
3299 db.names.pop_back();
3300 auto op1 = db.names.back().move_full();
3301 db.names.back() = "(" + op1 + ")[" + op2 + "]";
3302 first = t2;
3303 }
3304 else
3305 db.names.pop_back();
3306 }
3307 }
3308 break;
3309 case 'l':
3310 switch (t[1])
3311 {
3312 case 'e':
3313 t = parse_binary_expression(first+2, last, "<=", db);
3314 if (t != first+2)
3315 first = t;
3316 break;
3317 case 's':
3318 t = parse_binary_expression(first+2, last, "<<", db);
3319 if (t != first+2)
3320 first = t;
3321 break;
3322 case 'S':
3323 t = parse_binary_expression(first+2, last, "<<=", db);
3324 if (t != first+2)
3325 first = t;
3326 break;
3327 case 't':
3328 t = parse_binary_expression(first+2, last, "<", db);
3329 if (t != first+2)
3330 first = t;
3331 break;
3332 }
3333 break;
3334 case 'm':
3335 switch (t[1])
3336 {
3337 case 'i':
3338 t = parse_binary_expression(first+2, last, "-", db);
3339 if (t != first+2)
3340 first = t;
3341 break;
3342 case 'I':
3343 t = parse_binary_expression(first+2, last, "-=", db);
3344 if (t != first+2)
3345 first = t;
3346 break;
3347 case 'l':
3348 t = parse_binary_expression(first+2, last, "*", db);
3349 if (t != first+2)
3350 first = t;
3351 break;
3352 case 'L':
3353 t = parse_binary_expression(first+2, last, "*=", db);
3354 if (t != first+2)
3355 first = t;
3356 break;
3357 case 'm':
3358 if (first+2 != last && first[2] == '_')
3359 {
3360 t = parse_prefix_expression(first+3, last, "--", db);
3361 if (t != first+3)
3362 first = t;
3363 }
3364 else
3365 {
3366 const char* t1 = parse_expression(first+2, last, db);
3367 if (t1 != first+2)
3368 {
3369 db.names.back() = "(" + db.names.back().move_full() + ")--";
3370 first = t1;
3371 }
3372 }
3373 break;
3374 }
3375 break;
3376 case 'n':
3377 switch (t[1])
3378 {
3379 case 'a':
3380 case 'w':
3381 first = parse_new_expr(first, last, db);
3382 break;
3383 case 'e':
3384 t = parse_binary_expression(first+2, last, "!=", db);
3385 if (t != first+2)
3386 first = t;
3387 break;
3388 case 'g':
3389 t = parse_prefix_expression(first+2, last, "-", db);
3390 if (t != first+2)
3391 first = t;
3392 break;
3393 case 't':
3394 t = parse_prefix_expression(first+2, last, "!", db);
3395 if (t != first+2)
3396 first = t;
3397 break;
3398 case 'x':
3399 t = parse_noexcept_expression(first+2, last, db);
3400 if (t != first+2)
3401 first = t;
3402 break;
3403 }
3404 break;
3405 case 'o':
3406 switch (t[1])
3407 {
3408 case 'n':
3409 return parse_unresolved_name(first, last, db);
3410 case 'o':
3411 t = parse_binary_expression(first+2, last, "||", db);
3412 if (t != first+2)
3413 first = t;
3414 break;
3415 case 'r':
3416 t = parse_binary_expression(first+2, last, "|", db);
3417 if (t != first+2)
3418 first = t;
3419 break;
3420 case 'R':
3421 t = parse_binary_expression(first+2, last, "|=", db);
3422 if (t != first+2)
3423 first = t;
3424 break;
3425 }
3426 break;
3427 case 'p':
3428 switch (t[1])
3429 {
3430 case 'm':
3431 t = parse_binary_expression(first+2, last, "->*", db);
3432 if (t != first+2)
3433 first = t;
3434 break;
3435 case 'l':
3436 t = parse_binary_expression(first+2, last, "+", db);
3437 if (t != first+2)
3438 first = t;
3439 break;
3440 case 'L':
3441 t = parse_binary_expression(first+2, last, "+=", db);
3442 if (t != first+2)
3443 first = t;
3444 break;
3445 case 'p':
3446 if (first+2 != last && first[2] == '_')
3447 {
3448 t = parse_prefix_expression(first+3, last, "++", db);
3449 if (t != first+3)
3450 first = t;
3451 }
3452 else
3453 {
3454 const char* t1 = parse_expression(first+2, last, db);
3455 if (t1 != first+2)
3456 {
3457 db.names.back() = "(" + db.names.back().move_full() + ")++";
3458 first = t1;
3459 }
3460 }
3461 break;
3462 case 's':
3463 t = parse_prefix_expression(first+2, last, "+", db);
3464 if (t != first+2)
3465 first = t;
3466 break;
3467 case 't':
3468 first = parse_arrow_expr(first, last, db);
3469 break;
3470 }
3471 break;
3472 case 'q':
3473 if (t[1] == 'u')
3474 {
3475 const char* t1 = parse_expression(first+2, last, db);
3476 if (t1 != first+2)
3477 {
3478 const char* t2 = parse_expression(t1, last, db);
3479 if (t2 != t1)
3480 {
3481 const char* t3 = parse_expression(t2, last, db);
3482 if (t3 != t2)
3483 {
3484 auto op3 = db.names.back().move_full();
3485 db.names.pop_back();
3486 auto op2 = db.names.back().move_full();
3487 db.names.pop_back();
3488 auto op1 = db.names.back().move_full();
3489 db.names.back() = "(" + op1 + ") ? (" + op2 + ") : (" + op3 + ")";
3490 first = t3;
3491 }
3492 else
3493 {
3494 db.names.pop_back();
3495 db.names.pop_back();
3496 }
3497 }
3498 else
3499 db.names.pop_back();
3500 }
3501 }
3502 break;
3503 case 'r':
3504 switch (t[1])
3505 {
3506 case 'c':
3507 first = parse_reinterpret_cast_expr(first, last, db);
3508 break;
3509 case 'm':
3510 t = parse_binary_expression(first+2, last, "%", db);
3511 if (t != first+2)
3512 first = t;
3513 break;
3514 case 'M':
3515 t = parse_binary_expression(first+2, last, "%=", db);
3516 if (t != first+2)
3517 first = t;
3518 break;
3519 case 's':
3520 t = parse_binary_expression(first+2, last, ">>", db);
3521 if (t != first+2)
3522 first = t;
3523 break;
3524 case 'S':
3525 t = parse_binary_expression(first+2, last, ">>=", db);
3526 if (t != first+2)
3527 first = t;
3528 break;
3529 }
3530 break;
3531 case 's':
3532 switch (t[1])
3533 {
3534 case 'c':
3535 first = parse_static_cast_expr(first, last, db);
3536 break;
3537 case 'p':
3538 first = parse_pack_expansion(first, last, db);
3539 break;
3540 case 'r':
3541 return parse_unresolved_name(first, last, db);
3542 case 't':
3543 first = parse_sizeof_type_expr(first, last, db);
3544 break;
3545 case 'z':
3546 first = parse_sizeof_expr_expr(first, last, db);
3547 break;
3548 case 'Z':
3549 if (last - t >= 3)
3550 {
3551 switch (t[2])
3552 {
3553 case 'T':
3554 first = parse_sizeof_param_pack_expr(first, last, db);
3555 break;
3556 case 'f':
3557 first = parse_sizeof_function_param_pack_expr(first, last, db);
3558 break;
3559 }
3560 }
3561 break;
3562 }
3563 break;
3564 case 't':
3565 switch (t[1])
3566 {
3567 case 'e':
3568 case 'i':
3569 first = parse_typeid_expr(first, last, db);
3570 break;
3571 case 'r':
3572 db.names.push_back("throw");
3573 first += 2;
3574 break;
3575 case 'w':
3576 first = parse_throw_expr(first, last, db);
3577 break;
3578 }
3579 break;
3580 case '1':
3581 case '2':
3582 case '3':
3583 case '4':
3584 case '5':
3585 case '6':
3586 case '7':
3587 case '8':
3588 case '9':
3589 return parse_unresolved_name(first, last, db);
3590 }
3591 }
3592 return first;
3593}
3594
3595// <template-arg> ::= <type> # type or template
3596// ::= X <expression> E # expression
3597// ::= <expr-primary> # simple expressions
3598// ::= J <template-arg>* E # argument pack
3599// ::= LZ <encoding> E # extension
3600
3601template <class C>
3602const char*
3603parse_template_arg(const char* first, const char* last, C& db)
3604{
3605 if (first != last)
3606 {
3607 const char* t;
3608 switch (*first)
3609 {
3610 case 'X':
3611 t = parse_expression(first+1, last, db);
3612 if (t != first+1)
3613 {
3614 if (t != last && *t == 'E')
3615 first = t+1;
3616 }
3617 break;
3618 case 'J':
3619 t = first+1;
3620 if (t == last)
3621 return first;
3622 while (*t != 'E')
3623 {
3624 const char* t1 = parse_template_arg(t, last, db);
3625 if (t1 == t)
3626 return first;
3627 t = t1;
3628 }
3629 first = t+1;
3630 break;
3631 case 'L':
3632 // <expr-primary> or LZ <encoding> E
3633 if (first+1 != last && first[1] == 'Z')
3634 {
3635 t = parse_encoding(first+2, last, db);
3636 if (t != first+2 && t != last && *t == 'E')
3637 first = t+1;
3638 }
3639 else
3640 first = parse_expr_primary(first, last, db);
3641 break;
3642 default:
3643 // <type>
3644 first = parse_type(first, last, db);
3645 break;
3646 }
3647 }
3648 return first;
3649}
3650
3651// <template-args> ::= I <template-arg>* E
3652// extension, the abi says <template-arg>+
3653
3654template <class C>
3655const char*
3656parse_template_args(const char* first, const char* last, C& db)
3657{
3658 if (last - first >= 2 && *first == 'I')
3659 {
3660 if (db.tag_templates)
3661 db.template_param.back().clear();
3662 const char* t = first+1;
3663 typename C::String args("<");
3664 while (*t != 'E')
3665 {
3666 if (db.tag_templates)
3667 db.template_param.emplace_back(db.names.get_allocator());
3668 size_t k0 = db.names.size();
3669 const char* t1 = parse_template_arg(t, last, db);
3670 size_t k1 = db.names.size();
3671 if (db.tag_templates)
3672 db.template_param.pop_back();
3673 if (t1 == t || t1 == last)
3674 return first;
3675 if (db.tag_templates)
3676 {
3677 db.template_param.back().emplace_back(db.names.get_allocator());
3678 for (size_t k = k0; k < k1; ++k)
3679 db.template_param.back().back().push_back(db.names[k]);
3680 }
3681 for (size_t k = k0; k < k1; ++k)
3682 {
3683 if (args.size() > 1)
3684 args += ", ";
3685 args += db.names[k].move_full();
3686 }
3687 for (; k1 != k0; --k1)
3688 db.names.pop_back();
3689 t = t1;
3690 }
3691 first = t + 1;
3692 if (args.back() != '>')
3693 args += ">";
3694 else
3695 args += " >";
3696 db.names.push_back(std::move(args));
3697
3698 }
3699 return first;
3700}
3701
3702// <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
3703// ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
3704//
3705// <prefix> ::= <prefix> <unqualified-name>
3706// ::= <template-prefix> <template-args>
3707// ::= <template-param>
3708// ::= <decltype>
3709// ::= # empty
3710// ::= <substitution>
3711// ::= <prefix> <data-member-prefix>
3712// extension ::= L
3713//
3714// <template-prefix> ::= <prefix> <template unqualified-name>
3715// ::= <template-param>
3716// ::= <substitution>
3717
3718template <class C>
3719const char*
3720parse_nested_name(const char* first, const char* last, C& db)
3721{
3722 if (first != last && *first == 'N')
3723 {
3724 unsigned cv;
3725 const char* t0 = parse_cv_qualifiers(first+1, last, cv);
3726 if (t0 == last)
3727 return first;
3728 db.ref = 0;
3729 if (*t0 == 'R')
3730 {
3731 db.ref = 1;
3732 ++t0;
3733 }
3734 else if (*t0 == 'O')
3735 {
3736 db.ref = 2;
3737 ++t0;
3738 }
3739 db.names.emplace_back();
3740 if (last - t0 >= 2 && t0[0] == 'S' && t0[1] == 't')
3741 {
3742 t0 += 2;
3743 db.names.back().first = "std";
3744 }
3745 if (t0 == last)
3746 {
3747 db.names.pop_back();
3748 return first;
3749 }
3750 bool pop_subs = false;
3751 while (*t0 != 'E')
3752 {
3753 const char* t1;
3754 switch (*t0)
3755 {
3756 case 'S':
3757 if (t0 + 1 != last && t0[1] == 't')
3758 goto do_parse_unqualified_name;
3759 t1 = parse_substitution(t0, last, db);
3760 if (t1 != t0 && t1 != last)
3761 {
3762 auto name = db.names.back().move_full();
3763 db.names.pop_back();
3764 if (!db.names.back().first.empty())
3765 {
3766 db.names.back().first += "::" + name;
3767 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
3768 }
3769 else
3770 db.names.back().first = name;
3771 pop_subs = true;
3772 t0 = t1;
3773 }
3774 else
3775 return first;
3776 break;
3777 case 'T':
3778 t1 = parse_template_param(t0, last, db);
3779 if (t1 != t0 && t1 != last)
3780 {
3781 auto name = db.names.back().move_full();
3782 db.names.pop_back();
3783 if (!db.names.back().first.empty())
3784 db.names.back().first += "::" + name;
3785 else
3786 db.names.back().first = name;
3787 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
3788 pop_subs = true;
3789 t0 = t1;
3790 }
3791 else
3792 return first;
3793 break;
3794 case 'D':
3795 if (t0 + 1 != last && t0[1] != 't' && t0[1] != 'T')
3796 goto do_parse_unqualified_name;
3797 t1 = parse_decltype(t0, last, db);
3798 if (t1 != t0 && t1 != last)
3799 {
3800 auto name = db.names.back().move_full();
3801 db.names.pop_back();
3802 if (!db.names.back().first.empty())
3803 db.names.back().first += "::" + name;
3804 else
3805 db.names.back().first = name;
3806 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
3807 pop_subs = true;
3808 t0 = t1;
3809 }
3810 else
3811 return first;
3812 break;
3813 case 'I':
3814 t1 = parse_template_args(t0, last, db);
3815 if (t1 != t0 && t1 != last)
3816 {
3817 auto name = db.names.back().move_full();
3818 db.names.pop_back();
3819 db.names.back().first += name;
3820 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
3821 t0 = t1;
3822 }
3823 else
3824 return first;
3825 break;
3826 case 'L':
3827 if (++t0 == last)
3828 return first;
3829 break;
3830 default:
3831 do_parse_unqualified_name:
3832 t1 = parse_unqualified_name(t0, last, db);
3833 if (t1 != t0 && t1 != last)
3834 {
3835 auto name = db.names.back().move_full();
3836 db.names.pop_back();
3837 if (!db.names.back().first.empty())
3838 db.names.back().first += "::" + name;
3839 else
3840 db.names.back().first = name;
3841 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
3842 pop_subs = true;
3843 t0 = t1;
3844 }
3845 else
3846 return first;
3847 }
3848 }
3849 first = t0 + 1;
3850 db.cv = cv;
3851 if (pop_subs && !db.subs.empty())
3852 db.subs.pop_back();
3853 }
3854 return first;
3855}
3856
3857// <discriminator> := _ <non-negative number> # when number < 10
3858// := __ <non-negative number> _ # when number >= 10
3859// extension := decimal-digit+
3860
3861const char*
3862parse_discriminator(const char* first, const char* last)
3863{
3864 // parse but ignore discriminator
3865 if (first != last)
3866 {
3867 if (*first == '_')
3868 {
3869 const char* t1 = first+1;
3870 if (t1 != last)
3871 {
3872 if (std::isdigit(*t1))
3873 first = t1+1;
3874 else if (*t1 == '_')
3875 {
3876 for (++t1; t1 != last && std::isdigit(*t1); ++t1)
3877 ;
3878 if (t1 != last && *t1 == '_')
3879 first = t1 + 1;
3880 }
3881 }
3882 }
3883 else if (std::isdigit(*first))
3884 {
3885 const char* t1 = first+1;
3886 for (; t1 != last && std::isdigit(*t1); ++t1)
3887 ;
3888 first = t1;
3889 }
3890 }
3891 return first;
3892}
3893
3894// <local-name> := Z <function encoding> E <entity name> [<discriminator>]
3895// := Z <function encoding> E s [<discriminator>]
3896// := Z <function encoding> Ed [ <parameter number> ] _ <entity name>
3897
3898template <class C>
3899const char*
3900parse_local_name(const char* first, const char* last, C& db)
3901{
3902 if (first != last && *first == 'Z')
3903 {
3904 const char* t = parse_encoding(first+1, last, db);
3905 if (t != first+1 && t != last && *t == 'E' && ++t != last)
3906 {
3907 switch (*t)
3908 {
3909 case 's':
3910 first = parse_discriminator(t+1, last);
3911 db.names.back().first.append("::string literal");
3912 break;
3913 case 'd':
3914 if (++t != last)
3915 {
3916 const char* t1 = parse_number(t, last);
3917 if (t1 != last && *t1 == '_')
3918 {
3919 t = t1 + 1;
3920 t1 = parse_name(t, last, db);
3921 if (t1 != t)
3922 {
3923 auto name = db.names.back().move_full();
3924 db.names.pop_back();
3925 db.names.back().first.append("::");
3926 db.names.back().first.append(name);
3927 first = t1;
3928 }
3929 else
3930 db.names.pop_back();
3931 }
3932 }
3933 break;
3934 default:
3935 {
3936 const char* t1 = parse_name(t, last, db);
3937 if (t1 != t)
3938 {
3939 // parse but ignore discriminator
3940 first = parse_discriminator(t1, last);
3941 auto name = db.names.back().move_full();
3942 db.names.pop_back();
3943 db.names.back().first.append("::");
3944 db.names.back().first.append(name);
3945 }
3946 else
3947 db.names.pop_back();
3948 }
3949 break;
3950 }
3951 }
3952 }
3953 return first;
3954}
3955
3956// <name> ::= <nested-name> // N
3957// ::= <local-name> # See Scope Encoding below // Z
3958// ::= <unscoped-template-name> <template-args>
3959// ::= <unscoped-name>
3960
3961// <unscoped-template-name> ::= <unscoped-name>
3962// ::= <substitution>
3963
3964template <class C>
3965const char*
3966parse_name(const char* first, const char* last, C& db)
3967{
3968 if (last - first >= 2)
3969 {
3970 const char* t0 = first;
3971 // extension: ignore L here
3972 if (*t0 == 'L')
3973 ++t0;
3974 switch (*t0)
3975 {
3976 case 'N':
3977 {
3978 const char* t1 = parse_nested_name(t0, last, db);
3979 if (t1 != t0)
3980 first = t1;
3981 break;
3982 }
3983 case 'Z':
3984 {
3985 const char* t1 = parse_local_name(t0, last, db);
3986 if (t1 != t0)
3987 first = t1;
3988 break;
3989 }
3990 default:
3991 {
3992 const char* t1 = parse_unscoped_name(t0, last, db);
3993 if (t1 != t0)
3994 {
3995 if (t1 != last && *t1 == 'I') // <unscoped-template-name> <template-args>
3996 {
3997 db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
3998 t0 = t1;
3999 t1 = parse_template_args(t0, last, db);
4000 if (t1 != t0)
4001 {
4002 auto tmp = db.names.back().move_full();
4003 db.names.pop_back();
4004 db.names.back().first += tmp;
4005 first = t1;
4006 }
4007 }
4008 else // <unscoped-name>
4009 first = t1;
4010 }
4011 else
4012 { // try <substitution> <template-args>
4013 t1 = parse_substitution(t0, last, db);
4014 if (t1 != t0 && t1 != last && *t1 == 'I')
4015 {
4016 t0 = t1;
4017 t1 = parse_template_args(t0, last, db);
4018 if (t1 != t0)
4019 {
4020 auto tmp = db.names.back().move_full();
4021 db.names.pop_back();
4022 db.names.back().first += tmp;
4023 first = t1;
4024 }
4025 }
4026 }
4027 break;
4028 }
4029 }
4030 }
4031 return first;
4032}
4033
4034// <call-offset> ::= h <nv-offset> _
4035// ::= v <v-offset> _
4036//
4037// <nv-offset> ::= <offset number>
4038// # non-virtual base override
4039//
4040// <v-offset> ::= <offset number> _ <virtual offset number>
4041// # virtual base override, with vcall offset
4042
4043const char*
4044parse_call_offset(const char* first, const char* last)
4045{
4046 if (first != last)
4047 {
4048 switch (*first)
4049 {
4050 case 'h':
4051 {
4052 const char* t = parse_number(first + 1, last);
4053 if (t != first + 1 && t != last && *t == '_')
4054 first = t + 1;
4055 }
4056 break;
4057 case 'v':
4058 {
4059 const char* t = parse_number(first + 1, last);
4060 if (t != first + 1 && t != last && *t == '_')
4061 {
4062 const char* t2 = parse_number(++t, last);
4063 if (t2 != t && t2 != last && *t2 == '_')
4064 first = t2 + 1;
4065 }
4066 }
4067 break;
4068 }
4069 }
4070 return first;
4071}
4072
4073// <special-name> ::= TV <type> # virtual table
4074// ::= TT <type> # VTT structure (construction vtable index)
4075// ::= TI <type> # typeinfo structure
4076// ::= TS <type> # typeinfo name (null-terminated byte string)
4077// ::= Tc <call-offset> <call-offset> <base encoding>
4078// # base is the nominal target function of thunk
4079// # first call-offset is 'this' adjustment
4080// # second call-offset is result adjustment
4081// ::= T <call-offset> <base encoding>
4082// # base is the nominal target function of thunk
4083// ::= GV <object name> # Guard variable for one-time initialization
4084// # No <type>
4085// extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first
4086// extension ::= GR <object name> # reference temporary for object
4087
4088template <class C>
4089const char*
4090parse_special_name(const char* first, const char* last, C& db)
4091{
4092 if (last - first > 2)
4093 {
4094 const char* t;
4095 switch (*first)
4096 {
4097 case 'T':
4098 switch (first[1])
4099 {
4100 case 'V':
4101 // TV <type> # virtual table
4102 t = parse_type(first+2, last, db);
4103 if (t != first+2)
4104 {
4105 db.names.back().first.insert(0, "vtable for ");
4106 first = t;
4107 }
4108 break;
4109 case 'T':
4110 // TT <type> # VTT structure (construction vtable index)
4111 t = parse_type(first+2, last, db);
4112 if (t != first+2)
4113 {
4114 db.names.back().first.insert(0, "VTT for ");
4115 first = t;
4116 }
4117 break;
4118 case 'I':
4119 // TI <type> # typeinfo structure
4120 t = parse_type(first+2, last, db);
4121 if (t != first+2)
4122 {
4123 db.names.back().first.insert(0, "typeinfo for ");
4124 first = t;
4125 }
4126 break;
4127 case 'S':
4128 // TS <type> # typeinfo name (null-terminated byte string)
4129 t = parse_type(first+2, last, db);
4130 if (t != first+2)
4131 {
4132 db.names.back().first.insert(0, "typeinfo name for ");
4133 first = t;
4134 }
4135 break;
4136 case 'c':
4137 // Tc <call-offset> <call-offset> <base encoding>
4138 {
4139 const char* t0 = parse_call_offset(first+2, last);
4140 if (t0 == first+2)
4141 break;
4142 const char* t1 = parse_call_offset(t0, last);
4143 if (t1 == t0)
4144 break;
4145 t = parse_encoding(t1, last, db);
4146 if (t != t1)
4147 {
4148 db.names.back().first.insert(0, "covariant return thunk to ");
4149 first = t;
4150 }
4151 }
4152 break;
4153 case 'C':
4154 // extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first
4155 t = parse_type(first+2, last, db);
4156 if (t != first+2)
4157 {
4158 const char* t0 = parse_number(t, last);
4159 if (t0 != t && t0 != last && *t0 == '_')
4160 {
4161 const char* t1 = parse_type(++t0, last, db);
4162 if (t1 != t0)
4163 {
4164 auto left = db.names.back().move_full();
4165 db.names.pop_back();
4166 db.names.back().first = "construction vtable for " +
4167 std::move(left) + "-in-" +
4168 db.names.back().move_full();
4169 first = t1;
4170 }
4171 }
4172 }
4173 break;
4174 default:
4175 // T <call-offset> <base encoding>
4176 {
4177 const char* t0 = parse_call_offset(first+1, last);
4178 if (t0 == first+1)
4179 break;
4180 t = parse_encoding(t0, last, db);
4181 if (t != t0)
4182 {
4183 if (first[2] == 'v')
4184 {
4185 db.names.back().first.insert(0, "virtual thunk to ");
4186 first = t;
4187 }
4188 else
4189 {
4190 db.names.back().first.insert(0, "non-virtual thunk to ");
4191 first = t;
4192 }
4193 }
4194 }
4195 break;
4196 }
4197 break;
4198 case 'G':
4199 switch (first[1])
4200 {
4201 case 'V':
4202 // GV <object name> # Guard variable for one-time initialization
4203 t = parse_name(first+2, last, db);
4204 if (t != first+2)
4205 {
4206 db.names.back().first.insert(0, "guard variable for ");
4207 first = t;
4208 }
4209 break;
4210 case 'R':
4211 // extension ::= GR <object name> # reference temporary for object
4212 t = parse_name(first+2, last, db);
4213 if (t != first+2)
4214 {
4215 db.names.back().first.insert(0, "reference temporary for ");
4216 first = t;
4217 }
4218 break;
4219 }
4220 break;
4221 }
4222 }
4223 return first;
4224}
4225
4226// <encoding> ::= <function name> <bare-function-type>
4227// ::= <data name>
4228// ::= <special-name>
4229
4230template <class C>
4231const char*
4232parse_encoding(const char* first, const char* last, C& db)
4233{
4234 if (first != last)
4235 {
4236 switch (*first)
4237 {
4238 case 'G':
4239 case 'T':
4240 first = parse_special_name(first, last, db);
4241 break;
4242 default:
4243 {
4244 const char* t = parse_name(first, last, db);
4245 unsigned cv = db.cv;
4246 unsigned ref = db.ref;
4247 if (t != first)
4248 {
4249 if (t != last && *t != 'E' && *t != '.')
4250 {
4251 bool tag_templates = db.tag_templates;
4252 db.tag_templates = false;
4253 const char* t2;
4254 typename C::String ret2;
4255 const typename C::String& nm = db.names.back().first;
4256 if (!db.parsed_ctor_dtor_cv && nm.back() == '>' && nm[nm.size()-2] != '-'
4257 && nm[nm.size()-2] != '>')
4258 {
4259 t2 = parse_type(t, last, db);
4260 if (t2 == t)
4261 return first;
4262 auto ret1 = std::move(db.names.back().first);
4263 ret2 = std::move(db.names.back().second);
4264 if (ret2.empty())
4265 ret1 += ' ';
4266 db.names.pop_back();
4267 db.names.back().first.insert(0, ret1);
4268 t = t2;
4269 }
4270 db.names.back().first += '(';
4271 if (t != last && *t == 'v')
4272 {
4273 ++t;
4274 }
4275 else
4276 {
4277 bool first_arg = true;
4278 while (true)
4279 {
4280 size_t k0 = db.names.size();
4281 t2 = parse_type(t, last, db);
4282 size_t k1 = db.names.size();
4283 if (t2 == t)
4284 break;
4285 if (k1 > k0)
4286 {
4287 typename C::String tmp;
4288 for (size_t k = k0; k < k1; ++k)
4289 {
4290 if (!tmp.empty())
4291 tmp += ", ";
4292 tmp += db.names[k].move_full();
4293 }
4294 for (size_t k = k0; k < k1; ++k)
4295 db.names.pop_back();
4296 if (!tmp.empty())
4297 {
4298 if (!first_arg)
4299 db.names.back().first += ", ";
4300 else
4301 first_arg = false;
4302 db.names.back().first += tmp;
4303 }
4304 }
4305 t = t2;
4306 }
4307 }
4308 db.names.back().first += ')';
4309 if (cv & 1)
4310 db.names.back().first.append(" const");
4311 if (cv & 2)
4312 db.names.back().first.append(" volatile");
4313 if (cv & 4)
4314 db.names.back().first.append(" restrict");
4315 if (ref == 1)
4316 db.names.back().first.append(" &");
4317 else if (ref == 2)
4318 db.names.back().first.append(" &&");
4319 db.names.back().first += ret2;
4320 first = t;
4321 db.tag_templates = tag_templates;
4322 }
4323 else
4324 first = t;
4325 }
4326 break;
4327 }
4328 }
4329 }
4330 return first;
4331}
4332
4333// _block_invoke
4334// _block_invoke<decimal-digit>+
4335// _block_invoke_<decimal-digit>+
4336
4337template <class C>
4338const char*
4339parse_block_invoke(const char* first, const char* last, C& db)
4340{
4341 if (last - first >= 13)
4342 {
4343 const char test[] = "_block_invoke";
4344 const char* t = first;
4345 for (int i = 0; i < 13; ++i, ++t)
4346 {
4347 if (*t != test[i])
4348 return first;
4349 }
4350 if (t != last)
4351 {
4352 if (*t == '_')
4353 {
4354 // must have at least 1 decimal digit
4355 if (++t == last || !std::isdigit(*t))
4356 return first;
4357 ++t;
4358 }
4359 // parse zero or more digits
4360 while (t != last && isdigit(*t))
4361 ++t;
4362 }
4363 db.names.back().first.insert(0, "invocation function for block in ");
4364 first = t;
4365 }
4366 return first;
4367}
4368
4369// extension
4370// <dot-suffix> := .<anything and everything>
4371
4372template <class C>
4373const char*
4374parse_dot_suffix(const char* first, const char* last, C& db)
4375{
4376 if (first != last && *first == '.')
4377 {
4378 db.names.back().first += " (" + typename C::String(first, last) + ")";
4379 first = last;
4380 }
4381 return first;
4382}
4383
4384// <block-involcaton-function> ___Z<encoding>_block_invoke
4385// <block-involcaton-function> ___Z<encoding>_block_invoke<decimal-digit>+
4386// <block-involcaton-function> ___Z<encoding>_block_invoke_<decimal-digit>+
4387// <mangled-name> ::= _Z<encoding>
4388// ::= <type>
4389
4390template <class C>
4391void
4392demangle(const char* first, const char* last, C& db, int& status)
4393{
4394 if (first >= last)
4395 {
4396 status = invalid_mangled_name;
4397 return;
4398 }
4399 if (*first == '_')
4400 {
4401 if (last - first >= 4)
4402 {
4403 if (first[1] == 'Z')
4404 {
4405 const char* t = parse_encoding(first+2, last, db);
4406 if (t != first+2 && t != last && *t == '.')
4407 t = parse_dot_suffix(t, last, db);
4408 if (t != last)
4409 status = invalid_mangled_name;
4410 }
4411 else if (first[1] == '_' && first[2] == '_' && first[3] == 'Z')
4412 {
4413 const char* t = parse_encoding(first+4, last, db);
4414 if (t != first+4 && t != last)
4415 {
4416 const char* t1 = parse_block_invoke(t, last, db);
4417 if (t1 != last)
4418 status = invalid_mangled_name;
4419 }
4420 else
4421 status = invalid_mangled_name;
4422 }
4423 else
4424 status = invalid_mangled_name;
4425 }
4426 else
4427 status = invalid_mangled_name;
4428 }
4429 else
4430 {
4431 const char* t = parse_type(first, last, db);
4432 if (t != last)
4433 status = invalid_mangled_name;
4434 }
4435 if (status == success && db.names.empty())
4436 status = invalid_mangled_name;
4437}
4438
4439template <std::size_t N>
4440class arena
4441{
4442 static const std::size_t alignment = 16;
4443 alignas(alignment) char buf_[N];
4444 char* ptr_;
4445
4446 std::size_t
4447 align_up(std::size_t n) noexcept
4448 {return n + (alignment-1) & ~(alignment-1);}
4449
4450 bool
4451 pointer_in_buffer(char* p) noexcept
4452 {return buf_ <= p && p <= buf_ + N;}
4453
4454public:
4455 arena() noexcept : ptr_(buf_) {}
4456 ~arena() {ptr_ = nullptr;}
4457 arena(const arena&) = delete;
4458 arena& operator=(const arena&) = delete;
4459
4460 char* allocate(std::size_t n);
4461 void deallocate(char* p, std::size_t n) noexcept;
4462
4463 static constexpr std::size_t size() {return N;}
4464 std::size_t used() const {return static_cast<std::size_t>(ptr_ - buf_);}
4465 void reset() {ptr_ = buf_;}
4466};
4467
4468template <std::size_t N>
4469char*
4470arena<N>::allocate(std::size_t n)
4471{
4472 n = align_up(n);
4473 if (static_cast<std::size_t>(buf_ + N - ptr_) >= n)
4474 {
4475 char* r = ptr_;
4476 ptr_ += n;
4477 return r;
4478 }
4479 return static_cast<char*>(std::malloc(n));
4480}
4481
4482template <std::size_t N>
4483void
4484arena<N>::deallocate(char* p, std::size_t n) noexcept
4485{
4486 if (pointer_in_buffer(p))
4487 {
4488 n = align_up(n);
4489 if (p + n == ptr_)
4490 ptr_ = p;
4491 }
4492 else
4493 std::free(p);
4494}
4495
4496template <class T, std::size_t N>
4497class short_alloc
4498{
4499 arena<N>& a_;
4500public:
4501 typedef T value_type;
4502
4503public:
4504 template <class _Up> struct rebind {typedef short_alloc<_Up, N> other;};
4505
4506 short_alloc(arena<N>& a) noexcept : a_(a) {}
4507 template <class U>
4508 short_alloc(const short_alloc<U, N>& a) noexcept
4509 : a_(a.a_) {}
4510 short_alloc(const short_alloc&) = default;
4511 short_alloc& operator=(const short_alloc&) = delete;
4512
4513 T* allocate(std::size_t n)
4514 {
4515 return reinterpret_cast<T*>(a_.allocate(n*sizeof(T)));
4516 }
4517 void deallocate(T* p, std::size_t n) noexcept
4518 {
4519 a_.deallocate(reinterpret_cast<char*>(p), n*sizeof(T));
4520 }
4521
4522 template <class T1, std::size_t N1, class U, std::size_t M>
4523 friend
4524 bool
4525 operator==(const short_alloc<T1, N1>& x, const short_alloc<U, M>& y) noexcept;
4526
4527 template <class U, std::size_t M> friend class short_alloc;
4528};
4529
4530template <class T, std::size_t N, class U, std::size_t M>
4531inline
4532bool
4533operator==(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept
4534{
4535 return N == M && &x.a_ == &y.a_;
4536}
4537
4538template <class T, std::size_t N, class U, std::size_t M>
4539inline
4540bool
4541operator!=(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept
4542{
4543 return !(x == y);
4544}
4545
4546template <class T>
4547class malloc_alloc
4548{
4549public:
4550 typedef T value_type;
4551
4552 malloc_alloc() = default;
4553 template <class U> malloc_alloc(const malloc_alloc<U>&) noexcept {}
4554
4555 T* allocate(std::size_t n)
4556 {
4557 return static_cast<T*>(std::malloc(n*sizeof(T)));
4558 }
4559 void deallocate(T* p, std::size_t) noexcept
4560 {
4561 std::free(p);
4562 }
4563};
4564
4565template <class T, class U>
4566inline
4567bool
4568operator==(const malloc_alloc<T>&, const malloc_alloc<U>&) noexcept
4569{
4570 return true;
4571}
4572
4573template <class T, class U>
4574inline
4575bool
4576operator!=(const malloc_alloc<T>& x, const malloc_alloc<U>& y) noexcept
4577{
4578 return !(x == y);
4579}
4580
4581const size_t bs = 4 * 1024;
4582template <class T> using Alloc = short_alloc<T, bs>;
4583template <class T> using Vector = std::vector<T, Alloc<T>>;
4584using String = std::basic_string<char, std::char_traits<char>, malloc_alloc<char>>;
4585
4586struct string_pair
4587{
4588 String first;
4589 String second;
4590
4591 string_pair() = default;
4592 string_pair(String f) : first(std::move(f)) {}
4593 string_pair(String f, String s)
4594 : first(std::move(f)), second(std::move(s)) {}
4595 template <size_t N>
4596 string_pair(const char (&s)[N]) : first(s, N-1) {}
4597
4598 size_t size() const {return first.size() + second.size();}
4599 String full() const {return first + second;}
4600 String move_full() {return std::move(first) + std::move(second);}
4601};
4602
4603struct Db
4604{
4605 typedef String String;
4606 typedef Vector<string_pair> sub_type;
4607 typedef Vector<sub_type> template_param_type;
4608 Vector<string_pair> names;
4609 Vector<sub_type> subs;
4610 Vector<template_param_type> template_param;
4611 unsigned cv;
4612 unsigned ref;
4613 bool parsed_ctor_dtor_cv;
4614 bool tag_templates;
4615 bool fix_forward_references;
4616 bool try_to_parse_template_args;
4617
4618 template <size_t N>
4619 Db(arena<N>& ar) :
4620 names(ar),
4621 subs(0, names, ar),
4622 template_param(0, subs, ar)
4623 {}
4624};
4625
4626char*
4627__cxa_demangle(const char* mangled_name, char* buf, size_t* n, int* status)
4628{
4629 if (mangled_name == nullptr || (buf != nullptr && n == nullptr))
4630 {
4631 if (status)
4632 *status = invalid_args;
4633 return nullptr;
4634 }
4635 size_t internal_size = buf != nullptr ? *n : 0;
4636 arena<bs> a;
4637 Db db(a);
4638 db.cv = 0;
4639 db.ref = 0;
4640 db.parsed_ctor_dtor_cv = false;
4641 db.tag_templates = true;
4642 db.template_param.emplace_back(a);
4643 db.fix_forward_references = false;
4644 db.try_to_parse_template_args = true;
4645 int internal_status = success;
4646 size_t len = std::strlen(mangled_name);
4647 demangle(mangled_name, mangled_name + len, db,
4648 internal_status);
4649 if (internal_status == success && db.fix_forward_references &&
4650 !db.template_param.empty() && !db.template_param.front().empty())
4651 {
4652 db.fix_forward_references = false;
4653 db.tag_templates = false;
4654 db.names.clear();
4655 db.subs.clear();
4656 demangle(mangled_name, mangled_name + len, db, internal_status);
4657 if (db.fix_forward_references)
4658 internal_status = invalid_mangled_name;
4659 }
4660 if (internal_status == success)
4661 {
4662 size_t sz = db.names.back().size() + 1;
4663 if (sz > internal_size)
4664 {
4665 char* newbuf = static_cast<char*>(std::realloc(buf, sz));
4666 if (newbuf == nullptr)
4667 {
4668 internal_status = memory_alloc_failure;
4669 buf = nullptr;
4670 }
4671 else
4672 {
4673 buf = newbuf;
4674 if (n != nullptr)
4675 *n = sz;
4676 }
4677 }
4678 if (buf != nullptr)
4679 {
4680 db.names.back().first += db.names.back().second;
4681 std::memcpy(buf, db.names.back().first.data(), sz-1);
4682 buf[sz-1] = char(0);
4683 }
4684 }
4685 else
4686 buf = nullptr;
4687 if (status)
4688 *status = internal_status;
4689 return buf;
4690}
4691
4692} // unnamed namespace
4693
4694#endif
4695
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4696
Greg Claytone41e5892010-09-03 23:26:12 +0000[diff] [blame]4697#include "llvm/ADT/DenseMap.h"
4698
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4699#include "lldb/Core/ConstString.h"
4700#include "lldb/Core/Mangled.h"
Greg Clayton83c5cd92010-11-14 22:13:40 +0000[diff] [blame]4701#include "lldb/Core/RegularExpression.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4702#include "lldb/Core/Stream.h"
4703#include "lldb/Core/Timer.h"
Eli Friedman88966972010-06-09 08:50:27 +0000[diff] [blame]4704#include <ctype.h>
4705#include <string.h>
Daniel Maleac91e4ab2013-05-31 20:21:38 +0000[diff] [blame]4706#include <stdlib.h>
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4707
4708using namespace lldb_private;
4709
Greg Clayton5e0c5e82012-07-18 20:47:40 +0000[diff] [blame]4710static inline bool
4711cstring_is_mangled (const char *s)
4712{
4713 if (s)
4714 return s[0] == '_' && s[1] == 'Z';
4715 return false;
4716}
4717
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4718#pragma mark Mangled
4719//----------------------------------------------------------------------
4720// Default constructor
4721//----------------------------------------------------------------------
4722Mangled::Mangled () :
4723 m_mangled(),
4724 m_demangled()
4725{
4726}
4727
4728//----------------------------------------------------------------------
4729// Constructor with an optional string and a boolean indicating if it is
4730// the mangled version.
4731//----------------------------------------------------------------------
Greg Clayton5e0c5e82012-07-18 20:47:40 +0000[diff] [blame]4732Mangled::Mangled (const ConstString &s, bool mangled) :
4733 m_mangled(),
4734 m_demangled()
4735{
4736 if (s)
4737 SetValue(s, mangled);
4738}
4739
Greg Clayton037520e2012-07-18 23:18:10 +0000[diff] [blame]4740Mangled::Mangled (const ConstString &s) :
Greg Clayton5e0c5e82012-07-18 20:47:40 +0000[diff] [blame]4741 m_mangled(),
4742 m_demangled()
4743{
Greg Clayton5e0c5e82012-07-18 20:47:40 +0000[diff] [blame]4744 if (s)
4745 SetValue(s);
4746}
4747
4748//----------------------------------------------------------------------
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4749// Destructor
4750//----------------------------------------------------------------------
4751Mangled::~Mangled ()
4752{
4753}
4754
4755//----------------------------------------------------------------------
4756// Convert to pointer operator. This allows code to check any Mangled
4757// objects to see if they contain anything valid using code such as:
4758//
4759// Mangled mangled(...);
4760// if (mangled)
4761// { ...
4762//----------------------------------------------------------------------
4763Mangled::operator void* () const
4764{
4765 return (m_mangled) ? const_cast<Mangled*>(this) : NULL;
4766}
4767
4768//----------------------------------------------------------------------
4769// Logical NOT operator. This allows code to check any Mangled
4770// objects to see if they are invalid using code such as:
4771//
4772// Mangled mangled(...);
4773// if (!file_spec)
4774// { ...
4775//----------------------------------------------------------------------
4776bool
4777Mangled::operator! () const
4778{
4779 return !m_mangled;
4780}
4781
4782//----------------------------------------------------------------------
4783// Clear the mangled and demangled values.
4784//----------------------------------------------------------------------
4785void
4786Mangled::Clear ()
4787{
4788 m_mangled.Clear();
4789 m_demangled.Clear();
4790}
4791
4792
4793//----------------------------------------------------------------------
4794// Compare the the string values.
4795//----------------------------------------------------------------------
4796int
4797Mangled::Compare (const Mangled& a, const Mangled& b)
4798{
Jim Ingham89bf5e92010-09-15 00:13:44 +0000[diff] [blame]4799 return ConstString::Compare(a.GetName(ePreferMangled), a.GetName(ePreferMangled));
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4800}
4801
4802
4803
4804//----------------------------------------------------------------------
4805// Set the string value in this objects. If "mangled" is true, then
4806// the mangled named is set with the new value in "s", else the
4807// demangled name is set.
4808//----------------------------------------------------------------------
4809void
Greg Clayton5e0c5e82012-07-18 20:47:40 +0000[diff] [blame]4810Mangled::SetValue (const ConstString &s, bool mangled)
4811{
4812 if (s)
4813 {
4814 if (mangled)
4815 {
4816 m_demangled.Clear();
4817 m_mangled = s;
4818 }
4819 else
4820 {
4821 m_demangled = s;
4822 m_mangled.Clear();
4823 }
4824 }
4825 else
4826 {
4827 m_demangled.Clear();
4828 m_mangled.Clear();
4829 }
4830}
4831
4832void
4833Mangled::SetValue (const ConstString &name)
4834{
4835 if (name)
4836 {
4837 if (cstring_is_mangled(name.GetCString()))
4838 {
4839 m_demangled.Clear();
4840 m_mangled = name;
4841 }
4842 else
4843 {
4844 m_demangled = name;
4845 m_mangled.Clear();
4846 }
4847 }
4848 else
4849 {
4850 m_demangled.Clear();
4851 m_mangled.Clear();
4852 }
4853}
4854
4855
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4856//----------------------------------------------------------------------
4857// Generate the demangled name on demand using this accessor. Code in
4858// this class will need to use this accessor if it wishes to decode
4859// the demangled name. The result is cached and will be kept until a
4860// new string value is supplied to this object, or until the end of the
4861// object's lifetime.
4862//----------------------------------------------------------------------
4863const ConstString&
4864Mangled::GetDemangledName () const
4865{
4866 // Check to make sure we have a valid mangled name and that we
4867 // haven't already decoded our mangled name.
4868 if (m_mangled && !m_demangled)
4869 {
4870 // We need to generate and cache the demangled name.
4871 Timer scoped_timer (__PRETTY_FUNCTION__,
4872 "Mangled::GetDemangledName (m_mangled = %s)",
4873 m_mangled.GetCString());
4874
Greg Clayton5e0c5e82012-07-18 20:47:40 +0000[diff] [blame]4875 // Don't bother running anything that isn't mangled
4876 const char *mangled_cstr = m_mangled.GetCString();
4877 if (cstring_is_mangled(mangled_cstr))
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4878 {
Greg Claytonc3ae1ce2011-06-09 22:34:34 +0000[diff] [blame]4879 if (!m_mangled.GetMangledCounterpart(m_demangled))
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4880 {
Greg Claytone41e5892010-09-03 23:26:12 +0000[diff] [blame]4881 // We didn't already mangle this name, demangle it and if all goes well
4882 // add it to our map.
Greg Clayton19c8e782013-10-30 18:42:59 +0000[diff] [blame]4883#ifdef LLDB_USE_BUILTIN_DEMANGLER
4884 char *demangled_name = __cxa_demangle (mangled_cstr, NULL, NULL, NULL);
Virgile Bellod0c5c772013-09-18 08:09:31 +0000[diff] [blame]4885#else
Greg Clayton19c8e782013-10-30 18:42:59 +0000[diff] [blame]4886 char *demangled_name = abi::__cxa_demangle (mangled_cstr, NULL, NULL, NULL);
Virgile Bellod0c5c772013-09-18 08:09:31 +0000[diff] [blame]4887#endif
Greg Claytone41e5892010-09-03 23:26:12 +0000[diff] [blame]4888
4889 if (demangled_name)
4890 {
Greg Claytonc3ae1ce2011-06-09 22:34:34 +0000[diff] [blame]4891 m_demangled.SetCStringWithMangledCounterpart(demangled_name, m_mangled);
Greg Claytone41e5892010-09-03 23:26:12 +0000[diff] [blame]4892 free (demangled_name);
4893 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4894 }
4895 }
Jason Molenda3f8688b2010-12-15 04:27:04 +0000[diff] [blame]4896 if (!m_demangled)
4897 {
4898 // Set the demangled string to the empty string to indicate we
4899 // tried to parse it once and failed.
4900 m_demangled.SetCString("");
4901 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4902 }
4903
4904 return m_demangled;
4905}
4906
Greg Clayton83c5cd92010-11-14 22:13:40 +0000[diff] [blame]4907
4908bool
4909Mangled::NameMatches (const RegularExpression& regex) const
4910{
4911 if (m_mangled && regex.Execute (m_mangled.AsCString()))
4912 return true;
4913
4914 if (GetDemangledName() && regex.Execute (m_demangled.AsCString()))
4915 return true;
4916 return false;
4917}
4918
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4919//----------------------------------------------------------------------
4920// Get the demangled name if there is one, else return the mangled name.
4921//----------------------------------------------------------------------
4922const ConstString&
Jim Ingham08b87e02010-09-14 22:03:00 +0000[diff] [blame]4923Mangled::GetName (Mangled::NamePreference preference) const
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4924{
Greg Clayton87425432010-09-14 23:44:49 +0000[diff] [blame]4925 if (preference == ePreferDemangled)
Jim Ingham08b87e02010-09-14 22:03:00 +0000[diff] [blame]4926 {
Greg Claytond0b89f82010-09-14 23:48:44 +0000[diff] [blame]4927 // Call the accessor to make sure we get a demangled name in case
4928 // it hasn't been demangled yet...
4929 if (GetDemangledName())
4930 return m_demangled;
Greg Clayton87425432010-09-14 23:44:49 +0000[diff] [blame]4931 return m_mangled;
4932 }
4933 else
4934 {
Greg Claytond0b89f82010-09-14 23:48:44 +0000[diff] [blame]4935 if (m_mangled)
4936 return m_mangled;
4937 return GetDemangledName();
Jim Ingham08b87e02010-09-14 22:03:00 +0000[diff] [blame]4938 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4939}
4940
4941//----------------------------------------------------------------------
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000[diff] [blame]4942// Dump a Mangled object to stream "s". We don't force our
4943// demangled name to be computed currently (we don't use the accessor).
4944//----------------------------------------------------------------------
4945void
4946Mangled::Dump (Stream *s) const
4947{
4948 if (m_mangled)
4949 {
4950 *s << ", mangled = " << m_mangled;
4951 }
4952 if (m_demangled)
4953 {
4954 const char * demangled = m_demangled.AsCString();
4955 s->Printf(", demangled = %s", demangled[0] ? demangled : "<error>");
4956 }
4957}
4958
4959//----------------------------------------------------------------------
4960// Dumps a debug version of this string with extra object and state
4961// information to stream "s".
4962//----------------------------------------------------------------------
4963void
4964Mangled::DumpDebug (Stream *s) const
4965{
4966 s->Printf("%*p: Mangled mangled = ", (int)sizeof(void*) * 2, this);
4967 m_mangled.DumpDebug(s);
4968 s->Printf(", demangled = ");
4969 m_demangled.DumpDebug(s);
4970}
4971
4972//----------------------------------------------------------------------
4973// Return the size in byte that this object takes in memory. The size
4974// includes the size of the objects it owns, and not the strings that
4975// it references because they are shared strings.
4976//----------------------------------------------------------------------
4977size_t
4978Mangled::MemorySize () const
4979{
4980 return m_mangled.MemorySize() + m_demangled.MemorySize();
4981}
4982
4983//----------------------------------------------------------------------
4984// Dump OBJ to the supplied stream S.
4985//----------------------------------------------------------------------
4986Stream&
4987operator << (Stream& s, const Mangled& obj)
4988{
4989 if (obj.GetMangledName())
4990 s << "mangled = '" << obj.GetMangledName() << "'";
4991
4992 const ConstString& demangled = obj.GetDemangledName();
4993 if (demangled)
4994 s << ", demangled = '" << demangled << '\'';
4995 else
4996 s << ", demangled = <error>";
4997 return s;
4998}