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