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 
10 
11 // FreeBSD9-STABLE requires this to know about size_t in cxxabi.h
12 #include <cstddef>
13 #ifdef _MSC_VER
14 #define LLDB_USE_BUILTIN_DEMANGLER
15 #else
16 #include <cxxabi.h>
17 #endif
18 
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 
33 namespace
34 {
35 
36 enum
37 {
38     unknown_error = -4,
39     invalid_args = -3,
40     invalid_mangled_name,
41     memory_alloc_failure,
42     success
43 };
44 
45 template <class C>
46     const char* parse_type(const char* first, const char* last, C& db);
47 template <class C>
48     const char* parse_encoding(const char* first, const char* last, C& db);
49 template <class C>
50     const char* parse_name(const char* first, const char* last, C& db);
51 template <class C>
52     const char* parse_expression(const char* first, const char* last, C& db);
53 template <class C>
54     const char* parse_template_args(const char* first, const char* last, C& db);
55 template <class C>
56     const char* parse_operator_name(const char* first, const char* last, C& db);
57 template <class C>
58     const char* parse_unqualified_name(const char* first, const char* last, C& db);
59 template <class C>
60     const char* parse_decltype(const char* first, const char* last, C& db);
61 
62 template <class C>
63 void
64 print_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 
103 template <class C>
104 void
105 print_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 
116 const char*
117 parse_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 
141 template <class Float>
142 struct float_data;
143 
144 template <>
145 struct 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 
152 constexpr const char* float_data<float>::spec;
153 
154 template <>
155 struct 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 
162 constexpr const char* float_data<double>::spec;
163 
164 template <>
165 struct 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 
172 constexpr const char* float_data<long double>::spec;
173 
174 template <class Float, class C>
175 const char*
176 parse_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 
218 template <class C>
219 const char*
220 parse_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 
260 template <class C>
261 const char*
262 parse_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 
367 template <class C>
368 const char*
369 parse_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 
513 const char*
514 parse_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 
541 template <class C>
542 const char*
543 parse_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 
596 template <class C>
597 const char*
598 parse_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 
620 template <class C>
621 const char*
622 parse_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 
644 template <class C>
645 const char*
646 parse_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 
668 template <class C>
669 const char*
670 parse_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 
692 template <class C>
693 const char*
694 parse_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 
707 template <class C>
708 const char*
709 parse_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 
725 template <class C>
726 const char*
727 parse_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 
743 template <class C>
744 const char*
745 parse_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 
777 template <class C>
778 const char*
779 parse_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 
816 template <class C>
817 const char*
818 parse_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 
835 template <class C>
836 const char*
837 parse_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 
857 template <class C>
858 const char*
859 parse_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 
875 template <class C>
876 const char*
877 parse_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 
899 template <class C>
900 const char*
901 parse_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 
927 template <class C>
928 const char*
929 parse_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 
987 template <class C>
988 const char*
989 parse_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 
1013 template <class C>
1014 const char*
1015 parse_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 
1068 template <class C>
1069 const char*
1070 parse_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 
1085 template <class C>
1086 const char*
1087 parse_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 
1213 template <class C>
1214 const char*
1215 parse_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 
1237 template <class C>
1238 const char*
1239 parse_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 
1284 template <class C>
1285 const char*
1286 parse_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 
1392 template <class C>
1393 const char*
1394 parse_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 
1453 template <class C>
1454 const char*
1455 parse_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 
1481 template <class C>
1482 const char*
1483 parse_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 
1568 template <class C>
1569 const char*
1570 parse_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 
1603 template <class C>
1604 const char*
1605 parse_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 
1661 template <class C>
1662 const char*
1663 parse_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 
1692 template <class C>
1693 const char*
1694 parse_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 
1775 template <class C>
1776 const char*
1777 parse_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 
2191 template <class C>
2192 const char*
2193 parse_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 
2475 template <class C>
2476 const char*
2477 parse_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 
2506 template <class C>
2507 const char*
2508 parse_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 
2691 template <class String>
2692 String
2693 base_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 
2759 template <class C>
2760 const char*
2761 parse_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 
2805 template <class C>
2806 const char*
2807 parse_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 
2914 template <class C>
2915 const char*
2916 parse_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 
2961 template <class C>
2962 const char*
2963 parse_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 
2989 template <class C>
2990 const char*
2991 parse_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 
3007 template <class C>
3008 const char*
3009 parse_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 
3023 template <class C>
3024 const char*
3025 parse_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 
3036 template <class C>
3037 const char*
3038 parse_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 
3049 template <class C>
3050 const char*
3051 parse_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 
3117 template <class C>
3118 const char*
3119 parse_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 
3601 template <class C>
3602 const char*
3603 parse_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 
3654 template <class C>
3655 const char*
3656 parse_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 
3718 template <class C>
3719 const char*
3720 parse_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 
3861 const char*
3862 parse_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 
3898 template <class C>
3899 const char*
3900 parse_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 
3964 template <class C>
3965 const char*
3966 parse_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 
4043 const char*
4044 parse_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 
4088 template <class C>
4089 const char*
4090 parse_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 
4230 template <class C>
4231 const char*
4232 parse_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 
4337 template <class C>
4338 const char*
4339 parse_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 
4372 template <class C>
4373 const char*
4374 parse_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 
4390 template <class C>
4391 void
4392 demangle(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 
4439 template <std::size_t N>
4440 class 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 
4454 public:
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 
4468 template <std::size_t N>
4469 char*
4470 arena<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 
4482 template <std::size_t N>
4483 void
4484 arena<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 
4496 template <class T, std::size_t N>
4497 class short_alloc
4498 {
4499     arena<N>& a_;
4500 public:
4501     typedef T value_type;
4502 
4503 public:
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 
4530 template <class T, std::size_t N, class U, std::size_t M>
4531 inline
4532 bool
4533 operator==(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept
4534 {
4535     return N == M && &x.a_ == &y.a_;
4536 }
4537 
4538 template <class T, std::size_t N, class U, std::size_t M>
4539 inline
4540 bool
4541 operator!=(const short_alloc<T, N>& x, const short_alloc<U, M>& y) noexcept
4542 {
4543     return !(x == y);
4544 }
4545 
4546 template <class T>
4547 class malloc_alloc
4548 {
4549 public:
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 
4565 template <class T, class U>
4566 inline
4567 bool
4568 operator==(const malloc_alloc<T>&, const malloc_alloc<U>&) noexcept
4569 {
4570     return true;
4571 }
4572 
4573 template <class T, class U>
4574 inline
4575 bool
4576 operator!=(const malloc_alloc<T>& x, const malloc_alloc<U>& y) noexcept
4577 {
4578     return !(x == y);
4579 }
4580 
4581 const size_t bs = 4 * 1024;
4582 template <class T> using Alloc = short_alloc<T, bs>;
4583 template <class T> using Vector = std::vector<T, Alloc<T>>;
4584 using String = std::basic_string<char, std::char_traits<char>, malloc_alloc<char>>;
4585 
4586 struct 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 
4603 struct 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 
4626 char*
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 
4696 
4697 #include "llvm/ADT/DenseMap.h"
4698 
4699 #include "lldb/Core/ConstString.h"
4700 #include "lldb/Core/Mangled.h"
4701 #include "lldb/Core/RegularExpression.h"
4702 #include "lldb/Core/Stream.h"
4703 #include "lldb/Core/Timer.h"
4704 #include <ctype.h>
4705 #include <string.h>
4706 #include <stdlib.h>
4707 
4708 using namespace lldb_private;
4709 
4710 static inline bool
4711 cstring_is_mangled (const char *s)
4712 {
4713     if (s)
4714         return s[0] == '_' && s[1] == 'Z';
4715     return false;
4716 }
4717 
4718 #pragma mark Mangled
4719 //----------------------------------------------------------------------
4720 // Default constructor
4721 //----------------------------------------------------------------------
4722 Mangled::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 //----------------------------------------------------------------------
4732 Mangled::Mangled (const ConstString &s, bool mangled) :
4733     m_mangled(),
4734     m_demangled()
4735 {
4736     if (s)
4737         SetValue(s, mangled);
4738 }
4739 
4740 Mangled::Mangled (const ConstString &s) :
4741     m_mangled(),
4742     m_demangled()
4743 {
4744     if (s)
4745         SetValue(s);
4746 }
4747 
4748 //----------------------------------------------------------------------
4749 // Destructor
4750 //----------------------------------------------------------------------
4751 Mangled::~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 //----------------------------------------------------------------------
4763 Mangled::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 //----------------------------------------------------------------------
4776 bool
4777 Mangled::operator! () const
4778 {
4779     return !m_mangled;
4780 }
4781 
4782 //----------------------------------------------------------------------
4783 // Clear the mangled and demangled values.
4784 //----------------------------------------------------------------------
4785 void
4786 Mangled::Clear ()
4787 {
4788     m_mangled.Clear();
4789     m_demangled.Clear();
4790 }
4791 
4792 
4793 //----------------------------------------------------------------------
4794 // Compare the the string values.
4795 //----------------------------------------------------------------------
4796 int
4797 Mangled::Compare (const Mangled& a, const Mangled& b)
4798 {
4799     return ConstString::Compare(a.GetName(ePreferMangled), a.GetName(ePreferMangled));
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 //----------------------------------------------------------------------
4809 void
4810 Mangled::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 
4832 void
4833 Mangled::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 
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 //----------------------------------------------------------------------
4863 const ConstString&
4864 Mangled::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 
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))
4878         {
4879             if (!m_mangled.GetMangledCounterpart(m_demangled))
4880             {
4881                 // We didn't already mangle this name, demangle it and if all goes well
4882                 // add it to our map.
4883 #ifdef LLDB_USE_BUILTIN_DEMANGLER
4884                 char *demangled_name = __cxa_demangle (mangled_cstr, NULL, NULL, NULL);
4885 #else
4886                 char *demangled_name = abi::__cxa_demangle (mangled_cstr, NULL, NULL, NULL);
4887 #endif
4888 
4889                 if (demangled_name)
4890                 {
4891                     m_demangled.SetCStringWithMangledCounterpart(demangled_name, m_mangled);
4892                     free (demangled_name);
4893                 }
4894             }
4895         }
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         }
4902     }
4903 
4904     return m_demangled;
4905 }
4906 
4907 
4908 bool
4909 Mangled::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 
4919 //----------------------------------------------------------------------
4920 // Get the demangled name if there is one, else return the mangled name.
4921 //----------------------------------------------------------------------
4922 const ConstString&
4923 Mangled::GetName (Mangled::NamePreference preference) const
4924 {
4925     if (preference == ePreferDemangled)
4926     {
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;
4931         return m_mangled;
4932     }
4933     else
4934     {
4935         if (m_mangled)
4936             return m_mangled;
4937         return GetDemangledName();
4938     }
4939 }
4940 
4941 //----------------------------------------------------------------------
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 //----------------------------------------------------------------------
4945 void
4946 Mangled::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 //----------------------------------------------------------------------
4963 void
4964 Mangled::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 //----------------------------------------------------------------------
4977 size_t
4978 Mangled::MemorySize () const
4979 {
4980     return m_mangled.MemorySize() + m_demangled.MemorySize();
4981 }
4982 
4983 //----------------------------------------------------------------------
4984 // Dump OBJ to the supplied stream S.
4985 //----------------------------------------------------------------------
4986 Stream&
4987 operator << (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 }
4999