Lines Matching refs:first
37 const char* parse_type(const char* first, const char* last, C& db);
39 const char* parse_encoding(const char* first, const char* last, C& db);
41 const char* parse_name(const char* first, const char* last, C& db,
44 const char* parse_expression(const char* first, const char* last, C& db);
46 const char* parse_template_args(const char* first, const char* last, C& db);
48 const char* parse_operator_name(const char* first, const char* last, C& db);
50 const char* parse_unqualified_name(const char* first, const char* last, C& db);
52 const char* parse_decltype(const char* first, const char* last, C& db);
61 printf("{%s#%s}\n", s.first.c_str(), s.second.c_str());
71 printf("{%s#%s}", s.first.c_str(), s.second.c_str());
87 printf("{%s#%s}", s.first.c_str(), s.second.c_str());
97 print_state(const char* msg, const char* first, const char* last, const C& db)
100 for (; first != last; ++first)
101 printf("%c", *first);
109 parse_number(const char* first, const char* last)
111 if (first != last)
113 const char* t = first;
120 first = t+1;
124 first = t+1;
125 while (first != last && std::isdigit(*first))
126 ++first;
130 return first;
172 parse_floating_number(const char* first, const char* last, C& db)
175 if (static_cast<std::size_t>(last - first) > N)
177 last = first + N;
183 const char* t = first;
188 return first;
204 return first;
206 first = t+1;
209 return first;
216 parse_source_name(const char* first, const char* last, C& db)
218 if (first != last)
220 char c = *first;
221 if (isdigit(c) && first+1 != last)
223 const char* t = first+1;
229 return first;
238 first = t + n;
242 return first;
258 parse_substitution(const char* first, const char* last, C& db)
260 if (last - first >= 2)
262 if (*first == 'S')
264 switch (first[1])
268 first += 2;
272 first += 2;
276 first += 2;
280 first += 2;
284 first += 2;
288 first += 2;
295 first += 2;
299 if (std::isdigit(first[1]) || std::isupper(first[1]))
302 const char* t = first+1;
316 return first;
322 first = t+1;
329 return first;
366 parse_builtin_type(const char* first, const char* last, C& db)
368 if (first != last)
370 switch (*first)
374 ++first;
378 ++first;
382 ++first;
386 ++first;
390 ++first;
394 ++first;
398 ++first;
402 ++first;
406 ++first;
410 ++first;
414 ++first;
418 ++first;
422 ++first;
426 ++first;
430 ++first;
434 ++first;
438 ++first;
442 ++first;
446 ++first;
450 ++first;
454 ++first;
458 const char*t = parse_source_name(first+1, last, db);
459 if (t != first+1)
460 first = t;
464 if (first+1 != last)
466 switch (first[1])
470 first += 2;
474 first += 2;
478 first += 2;
482 first += 2;
486 first += 2;
490 first += 2;
494 first += 2;
498 first += 2;
502 first += 2;
509 return first;
515 parse_cv_qualifiers(const char* first, const char* last, unsigned& cv)
518 if (first != last)
520 if (*first == 'r')
523 ++first;
525 if (*first == 'V')
528 ++first;
530 if (*first == 'K')
533 ++first;
536 return first;
539 // <template-param> ::= T_ # first template parameter
544 parse_template_param(const char* first, const char* last, C& db)
546 if (last - first >= 2)
548 if (*first == 'T')
550 if (first[1] == '_')
553 return first;
558 first += 2;
563 first += 2;
567 else if (isdigit(first[1]))
569 const char* t = first+1;
577 return first;
583 first = t+1;
587 db.names.push_back(typename C::String(first, t+1));
588 first = t+1;
594 return first;
601 parse_const_cast_expr(const char* first, const char* last, C& db)
603 if (last - first >= 3 && first[0] == 'c' && first[1] == 'c')
605 const char* t = parse_type(first+2, last, db);
606 if (t != first+2)
612 return first;
616 first = t1;
620 return first;
627 parse_dynamic_cast_expr(const char* first, const char* last, C& db)
629 if (last - first >= 3 && first[0] == 'd' && first[1] == 'c')
631 const char* t = parse_type(first+2, last, db);
632 if (t != first+2)
638 return first;
642 first = t1;
646 return first;
653 parse_reinterpret_cast_expr(const char* first, const char* last, C& db)
655 if (last - first >= 3 && first[0] == 'r' && first[1] == 'c')
657 const char* t = parse_type(first+2, last, db);
658 if (t != first+2)
664 return first;
668 first = t1;
672 return first;
679 parse_static_cast_expr(const char* first, const char* last, C& db)
681 if (last - first >= 3 && first[0] == 's' && first[1] == 'c')
683 const char* t = parse_type(first+2, last, db);
684 if (t != first+2)
690 return first;
694 first = t1;
698 return first;
705 parse_pack_expansion(const char* first, const char* last, C& db)
707 if (last - first >= 3 && first[0] == 's' && first[1] == 'p')
709 const char* t = parse_expression(first+2, last, db);
710 if (t != first+2)
711 first = t;
713 return first;
720 parse_sizeof_type_expr(const char* first, const char* last, C& db)
722 if (last - first >= 3 && first[0] == 's' && first[1] == 't')
724 const char* t = parse_type(first+2, last, db);
725 if (t != first+2)
728 return first;
730 first = t;
733 return first;
740 parse_sizeof_expr_expr(const char* first, const char* last, C& db)
742 if (last - first >= 3 && first[0] == 's' && first[1] == 'z')
744 const char* t = parse_expression(first+2, last, db);
745 if (t != first+2)
748 return first;
750 first = t;
753 return first;
760 parse_sizeof_param_pack_expr(const char* first, const char* last, C& db)
762 if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'T')
765 const char* t = parse_template_param(first+2, last, db);
767 if (t != first+2)
781 first = t;
784 return first;
787 // <function-param> ::= fp <top-level CV-qualifiers> _ # L == 0, first parameter
789 // ::= fL <L-1 non-negative number> p <top-level CV-qualifiers> _ # L > 0, first parameter
794 parse_function_param(const char* first, const char* last, C& db)
796 if (last - first >= 3 && *first == 'f')
798 if (first[1] == 'p')
801 const char* t = parse_cv_qualifiers(first+2, last, cv);
806 first = t1+1;
809 else if (first[1] == 'L')
812 const char* t0 = parse_number(first+2, last);
821 first = t1+1;
826 return first;
833 parse_sizeof_function_param_pack_expr(const char* first, const char* last, C& db)
835 if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'f')
837 const char* t = parse_function_param(first+2, last, db);
838 if (t != first+2)
841 return first;
843 first = t;
846 return first;
854 parse_typeid_expr(const char* first, const char* last, C& db)
856 if (last - first >= 3 && first[0] == 't' && (first[1] == 'e' || first[1] == 'i'))
859 if (first[1] == 'e')
860 t = parse_expression(first+2, last, db);
862 t = parse_type(first+2, last, db);
863 if (t != first+2)
866 return first;
868 first = t;
871 return first;
878 parse_throw_expr(const char* first, const char* last, C& db)
880 if (last - first >= 3 && first[0] == 't' && first[1] == 'w')
882 const char* t = parse_expression(first+2, last, db);
883 if (t != first+2)
886 return first;
888 first = t;
891 return first;
898 parse_dot_star_expr(const char* first, const char* last, C& db)
900 if (last - first >= 3 && first[0] == 'd' && first[1] == 's')
902 const char* t = parse_expression(first+2, last, db);
903 if (t != first+2)
909 return first;
912 db.names.back().first += ".*" + expr;
913 first = t1;
917 return first;
924 parse_simple_id(const char* first, const char* last, C& db)
926 if (first != last)
928 const char* t = parse_source_name(first, last, db);
929 if (t != first)
935 return first;
938 db.names.back().first += std::move(args);
940 first = t1;
943 first = t;
945 return first;
954 parse_unresolved_type(const char* first, const char* last, C& db)
956 if (first != last)
958 const char* t = first;
959 switch (*first)
964 t = parse_template_param(first, last, db);
966 if (t != first && k1 == k0 + 1)
969 first = t;
979 t = parse_decltype(first, last, db);
980 if (t != first)
983 return first;
985 first = t;
989 t = parse_substitution(first, last, db);
990 if (t != first)
991 first = t;
994 if (last - first > 2 && first[1] == 't')
996 t = parse_unqualified_name(first+2, last, db);
997 if (t != first+2)
1000 return first;
1001 db.names.back().first.insert(0, "std::");
1003 first = t;
1010 return first;
1018 parse_destructor_name(const char* first, const char* last, C& db)
1020 if (first != last)
1022 const char* t = parse_unresolved_type(first, last, db);
1023 if (t == first)
1024 t = parse_simple_id(first, last, db);
1025 if (t != first)
1028 return first;
1029 db.names.back().first.insert(0, "~");
1030 first = t;
1033 return first;
1046 parse_base_unresolved_name(const char* first, const char* last, C& db)
1048 if (last - first >= 2)
1050 if ((first[0] == 'o' || first[0] == 'd') && first[1] == 'n')
1052 if (first[0] == 'o')
1054 const char* t = parse_operator_name(first+2, last, db);
1055 if (t != first+2)
1057 first = parse_template_args(t, last, db);
1058 if (first != t)
1061 return first;
1064 db.names.back().first += std::move(args);
1070 const char* t = parse_destructor_name(first+2, last, db);
1071 if (t != first+2)
1072 first = t;
1077 const char* t = parse_simple_id(first, last, db);
1078 if (t == first)
1080 t = parse_operator_name(first, last, db);
1081 if (t != first)
1083 first = parse_template_args(t, last, db);
1084 if (first != t)
1087 return first;
1090 db.names.back().first += std::move(args);
1095 first = t;
1098 return first;
1105 parse_unresolved_qualifier_level(const char* first, const char* last, C& db)
1107 return parse_simple_id(first, last, db);
1122 parse_unresolved_name(const char* first, const char* last, C& db)
1124 if (last - first > 2)
1126 const char* t = first;
1139 return first;
1140 db.names.back().first.insert(0, "::");
1142 first = t2;
1151 return first;
1157 return first;
1160 db.names.back().first += std::move(args);
1165 return first;
1172 return first;
1175 db.names.back().first += "::" + std::move(s);
1184 return first;
1187 return first;
1190 db.names.back().first += "::" + std::move(s);
1191 first = t1;
1204 return first;
1207 db.names.back().first += std::move(args);
1215 return first;
1218 return first;
1221 db.names.back().first += "::" + std::move(s);
1222 first = t1;
1228 return first;
1233 return first;
1234 db.names.back().first.insert(0, "::");
1240 return first;
1243 db.names.back().first += "::" + std::move(s);
1252 return first;
1255 return first;
1258 db.names.back().first += "::" + std::move(s);
1259 first = t1;
1264 return first;
1271 parse_dot_expr(const char* first, const char* last, C& db)
1273 if (last - first >= 3 && first[0] == 'd' && first[1] == 't')
1275 const char* t = parse_expression(first+2, last, db);
1276 if (t != first+2)
1282 return first;
1285 db.names.back().first += "." + name;
1286 first = t1;
1290 return first;
1297 parse_call_expr(const char* first, const char* last, C& db)
1299 if (last - first >= 4 && first[0] == 'c' && first[1] == 'l')
1301 const char* t = parse_expression(first+2, last, db);
1302 if (t != first+2)
1305 return first;
1307 return first;
1308 db.names.back().first += db.names.back().second;
1310 db.names.back().first.append("(");
1316 return first;
1318 return first;
1324 return first;
1327 db.names.back().first.append(", ");
1330 db.names.back().first.append(tmp);
1336 return first;
1337 db.names.back().first.append(")");
1338 first = t;
1341 return first;
1352 parse_new_expr(const char* first, const char* last, C& db)
1354 if (last - first >= 4)
1356 const char* t = first;
1368 return first;
1375 return first;
1380 return first;
1386 return first;
1387 db.names.back().first.append(", ");
1388 db.names.back().first.append(tmp);
1397 return first;
1409 return first;
1413 return first;
1419 return first;
1420 db.names.back().first.append(", ");
1421 db.names.back().first.append(tmp);
1429 return first;
1434 return first;
1439 return first;
1446 return first;
1463 first = t+1;
1466 return first;
1474 parse_conversion_expr(const char* first, const char* last, C& db)
1476 if (last - first >= 3 && first[0] == 'c' && first[1] == 'v')
1480 const char* t = parse_type(first+2, last, db);
1482 if (t != first+2 && t != last)
1488 return first;
1495 return first;
1505 return first;
1509 return first;
1515 return first;
1516 db.names.back().first.append(", ");
1517 db.names.back().first.append(tmp);
1527 return first;
1531 first = t;
1534 return first;
1541 parse_arrow_expr(const char* first, const char* last, C& db)
1543 if (last - first >= 3 && first[0] == 'p' && first[1] == 't')
1545 const char* t = parse_expression(first+2, last, db);
1546 if (t != first+2)
1552 return first;
1555 db.names.back().first += "->";
1556 db.names.back().first += tmp;
1557 first = t1;
1561 return first;
1571 parse_function_type(const char* first, const char* last, C& db)
1573 if (first != last && *first == 'F')
1575 const char* t = first+1;
1583 return first;
1596 return first;
1624 return first;
1646 return first;
1647 db.names.back().first += " ";
1649 first = t;
1653 return first;
1660 parse_pointer_to_member_type(const char* first, const char* last, C& db)
1662 if (first != last && *first == 'M')
1664 const char* t = parse_type(first+1, last, db);
1665 if (t != first+1)
1671 return first;
1677 db.names.back().first = std::move(func.first) + "(" + class_type.move_full() + "::*";
1682 db.names.back().first = std::move(func.first) + " " + class_type.move_full() + "::*";
1685 first = t2;
1689 return first;
1697 parse_array_type(const char* first, const char* last, C& db)
1699 if (first != last && *first == 'A' && first+1 != last)
1701 if (first[1] == '_')
1703 const char* t = parse_type(first+2, last, db);
1704 if (t != first+2)
1707 return first;
1711 first = t;
1714 else if ('1' <= first[1] && first[1] <= '9')
1716 const char* t = parse_number(first+1, last);
1723 return first;
1726 db.names.back().second.insert(0, " [" + typename C::String(first+1, t) + "]");
1727 first = t2;
1733 const char* t = parse_expression(first+1, last, db);
1734 if (t != first+1 && t != last && *t == '_')
1740 return first;
1744 db.names.back().first = std::move(type.first);
1748 first = t2;
1753 return first;
1761 parse_decltype(const char* first, const char* last, C& db)
1763 if (last - first >= 4 && first[0] == 'D')
1765 switch (first[1])
1770 const char* t = parse_expression(first+2, last, db);
1771 if (t != first+2 && t != last && *t == 'E')
1774 return first;
1776 first = t+1;
1782 return first;
1794 parse_vector_type(const char* first, const char* last, C& db)
1796 if (last - first > 3 && first[0] == 'D' && first[1] == 'v')
1798 if ('1' <= first[2] && first[2] <= '9')
1800 const char* t = parse_number(first+2, last);
1802 return first;
1803 const char* num = first + 2;
1813 return first;
1814 db.names.back().first += " vector[" + typename C::String(num, sz) + "]";
1815 first = t1;
1822 first = t;
1829 const char* t1 = first+2;
1836 return first;
1848 return first;
1849 db.names.back().first += " vector[" + num + "]";
1850 first = t;
1855 return first;
1883 parse_type(const char* first, const char* last, C& db)
1885 if (first != last)
1887 switch (*first)
1894 const char* t = parse_cv_qualifiers(first, last, cv);
1895 if (t != first)
1931 db.names[k].first.append(" const");
1933 db.names[k].first.append(" volatile");
1935 db.names[k].first.append(" restrict");
1939 first = t1;
1946 const char* t = parse_builtin_type(first, last, db);
1947 if (t != first)
1949 first = t;
1953 switch (*first)
1956 t = parse_array_type(first, last, db);
1957 if (t != first)
1960 return first;
1961 first = t;
1966 t = parse_type(first+1, last, db);
1967 if (t != first+1)
1970 return first;
1971 db.names.back().first.append(" complex");
1972 first = t;
1977 t = parse_function_type(first, last, db);
1978 if (t != first)
1981 return first;
1982 first = t;
1987 t = parse_type(first+1, last, db);
1988 if (t != first+1)
1991 return first;
1992 db.names.back().first.append(" imaginary");
1993 first = t;
1998 t = parse_pointer_to_member_type(first, last, db);
1999 if (t != first)
2002 return first;
2003 first = t;
2010 t = parse_type(first+1, last, db);
2012 if (t != first+1)
2019 db.names[k].first += " (";
2024 db.names[k].first += "(";
2027 db.names[k].first.append("&&");
2030 first = t;
2037 t = parse_type(first+1, last, db);
2039 if (t != first+1)
2046 db.names[k].first += " (";
2051 db.names[k].first += "(";
2054 if (first[1] != 'U' || db.names[k].first.substr(0, 12) != "objc_object<")
2056 db.names[k].first.append("*");
2060 db.names[k].first.replace(0, 11, "id");
2064 first = t;
2071 t = parse_type(first+1, last, db);
2073 if (t != first+1)
2080 db.names[k].first += " (";
2085 db.names[k].first += "(";
2088 db.names[k].first.append("&");
2091 first = t;
2098 t = parse_template_param(first, last, db);
2100 if (t != first)
2112 db.names.back().first += std::move(args);
2117 first = t;
2122 if (first+1 != last)
2124 t = parse_source_name(first+1, last, db);
2125 if (t != first+1)
2131 return first;
2134 if (db.names.back().first.substr(0, 9) != "objcproto")
2153 first = t2;
2159 if (first+1 != last && first[1] == 't')
2161 t = parse_name(first, last, db);
2162 if (t != first)
2165 return first;
2167 first = t;
2172 t = parse_substitution(first, last, db);
2173 if (t != first)
2175 first = t;
2178 t = parse_template_args(first, last, db);
2179 if (t != first)
2182 return first;
2185 db.names.back().first += template_args;
2188 first = t;
2194 if (first+1 != last)
2196 switch (first[1])
2201 t = parse_type(first+2, last, db);
2203 if (t != first+2)
2208 first = t;
2209 return first;
2215 t = parse_decltype(first, last, db);
2216 if (t != first)
2219 return first;
2221 first = t;
2222 return first;
2226 t = parse_vector_type(first, last, db);
2227 if (t != first)
2230 return first;
2232 first = t;
2233 return first;
2242 t = parse_builtin_type(first, last, db);
2243 if (t != first)
2245 first = t;
2249 t = parse_name(first, last, db);
2250 if (t != first)
2253 return first;
2255 first = t;
2265 return first;
2322 parse_operator_name(const char* first, const char* last, C& db)
2324 if (last - first >= 2)
2326 switch (first[0])
2329 switch (first[1])
2333 first += 2;
2338 first += 2;
2342 first += 2;
2346 first += 2;
2351 switch (first[1])
2355 first += 2;
2359 first += 2;
2363 first += 2;
2369 const char* t = parse_type(first+2, last, db);
2371 if (t != first+2)
2374 return first;
2375 db.names.back().first.insert(0, "operator ");
2377 first = t;
2384 switch (first[1])
2388 first += 2;
2392 first += 2;
2396 first += 2;
2400 first += 2;
2404 first += 2;
2409 switch (first[1])
2413 first += 2;
2417 first += 2;
2421 first += 2;
2426 switch (first[1])
2430 first += 2;
2434 first += 2;
2439 if (first[1] == 'x')
2442 first += 2;
2446 switch (first[1])
2450 first += 2;
2454 const char* t = parse_source_name(first+2, last, db);
2455 if (t != first+2)
2458 return first;
2459 db.names.back().first.insert(0, "operator\"\" ");
2460 first = t;
2466 first += 2;
2470 first += 2;
2474 first += 2;
2479 switch (first[1])
2483 first += 2;
2487 first += 2;
2491 first += 2;
2495 first += 2;
2499 first += 2;
2504 switch (first[1])
2508 first += 2;
2512 first += 2;
2516 first += 2;
2520 first += 2;
2524 first += 2;
2529 switch (first[1])
2533 first += 2;
2537 first += 2;
2541 first += 2;
2546 switch (first[1])
2550 first += 2;
2554 first += 2;
2558 first += 2;
2562 first += 2;
2566 first += 2;
2570 first += 2;
2575 if (first[1] == 'u')
2578 first += 2;
2582 switch (first[1])
2586 first += 2;
2590 first += 2;
2594 first += 2;
2598 first += 2;
2603 if (std::isdigit(first[1]))
2605 const char* t = parse_source_name(first+2, last, db);
2606 if (t != first+2)
2609 return first;
2610 db.names.back().first.insert(0, "operator ");
2611 first = t;
2617 return first;
2622 parse_integer_literal(const char* first, const char* last, const typename C::String& lit, C& db)
2624 const char* t = parse_number(first, last);
2625 if (t != first && t != last && *t == 'E')
2631 if (*first == 'n')
2633 db.names.back().first += '-';
2634 ++first;
2636 db.names.back().first.append(first, t);
2638 db.names.back().first += lit;
2639 first = t+1;
2641 return first;
2653 parse_expr_primary(const char* first, const char* last, C& db)
2655 if (last - first >= 4 && *first == 'L')
2657 switch (first[1])
2661 const char* t = parse_integer_literal(first+2, last, "wchar_t", db);
2662 if (t != first+2)
2663 first = t;
2667 if (first[3] == 'E')
2669 switch (first[2])
2673 first += 4;
2677 first += 4;
2684 const char* t = parse_integer_literal(first+2, last, "char", db);
2685 if (t != first+2)
2686 first = t;
2691 const char* t = parse_integer_literal(first+2, last, "signed char", db);
2692 if (t != first+2)
2693 first = t;
2698 const char* t = parse_integer_literal(first+2, last, "unsigned char", db);
2699 if (t != first+2)
2700 first = t;
2705 const char* t = parse_integer_literal(first+2, last, "short", db);
2706 if (t != first+2)
2707 first = t;
2712 const char* t = parse_integer_literal(first+2, last, "unsigned short", db);
2713 if (t != first+2)
2714 first = t;
2719 const char* t = parse_integer_literal(first+2, last, "", db);
2720 if (t != first+2)
2721 first = t;
2726 const char* t = parse_integer_literal(first+2, last, "u", db);
2727 if (t != first+2)
2728 first = t;
2733 const char* t = parse_integer_literal(first+2, last, "l", db);
2734 if (t != first+2)
2735 first = t;
2740 const char* t = parse_integer_literal(first+2, last, "ul", db);
2741 if (t != first+2)
2742 first = t;
2747 const char* t = parse_integer_literal(first+2, last, "ll", db);
2748 if (t != first+2)
2749 first = t;
2754 const char* t = parse_integer_literal(first+2, last, "ull", db);
2755 if (t != first+2)
2756 first = t;
2761 const char* t = parse_integer_literal(first+2, last, "__int128", db);
2762 if (t != first+2)
2763 first = t;
2768 const char* t = parse_integer_literal(first+2, last, "unsigned __int128", db);
2769 if (t != first+2)
2770 first = t;
2775 const char* t = parse_floating_number<float>(first+2, last, db);
2776 if (t != first+2)
2777 first = t;
2782 const char* t = parse_floating_number<double>(first+2, last, db);
2783 if (t != first+2)
2784 first = t;
2789 const char* t = parse_floating_number<long double>(first+2, last, db);
2790 if (t != first+2)
2791 first = t;
2795 if (first[2] == 'Z')
2797 const char* t = parse_encoding(first+3, last, db);
2798 if (t != first+3 && t != last && *t == 'E')
2799 first = t+1;
2809 const char* t = parse_type(first+1, last, db);
2810 if (t != first+1 && t != last)
2820 return first;
2822 first = n+1;
2828 first = t+1;
2835 return first;
2908 parse_ctor_dtor_name(const char* first, const char* last, C& db)
2910 if (last-first >= 2 && !db.names.empty())
2912 switch (first[0])
2915 switch (first[1])
2922 return first;
2923 db.names.push_back(base_name(db.names.back().first));
2924 first += 2;
2930 switch (first[1])
2937 return first;
2938 db.names.push_back("~" + base_name(db.names.back().first));
2939 first += 2;
2946 return first;
2958 parse_unnamed_type_name(const char* first, const char* last, C& db)
2960 if (last - first > 2 && first[0] == 'U')
2962 char type = first[1];
2968 const char* t0 = first+2;
2972 return first;
2979 db.names.back().first.append(t0, t1);
2982 db.names.back().first.push_back('\'');
2986 return first;
2988 first = t0 + 1;
2994 const char* t0 = first+2;
2995 if (first[2] == 'v')
2997 db.names.back().first += ')';
3006 return first;
3009 return first;
3012 db.names.back().first.append(tmp);
3020 return first;
3025 db.names.back().first.append(", ");
3026 db.names.back().first.append(tmp);
3030 db.names.back().first.append(")");
3035 return first;
3041 return first;
3048 db.names.back().first.insert(db.names.back().first.begin()+7, t0, t1);
3054 return first;
3056 first = t0 + 1;
3061 return first;
3071 parse_unqualified_name(const char* first, const char* last, C& db)
3073 if (first != last)
3076 switch (*first)
3080 t = parse_ctor_dtor_name(first, last, db);
3081 if (t != first)
3082 first = t;
3085 t = parse_unnamed_type_name(first, last, db);
3086 if (t != first)
3087 first = t;
3098 t = parse_source_name(first, last, db);
3099 if (t != first)
3100 first = t;
3103 t = parse_operator_name(first, last, db);
3104 if (t != first)
3105 first = t;
3109 return first;
3118 parse_unscoped_name(const char* first, const char* last, C& db)
3120 if (last - first >= 2)
3122 const char* t0 = first;
3124 if (first[0] == 'S' && first[1] == 't')
3137 return first;
3138 db.names.back().first.insert(0, "std::");
3140 first = t1;
3143 return first;
3150 parse_alignof_type(const char* first, const char* last, C& db)
3152 if (last - first >= 3 && first[0] == 'a' && first[1] == 't')
3154 const char* t = parse_type(first+2, last, db);
3155 if (t != first+2)
3158 return first;
3159 db.names.back().first = "alignof (" + db.names.back().move_full() + ")";
3160 first = t;
3163 return first;
3170 parse_alignof_expr(const char* first, const char* last, C& db)
3172 if (last - first >= 3 && first[0] == 'a' && first[1] == 'z')
3174 const char* t = parse_expression(first+2, last, db);
3175 if (t != first+2)
3178 return first;
3179 db.names.back().first = "alignof (" + db.names.back().move_full() + ")";
3180 first = t;
3183 return first;
3188 parse_noexcept_expression(const char* first, const char* last, C& db)
3190 const char* t1 = parse_expression(first, last, db);
3191 if (t1 != first)
3194 return first;
3195 db.names.back().first = "noexcept (" + db.names.back().move_full() + ")";
3196 first = t1;
3198 return first;
3203 parse_prefix_expression(const char* first, const char* last, const typename C::String& op, C& db)
3205 const char* t1 = parse_expression(first, last, db);
3206 if (t1 != first)
3209 return first;
3210 db.names.back().first = op + "(" + db.names.back().move_full() + ")";
3211 first = t1;
3213 return first;
3218 parse_binary_expression(const char* first, const char* last, const typename C::String& op, C& db)
3220 const char* t1 = parse_expression(first, last, db);
3221 if (t1 != first)
3227 return first;
3231 auto& nm = db.names.back().first;
3238 first = t2;
3243 return first;
3288 parse_expression(const char* first, const char* last, C& db)
3290 if (last - first >= 2)
3292 const char* t = first;
3294 if (last - first >= 4 && t[0] == 'g' && t[1] == 's')
3302 first = parse_expr_primary(first, last, db);
3305 first = parse_template_param(first, last, db);
3308 first = parse_function_param(first, last, db);
3314 t = parse_binary_expression(first+2, last, "&&", db);
3315 if (t != first+2)
3316 first = t;
3319 t = parse_prefix_expression(first+2, last, "&", db);
3320 if (t != first+2)
3321 first = t;
3324 t = parse_binary_expression(first+2, last, "&", db);
3325 if (t != first+2)
3326 first = t;
3329 t = parse_binary_expression(first+2, last, "&=", db);
3330 if (t != first+2)
3331 first = t;
3334 t = parse_binary_expression(first+2, last, "=", db);
3335 if (t != first+2)
3336 first = t;
3339 first = parse_alignof_type(first, last, db);
3342 first = parse_alignof_expr(first, last, db);
3350 first = parse_const_cast_expr(first, last, db);
3353 first = parse_call_expr(first, last, db);
3356 t = parse_binary_expression(first+2, last, ",", db);
3357 if (t != first+2)
3358 first = t;
3361 t = parse_prefix_expression(first+2, last, "~", db);
3362 if (t != first+2)
3363 first = t;
3366 first = parse_conversion_expr(first, last, db);
3379 return first;
3380 db.names.back().first = (parsed_gs ? typename C::String("::") : typename C::String()) +
3382 first = t1;
3387 first = parse_dynamic_cast_expr(first, last, db);
3390 t = parse_prefix_expression(first+2, last, "*", db);
3391 if (t != first+2)
3392 first = t;
3400 return first;
3401 db.names.back().first = (parsed_gs ? typename C::String("::") : typename C::String()) +
3403 first = t1;
3408 return parse_unresolved_name(first, last, db);
3410 first = parse_dot_star_expr(first, last, db);
3413 first = parse_dot_expr(first, last, db);
3416 t = parse_binary_expression(first+2, last, "/", db);
3417 if (t != first+2)
3418 first = t;
3421 t = parse_binary_expression(first+2, last, "/=", db);
3422 if (t != first+2)
3423 first = t;
3431 t = parse_binary_expression(first+2, last, "^", db);
3432 if (t != first+2)
3433 first = t;
3436 t = parse_binary_expression(first+2, last, "^=", db);
3437 if (t != first+2)
3438 first = t;
3441 t = parse_binary_expression(first+2, last, "==", db);
3442 if (t != first+2)
3443 first = t;
3451 t = parse_binary_expression(first+2, last, ">=", db);
3452 if (t != first+2)
3453 first = t;
3456 t = parse_binary_expression(first+2, last, ">", db);
3457 if (t != first+2)
3458 first = t;
3465 const char* t1 = parse_expression(first+2, last, db);
3466 if (t1 != first+2)
3472 return first;
3477 first = t2;
3488 t = parse_binary_expression(first+2, last, "<=", db);
3489 if (t != first+2)
3490 first = t;
3493 t = parse_binary_expression(first+2, last, "<<", db);
3494 if (t != first+2)
3495 first = t;
3498 t = parse_binary_expression(first+2, last, "<<=", db);
3499 if (t != first+2)
3500 first = t;
3503 t = parse_binary_expression(first+2, last, "<", db);
3504 if (t != first+2)
3505 first = t;
3513 t = parse_binary_expression(first+2, last, "-", db);
3514 if (t != first+2)
3515 first = t;
3518 t = parse_binary_expression(first+2, last, "-=", db);
3519 if (t != first+2)
3520 first = t;
3523 t = parse_binary_expression(first+2, last, "*", db);
3524 if (t != first+2)
3525 first = t;
3528 t = parse_binary_expression(first+2, last, "*=", db);
3529 if (t != first+2)
3530 first = t;
3533 if (first+2 != last && first[2] == '_')
3535 t = parse_prefix_expression(first+3, last, "--", db);
3536 if (t != first+3)
3537 first = t;
3541 const char* t1 = parse_expression(first+2, last, db);
3542 if (t1 != first+2)
3545 return first;
3547 first = t1;
3558 first = parse_new_expr(first, last, db);
3561 t = parse_binary_expression(first+2, last, "!=", db);
3562 if (t != first+2)
3563 first = t;
3566 t = parse_prefix_expression(first+2, last, "-", db);
3567 if (t != first+2)
3568 first = t;
3571 t = parse_prefix_expression(first+2, last, "!", db);
3572 if (t != first+2)
3573 first = t;
3576 t = parse_noexcept_expression(first+2, last, db);
3577 if (t != first+2)
3578 first = t;
3586 return parse_unresolved_name(first, last, db);
3588 t = parse_binary_expression(first+2, last, "||", db);
3589 if (t != first+2)
3590 first = t;
3593 t = parse_binary_expression(first+2, last, "|", db);
3594 if (t != first+2)
3595 first = t;
3598 t = parse_binary_expression(first+2, last, "|=", db);
3599 if (t != first+2)
3600 first = t;
3608 t = parse_binary_expression(first+2, last, "->*", db);
3609 if (t != first+2)
3610 first = t;
3613 t = parse_binary_expression(first+2, last, "+", db);
3614 if (t != first+2)
3615 first = t;
3618 t = parse_binary_expression(first+2, last, "+=", db);
3619 if (t != first+2)
3620 first = t;
3623 if (first+2 != last && first[2] == '_')
3625 t = parse_prefix_expression(first+3, last, "++", db);
3626 if (t != first+3)
3627 first = t;
3631 const char* t1 = parse_expression(first+2, last, db);
3632 if (t1 != first+2)
3635 return first;
3637 first = t1;
3642 t = parse_prefix_expression(first+2, last, "+", db);
3643 if (t != first+2)
3644 first = t;
3647 first = parse_arrow_expr(first, last, db);
3654 const char* t1 = parse_expression(first+2, last, db);
3655 if (t1 != first+2)
3664 return first;
3671 first = t3;
3688 first = parse_reinterpret_cast_expr(first, last, db);
3691 t = parse_binary_expression(first+2, last, "%", db);
3692 if (t != first+2)
3693 first = t;
3696 t = parse_binary_expression(first+2, last, "%=", db);
3697 if (t != first+2)
3698 first = t;
3701 t = parse_binary_expression(first+2, last, ">>", db);
3702 if (t != first+2)
3703 first = t;
3706 t = parse_binary_expression(first+2, last, ">>=", db);
3707 if (t != first+2)
3708 first = t;
3716 first = parse_static_cast_expr(first, last, db);
3719 first = parse_pack_expansion(first, last, db);
3722 return parse_unresolved_name(first, last, db);
3724 first = parse_sizeof_type_expr(first, last, db);
3727 first = parse_sizeof_expr_expr(first, last, db);
3735 first = parse_sizeof_param_pack_expr(first, last, db);
3738 first = parse_sizeof_function_param_pack_expr(first, last, db);
3750 first = parse_typeid_expr(first, last, db);
3754 first += 2;
3757 first = parse_throw_expr(first, last, db);
3770 return parse_unresolved_name(first, last, db);
3773 return first;
3784 parse_template_arg(const char* first, const char* last, C& db)
3786 if (first != last)
3789 switch (*first)
3792 t = parse_expression(first+1, last, db);
3793 if (t != first+1)
3796 first = t+1;
3800 t = first+1;
3802 return first;
3807 return first;
3810 first = t+1;
3814 if (first+1 != last && first[1] == 'Z')
3816 t = parse_encoding(first+2, last, db);
3817 if (t != first+2 && t != last && *t == 'E')
3818 first = t+1;
3821 first = parse_expr_primary(first, last, db);
3825 first = parse_type(first, last, db);
3829 return first;
3837 parse_template_args(const char* first, const char* last, C& db)
3839 if (last - first >= 2 && *first == 'I')
3843 const char* t = first+1;
3855 return first;
3872 first = t + 1;
3880 return first;
3901 parse_nested_name(const char* first, const char* last, C& db,
3904 if (first != last && *first == 'N')
3907 const char* t0 = parse_cv_qualifiers(first+1, last, cv);
3909 return first;
3925 db.names.back().first = "std";
3930 return first;
3948 if (!db.names.back().first.empty())
3950 db.names.back().first += "::" + name;
3954 db.names.back().first = name;
3959 return first;
3967 if (!db.names.back().first.empty())
3968 db.names.back().first += "::" + name;
3970 db.names.back().first = name;
3976 return first;
3986 if (!db.names.back().first.empty())
3987 db.names.back().first += "::" + name;
3989 db.names.back().first = name;
3995 return first;
4003 db.names.back().first += name;
4009 return first;
4013 return first;
4022 if (!db.names.back().first.empty())
4023 db.names.back().first += "::" + name;
4025 db.names.back().first = name;
4031 return first;
4034 first = t0 + 1;
4041 return first;
4049 parse_discriminator(const char* first, const char* last)
4052 if (first != last)
4054 if (*first == '_')
4056 const char* t1 = first+1;
4060 first = t1+1;
4066 first = t1 + 1;
4070 else if (std::isdigit(*first))
4072 const char* t1 = first+1;
4075 first = t1;
4078 return first;
4087 parse_local_name(const char* first, const char* last, C& db,
4090 if (first != last && *first == 'Z')
4092 const char* t = parse_encoding(first+1, last, db);
4093 if (t != first+1 && t != last && *t == 'E' && ++t != last)
4098 first = parse_discriminator(t+1, last);
4100 return first;
4101 db.names.back().first.append("::string literal");
4115 return first;
4118 db.names.back().first.append("::");
4119 db.names.back().first.append(name);
4120 first = t1;
4134 first = parse_discriminator(t1, last);
4136 return first;
4139 db.names.back().first.append("::");
4140 db.names.back().first.append(name);
4149 return first;
4162 parse_name(const char* first, const char* last, C& db,
4165 if (last - first >= 2)
4167 const char* t0 = first;
4178 first = t1;
4186 first = t1;
4197 return first;
4204 return first;
4207 db.names.back().first += tmp;
4208 first = t1;
4214 first = t1;
4226 return first;
4229 db.names.back().first += tmp;
4230 first = t1;
4240 return first;
4253 parse_call_offset(const char* first, const char* last)
4255 if (first != last)
4257 switch (*first)
4261 const char* t = parse_number(first + 1, last);
4262 if (t != first + 1 && t != last && *t == '_')
4263 first = t + 1;
4268 const char* t = parse_number(first + 1, last);
4269 if (t != first + 1 && t != last && *t == '_')
4273 first = t2 + 1;
4279 return first;
4288 // # first call-offset is 'this' adjustment
4294 // extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first
4299 parse_special_name(const char* first, const char* last, C& db)
4301 if (last - first > 2)
4304 switch (*first)
4307 switch (first[1])
4311 t = parse_type(first+2, last, db);
4312 if (t != first+2)
4315 return first;
4316 db.names.back().first.insert(0, "vtable for ");
4317 first = t;
4322 t = parse_type(first+2, last, db);
4323 if (t != first+2)
4326 return first;
4327 db.names.back().first.insert(0, "VTT for ");
4328 first = t;
4333 t = parse_type(first+2, last, db);
4334 if (t != first+2)
4337 return first;
4338 db.names.back().first.insert(0, "typeinfo for ");
4339 first = t;
4344 t = parse_type(first+2, last, db);
4345 if (t != first+2)
4348 return first;
4349 db.names.back().first.insert(0, "typeinfo name for ");
4350 first = t;
4356 const char* t0 = parse_call_offset(first+2, last);
4357 if (t0 == first+2)
4366 return first;
4367 db.names.back().first.insert(0, "covariant return thunk to ");
4368 first = t;
4373 // extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first
4374 t = parse_type(first+2, last, db);
4375 if (t != first+2)
4384 return first;
4387 db.names.back().first = "construction vtable for " +
4390 first = t1;
4398 const char* t0 = parse_call_offset(first+1, last);
4399 if (t0 == first+1)
4405 return first;
4406 if (first[2] == 'v')
4408 db.names.back().first.insert(0, "virtual thunk to ");
4409 first = t;
4413 db.names.back().first.insert(0, "non-virtual thunk to ");
4414 first = t;
4422 switch (first[1])
4426 t = parse_name(first+2, last, db);
4427 if (t != first+2)
4430 return first;
4431 db.names.back().first.insert(0, "guard variable for ");
4432 first = t;
4437 t = parse_name(first+2, last, db);
4438 if (t != first+2)
4441 return first;
4442 db.names.back().first.insert(0, "reference temporary for ");
4443 first = t;
4450 return first;
4479 parse_encoding(const char* first, const char* last, C& db)
4481 if (first != last)
4488 switch (*first)
4492 first = parse_special_name(first, last, db);
4497 const char* t = parse_name(first, last, db,
4501 if (t != first)
4510 return first;
4511 const typename C::String& nm = db.names.back().first;
4513 return first;
4518 return first;
4520 return first;
4521 auto ret1 = std::move(db.names.back().first);
4526 db.names.back().first.insert(0, ret1);
4529 db.names.back().first += '(';
4558 return first;
4560 db.names.back().first += ", ";
4563 db.names.back().first += tmp;
4570 return first;
4571 db.names.back().first += ')';
4573 db.names.back().first.append(" const");
4575 db.names.back().first.append(" volatile");
4577 db.names.back().first.append(" restrict");
4579 db.names.back().first.append(" &");
4581 db.names.back().first.append(" &&");
4582 db.names.back().first += ret2;
4583 first = t;
4586 first = t;
4592 return first;
4601 parse_block_invoke(const char* first, const char* last, C& db)
4603 if (last - first >= 13)
4606 const char* t = first;
4610 return first;
4618 return first;
4626 return first;
4627 db.names.back().first.insert(0, "invocation function for block in ");
4628 first = t;
4630 return first;
4638 parse_dot_suffix(const char* first, const char* last, C& db)
4640 if (first != last && *first == '.')
4643 return first;
4644 db.names.back().first += " (" + typename C::String(first, last) + ")";
4645 first = last;
4647 return first;
4658 demangle(const char* first, const char* last, C& db, int& status)
4660 if (first >= last)
4665 if (*first == '_')
4667 if (last - first >= 4)
4669 if (first[1] == 'Z')
4671 const char* t = parse_encoding(first+2, last, db);
4672 if (t != first+2 && t != last && *t == '.')
4677 else if (first[1] == '_' && first[2] == '_' && first[3] == 'Z')
4679 const char* t = parse_encoding(first+4, last, db);
4680 if (t != first+4 && t != last)
4697 const char* t = parse_type(first, last, db);
4854 StrT first;
4858 string_pair(StrT f) : first(std::move(f)) {}
4860 : first(std::move(f)), second(std::move(s)) {}
4862 string_pair(const char (&s)[N]) : first(s, N-1) {}
4864 size_t size() const {return first.size() + second.size();}
4865 StrT full() const {return first + second;}
4866 StrT move_full() {return std::move(first) + std::move(second);}
4953 db.names.back().first += db.names.back().second;
4954 std::memcpy(buf, db.names.back().first.data(), sz-1);