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