| //===- ItaniumDemangle.cpp ------------------------------------------------===// | |
| // | |
| // The LLVM Compiler Infrastructure | |
| // | |
| // This file is dual licensed under the MIT and the University of Illinois Open | |
| // Source Licenses. See LICENSE.TXT for details. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "llvm/Demangle/Demangle.h" | |
| // This file exports a single function: llvm::itanium_demangle. | |
| // It also has no dependencies on the rest of llvm. It is implemented this way | |
| // so that it can be easily reused in libcxxabi. | |
| #include <algorithm> | |
| #include <cctype> | |
| #include <cstdlib> | |
| #include <cstring> | |
| #include <numeric> | |
| #include <string> | |
| #include <vector> | |
| #ifdef _MSC_VER | |
| // snprintf is implemented in VS 2015 | |
| #if _MSC_VER < 1900 | |
| #define snprintf _snprintf_s | |
| #endif | |
| #endif | |
| enum { | |
| unknown_error = -4, | |
| invalid_args = -3, | |
| invalid_mangled_name, | |
| memory_alloc_failure, | |
| success | |
| }; | |
| template <class C> | |
| static const char *parse_type(const char *first, const char *last, C &db); | |
| template <class C> | |
| static const char *parse_encoding(const char *first, const char *last, C &db); | |
| template <class C> | |
| static const char *parse_name(const char *first, const char *last, C &db, | |
| bool *ends_with_template_args = 0); | |
| template <class C> | |
| static const char *parse_expression(const char *first, const char *last, C &db); | |
| template <class C> | |
| static const char *parse_template_args(const char *first, const char *last, | |
| C &db); | |
| template <class C> | |
| static const char *parse_operator_name(const char *first, const char *last, | |
| C &db); | |
| template <class C> | |
| static const char *parse_unqualified_name(const char *first, const char *last, | |
| C &db); | |
| template <class C> | |
| static const char *parse_decltype(const char *first, const char *last, C &db); | |
| // <number> ::= [n] <non-negative decimal integer> | |
| static const char *parse_number(const char *first, const char *last) { | |
| if (first != last) { | |
| const char *t = first; | |
| if (*t == 'n') | |
| ++t; | |
| if (t != last) { | |
| if (*t == '0') { | |
| first = t + 1; | |
| } else if ('1' <= *t && *t <= '9') { | |
| first = t + 1; | |
| while (first != last && std::isdigit(*first)) | |
| ++first; | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| namespace { | |
| template <class Float> struct float_data; | |
| template <> struct float_data<float> { | |
| static const size_t mangled_size = 8; | |
| static const size_t max_demangled_size = 24; | |
| static const char *spec; | |
| }; | |
| const char *float_data<float>::spec = "%af"; | |
| template <> struct float_data<double> { | |
| static const size_t mangled_size = 16; | |
| static const size_t max_demangled_size = 32; | |
| static const char *spec; | |
| }; | |
| const char *float_data<double>::spec = "%a"; | |
| template <> struct float_data<long double> { | |
| #if defined(__mips__) && defined(__mips_n64) || defined(__aarch64__) || \ | |
| defined(__wasm__) | |
| static const size_t mangled_size = 32; | |
| #elif defined(__arm__) || defined(__mips__) || defined(__hexagon__) | |
| static const size_t mangled_size = 16; | |
| #else | |
| static const size_t mangled_size = | |
| 20; // May need to be adjusted to 16 or 24 on other platforms | |
| #endif | |
| static const size_t max_demangled_size = 40; | |
| static const char *spec; | |
| }; | |
| const char *float_data<long double>::spec = "%LaL"; | |
| } | |
| template <class Float, class C> | |
| static const char *parse_floating_number(const char *first, const char *last, | |
| C &db) { | |
| const size_t N = float_data<Float>::mangled_size; | |
| if (static_cast<std::size_t>(last - first) > N) { | |
| last = first + N; | |
| union { | |
| Float value; | |
| char buf[sizeof(Float)]; | |
| }; | |
| const char *t = first; | |
| char *e = buf; | |
| for (; t != last; ++t, ++e) { | |
| if (!isxdigit(*t)) | |
| return first; | |
| unsigned d1 = isdigit(*t) ? static_cast<unsigned>(*t - '0') | |
| : static_cast<unsigned>(*t - 'a' + 10); | |
| ++t; | |
| unsigned d0 = isdigit(*t) ? static_cast<unsigned>(*t - '0') | |
| : static_cast<unsigned>(*t - 'a' + 10); | |
| *e = static_cast<char>((d1 << 4) + d0); | |
| } | |
| if (*t == 'E') { | |
| #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ | |
| std::reverse(buf, e); | |
| #endif | |
| char num[float_data<Float>::max_demangled_size] = {0}; | |
| int n = snprintf(num, sizeof(num), float_data<Float>::spec, value); | |
| if (static_cast<std::size_t>(n) >= sizeof(num)) | |
| return first; | |
| db.names.push_back(std::string(num, static_cast<std::size_t>(n))); | |
| first = t + 1; | |
| } | |
| } | |
| return first; | |
| } | |
| // <source-name> ::= <positive length number> <identifier> | |
| template <class C> | |
| static const char *parse_source_name(const char *first, const char *last, | |
| C &db) { | |
| if (first != last) { | |
| char c = *first; | |
| if (isdigit(c) && first + 1 != last) { | |
| const char *t = first + 1; | |
| size_t n = static_cast<size_t>(c - '0'); | |
| for (c = *t; isdigit(c); c = *t) { | |
| n = n * 10 + static_cast<size_t>(c - '0'); | |
| if (++t == last) | |
| return first; | |
| } | |
| if (static_cast<size_t>(last - t) >= n) { | |
| std::string r(t, n); | |
| if (r.substr(0, 10) == "_GLOBAL__N") | |
| db.names.push_back("(anonymous namespace)"); | |
| else | |
| db.names.push_back(std::move(r)); | |
| first = t + n; | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // <substitution> ::= S <seq-id> _ | |
| // ::= S_ | |
| // <substitution> ::= Sa # ::std::allocator | |
| // <substitution> ::= Sb # ::std::basic_string | |
| // <substitution> ::= Ss # ::std::basic_string < char, | |
| // ::std::char_traits<char>, | |
| // ::std::allocator<char> > | |
| // <substitution> ::= Si # ::std::basic_istream<char, std::char_traits<char> > | |
| // <substitution> ::= So # ::std::basic_ostream<char, std::char_traits<char> > | |
| // <substitution> ::= Sd # ::std::basic_iostream<char, std::char_traits<char> > | |
| template <class C> | |
| static const char *parse_substitution(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 2) { | |
| if (*first == 'S') { | |
| switch (first[1]) { | |
| case 'a': | |
| db.names.push_back("std::allocator"); | |
| first += 2; | |
| break; | |
| case 'b': | |
| db.names.push_back("std::basic_string"); | |
| first += 2; | |
| break; | |
| case 's': | |
| db.names.push_back("std::string"); | |
| first += 2; | |
| break; | |
| case 'i': | |
| db.names.push_back("std::istream"); | |
| first += 2; | |
| break; | |
| case 'o': | |
| db.names.push_back("std::ostream"); | |
| first += 2; | |
| break; | |
| case 'd': | |
| db.names.push_back("std::iostream"); | |
| first += 2; | |
| break; | |
| case '_': | |
| if (!db.subs.empty()) { | |
| for (const auto &n : db.subs.front()) | |
| db.names.push_back(n); | |
| first += 2; | |
| } | |
| break; | |
| default: | |
| if (std::isdigit(first[1]) || std::isupper(first[1])) { | |
| size_t sub = 0; | |
| const char *t = first + 1; | |
| if (std::isdigit(*t)) | |
| sub = static_cast<size_t>(*t - '0'); | |
| else | |
| sub = static_cast<size_t>(*t - 'A') + 10; | |
| for (++t; t != last && (std::isdigit(*t) || std::isupper(*t)); ++t) { | |
| sub *= 36; | |
| if (std::isdigit(*t)) | |
| sub += static_cast<size_t>(*t - '0'); | |
| else | |
| sub += static_cast<size_t>(*t - 'A') + 10; | |
| } | |
| if (t == last || *t != '_') | |
| return first; | |
| ++sub; | |
| if (sub < db.subs.size()) { | |
| for (const auto &n : db.subs[sub]) | |
| db.names.push_back(n); | |
| first = t + 1; | |
| } | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // <builtin-type> ::= v # void | |
| // ::= w # wchar_t | |
| // ::= b # bool | |
| // ::= c # char | |
| // ::= a # signed char | |
| // ::= h # unsigned char | |
| // ::= s # short | |
| // ::= t # unsigned short | |
| // ::= i # int | |
| // ::= j # unsigned int | |
| // ::= l # long | |
| // ::= m # unsigned long | |
| // ::= x # long long, __int64 | |
| // ::= y # unsigned long long, __int64 | |
| // ::= n # __int128 | |
| // ::= o # unsigned __int128 | |
| // ::= f # float | |
| // ::= d # double | |
| // ::= e # long double, __float80 | |
| // ::= g # __float128 | |
| // ::= z # ellipsis | |
| // ::= Dd # IEEE 754r decimal floating point (64 bits) | |
| // ::= De # IEEE 754r decimal floating point (128 bits) | |
| // ::= Df # IEEE 754r decimal floating point (32 bits) | |
| // ::= Dh # IEEE 754r half-precision floating point (16 bits) | |
| // ::= Di # char32_t | |
| // ::= Ds # char16_t | |
| // ::= Da # auto (in dependent new-expressions) | |
| // ::= Dc # decltype(auto) | |
| // ::= Dn # std::nullptr_t (i.e., decltype(nullptr)) | |
| // ::= u <source-name> # vendor extended type | |
| template <class C> | |
| static const char *parse_builtin_type(const char *first, const char *last, | |
| C &db) { | |
| if (first != last) { | |
| switch (*first) { | |
| case 'v': | |
| db.names.push_back("void"); | |
| ++first; | |
| break; | |
| case 'w': | |
| db.names.push_back("wchar_t"); | |
| ++first; | |
| break; | |
| case 'b': | |
| db.names.push_back("bool"); | |
| ++first; | |
| break; | |
| case 'c': | |
| db.names.push_back("char"); | |
| ++first; | |
| break; | |
| case 'a': | |
| db.names.push_back("signed char"); | |
| ++first; | |
| break; | |
| case 'h': | |
| db.names.push_back("unsigned char"); | |
| ++first; | |
| break; | |
| case 's': | |
| db.names.push_back("short"); | |
| ++first; | |
| break; | |
| case 't': | |
| db.names.push_back("unsigned short"); | |
| ++first; | |
| break; | |
| case 'i': | |
| db.names.push_back("int"); | |
| ++first; | |
| break; | |
| case 'j': | |
| db.names.push_back("unsigned int"); | |
| ++first; | |
| break; | |
| case 'l': | |
| db.names.push_back("long"); | |
| ++first; | |
| break; | |
| case 'm': | |
| db.names.push_back("unsigned long"); | |
| ++first; | |
| break; | |
| case 'x': | |
| db.names.push_back("long long"); | |
| ++first; | |
| break; | |
| case 'y': | |
| db.names.push_back("unsigned long long"); | |
| ++first; | |
| break; | |
| case 'n': | |
| db.names.push_back("__int128"); | |
| ++first; | |
| break; | |
| case 'o': | |
| db.names.push_back("unsigned __int128"); | |
| ++first; | |
| break; | |
| case 'f': | |
| db.names.push_back("float"); | |
| ++first; | |
| break; | |
| case 'd': | |
| db.names.push_back("double"); | |
| ++first; | |
| break; | |
| case 'e': | |
| db.names.push_back("long double"); | |
| ++first; | |
| break; | |
| case 'g': | |
| db.names.push_back("__float128"); | |
| ++first; | |
| break; | |
| case 'z': | |
| db.names.push_back("..."); | |
| ++first; | |
| break; | |
| case 'u': { | |
| const char *t = parse_source_name(first + 1, last, db); | |
| if (t != first + 1) | |
| first = t; | |
| } break; | |
| case 'D': | |
| if (first + 1 != last) { | |
| switch (first[1]) { | |
| case 'd': | |
| db.names.push_back("decimal64"); | |
| first += 2; | |
| break; | |
| case 'e': | |
| db.names.push_back("decimal128"); | |
| first += 2; | |
| break; | |
| case 'f': | |
| db.names.push_back("decimal32"); | |
| first += 2; | |
| break; | |
| case 'h': | |
| db.names.push_back("decimal16"); | |
| first += 2; | |
| break; | |
| case 'i': | |
| db.names.push_back("char32_t"); | |
| first += 2; | |
| break; | |
| case 's': | |
| db.names.push_back("char16_t"); | |
| first += 2; | |
| break; | |
| case 'a': | |
| db.names.push_back("auto"); | |
| first += 2; | |
| break; | |
| case 'c': | |
| db.names.push_back("decltype(auto)"); | |
| first += 2; | |
| break; | |
| case 'n': | |
| db.names.push_back("std::nullptr_t"); | |
| first += 2; | |
| break; | |
| } | |
| } | |
| break; | |
| } | |
| } | |
| return first; | |
| } | |
| // <CV-qualifiers> ::= [r] [V] [K] | |
| static const char *parse_cv_qualifiers(const char *first, const char *last, | |
| unsigned &cv) { | |
| cv = 0; | |
| if (first != last) { | |
| if (*first == 'r') { | |
| cv |= 4; | |
| ++first; | |
| } | |
| if (*first == 'V') { | |
| cv |= 2; | |
| ++first; | |
| } | |
| if (*first == 'K') { | |
| cv |= 1; | |
| ++first; | |
| } | |
| } | |
| return first; | |
| } | |
| // <template-param> ::= T_ # first template parameter | |
| // ::= T <parameter-2 non-negative number> _ | |
| template <class C> | |
| static const char *parse_template_param(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 2) { | |
| if (*first == 'T') { | |
| if (first[1] == '_') { | |
| if (db.template_param.empty()) | |
| return first; | |
| if (!db.template_param.back().empty()) { | |
| for (auto &t : db.template_param.back().front()) | |
| db.names.push_back(t); | |
| first += 2; | |
| } else { | |
| db.names.push_back("T_"); | |
| first += 2; | |
| db.fix_forward_references = true; | |
| } | |
| } else if (isdigit(first[1])) { | |
| const char *t = first + 1; | |
| size_t sub = static_cast<size_t>(*t - '0'); | |
| for (++t; t != last && isdigit(*t); ++t) { | |
| sub *= 10; | |
| sub += static_cast<size_t>(*t - '0'); | |
| } | |
| if (t == last || *t != '_' || db.template_param.empty()) | |
| return first; | |
| ++sub; | |
| if (sub < db.template_param.back().size()) { | |
| for (auto &temp : db.template_param.back()[sub]) | |
| db.names.push_back(temp); | |
| first = t + 1; | |
| } else { | |
| db.names.push_back(std::string(first, t + 1)); | |
| first = t + 1; | |
| db.fix_forward_references = true; | |
| } | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // cc <type> <expression> # const_cast<type> | |
| // (expression) | |
| template <class C> | |
| static const char *parse_const_cast_expr(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 3 && first[0] == 'c' && first[1] == 'c') { | |
| const char *t = parse_type(first + 2, last, db); | |
| if (t != first + 2) { | |
| const char *t1 = parse_expression(t, last, db); | |
| if (t1 != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto expr = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back() = | |
| "const_cast<" + db.names.back().move_full() + ">(" + expr + ")"; | |
| first = t1; | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // dc <type> <expression> # dynamic_cast<type> | |
| // (expression) | |
| template <class C> | |
| static const char *parse_dynamic_cast_expr(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 3 && first[0] == 'd' && first[1] == 'c') { | |
| const char *t = parse_type(first + 2, last, db); | |
| if (t != first + 2) { | |
| const char *t1 = parse_expression(t, last, db); | |
| if (t1 != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto expr = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back() = | |
| "dynamic_cast<" + db.names.back().move_full() + ">(" + expr + ")"; | |
| first = t1; | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // rc <type> <expression> # reinterpret_cast<type> | |
| // (expression) | |
| template <class C> | |
| static const char *parse_reinterpret_cast_expr(const char *first, | |
| const char *last, C &db) { | |
| if (last - first >= 3 && first[0] == 'r' && first[1] == 'c') { | |
| const char *t = parse_type(first + 2, last, db); | |
| if (t != first + 2) { | |
| const char *t1 = parse_expression(t, last, db); | |
| if (t1 != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto expr = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back() = "reinterpret_cast<" + db.names.back().move_full() + | |
| ">(" + expr + ")"; | |
| first = t1; | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // sc <type> <expression> # static_cast<type> | |
| // (expression) | |
| template <class C> | |
| static const char *parse_static_cast_expr(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 3 && first[0] == 's' && first[1] == 'c') { | |
| const char *t = parse_type(first + 2, last, db); | |
| if (t != first + 2) { | |
| const char *t1 = parse_expression(t, last, db); | |
| if (t1 != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto expr = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back() = | |
| "static_cast<" + db.names.back().move_full() + ">(" + expr + ")"; | |
| first = t1; | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // sp <expression> # pack expansion | |
| template <class C> | |
| static const char *parse_pack_expansion(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 3 && first[0] == 's' && first[1] == 'p') { | |
| const char *t = parse_expression(first + 2, last, db); | |
| if (t != first + 2) | |
| first = t; | |
| } | |
| return first; | |
| } | |
| // st <type> # sizeof (a type) | |
| template <class C> | |
| static const char *parse_sizeof_type_expr(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 3 && first[0] == 's' && first[1] == 't') { | |
| const char *t = parse_type(first + 2, last, db); | |
| if (t != first + 2) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back() = "sizeof (" + db.names.back().move_full() + ")"; | |
| first = t; | |
| } | |
| } | |
| return first; | |
| } | |
| // sz <expr> # sizeof (a expression) | |
| template <class C> | |
| static const char *parse_sizeof_expr_expr(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 3 && first[0] == 's' && first[1] == 'z') { | |
| const char *t = parse_expression(first + 2, last, db); | |
| if (t != first + 2) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back() = "sizeof (" + db.names.back().move_full() + ")"; | |
| first = t; | |
| } | |
| } | |
| return first; | |
| } | |
| // sZ <template-param> # size of a parameter | |
| // pack | |
| template <class C> | |
| static const char *parse_sizeof_param_pack_expr(const char *first, | |
| const char *last, C &db) { | |
| if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && | |
| first[2] == 'T') { | |
| size_t k0 = db.names.size(); | |
| const char *t = parse_template_param(first + 2, last, db); | |
| size_t k1 = db.names.size(); | |
| if (t != first + 2) { | |
| std::string tmp("sizeof...("); | |
| size_t k = k0; | |
| if (k != k1) { | |
| tmp += db.names[k].move_full(); | |
| for (++k; k != k1; ++k) | |
| tmp += ", " + db.names[k].move_full(); | |
| } | |
| tmp += ")"; | |
| for (; k1 != k0; --k1) | |
| db.names.pop_back(); | |
| db.names.push_back(std::move(tmp)); | |
| first = t; | |
| } | |
| } | |
| return first; | |
| } | |
| // <function-param> ::= fp <top-level CV-qualifiers> _ # L == 0, first parameter | |
| // ::= fp <top-level CV-qualifiers> <parameter-2 non-negative | |
| // number> _ # L == 0, second and later parameters | |
| // ::= fL <L-1 non-negative number> p <top-level CV-qualifiers> | |
| // _ # L > 0, first parameter | |
| // ::= fL <L-1 non-negative number> p <top-level CV-qualifiers> | |
| // <parameter-2 non-negative number> _ # L > 0, second and | |
| // later parameters | |
| template <class C> | |
| static const char *parse_function_param(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 3 && *first == 'f') { | |
| if (first[1] == 'p') { | |
| unsigned cv; | |
| const char *t = parse_cv_qualifiers(first + 2, last, cv); | |
| const char *t1 = parse_number(t, last); | |
| if (t1 != last && *t1 == '_') { | |
| db.names.push_back("fp" + std::string(t, t1)); | |
| first = t1 + 1; | |
| } | |
| } else if (first[1] == 'L') { | |
| unsigned cv; | |
| const char *t0 = parse_number(first + 2, last); | |
| if (t0 != last && *t0 == 'p') { | |
| ++t0; | |
| const char *t = parse_cv_qualifiers(t0, last, cv); | |
| const char *t1 = parse_number(t, last); | |
| if (t1 != last && *t1 == '_') { | |
| db.names.push_back("fp" + std::string(t, t1)); | |
| first = t1 + 1; | |
| } | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // sZ <function-param> # size of a function | |
| // parameter pack | |
| template <class C> | |
| static const char *parse_sizeof_function_param_pack_expr(const char *first, | |
| const char *last, | |
| C &db) { | |
| if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && | |
| first[2] == 'f') { | |
| const char *t = parse_function_param(first + 2, last, db); | |
| if (t != first + 2) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back() = "sizeof...(" + db.names.back().move_full() + ")"; | |
| first = t; | |
| } | |
| } | |
| return first; | |
| } | |
| // te <expression> # typeid (expression) | |
| // ti <type> # typeid (type) | |
| template <class C> | |
| static const char *parse_typeid_expr(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 3 && first[0] == 't' && | |
| (first[1] == 'e' || first[1] == 'i')) { | |
| const char *t; | |
| if (first[1] == 'e') | |
| t = parse_expression(first + 2, last, db); | |
| else | |
| t = parse_type(first + 2, last, db); | |
| if (t != first + 2) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back() = "typeid(" + db.names.back().move_full() + ")"; | |
| first = t; | |
| } | |
| } | |
| return first; | |
| } | |
| // tw <expression> # throw expression | |
| template <class C> | |
| static const char *parse_throw_expr(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 3 && first[0] == 't' && first[1] == 'w') { | |
| const char *t = parse_expression(first + 2, last, db); | |
| if (t != first + 2) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back() = "throw " + db.names.back().move_full(); | |
| first = t; | |
| } | |
| } | |
| return first; | |
| } | |
| // ds <expression> <expression> # expr.*expr | |
| template <class C> | |
| static const char *parse_dot_star_expr(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 3 && first[0] == 'd' && first[1] == 's') { | |
| const char *t = parse_expression(first + 2, last, db); | |
| if (t != first + 2) { | |
| const char *t1 = parse_expression(t, last, db); | |
| if (t1 != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto expr = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back().first += ".*" + expr; | |
| first = t1; | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // <simple-id> ::= <source-name> [ <template-args> ] | |
| template <class C> | |
| static const char *parse_simple_id(const char *first, const char *last, C &db) { | |
| if (first != last) { | |
| const char *t = parse_source_name(first, last, db); | |
| if (t != first) { | |
| const char *t1 = parse_template_args(t, last, db); | |
| if (t1 != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto args = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back().first += std::move(args); | |
| } | |
| first = t1; | |
| } else | |
| first = t; | |
| } | |
| return first; | |
| } | |
| // <unresolved-type> ::= <template-param> | |
| // ::= <decltype> | |
| // ::= <substitution> | |
| template <class C> | |
| static const char *parse_unresolved_type(const char *first, const char *last, | |
| C &db) { | |
| if (first != last) { | |
| const char *t = first; | |
| switch (*first) { | |
| case 'T': { | |
| size_t k0 = db.names.size(); | |
| t = parse_template_param(first, last, db); | |
| size_t k1 = db.names.size(); | |
| if (t != first && k1 == k0 + 1) { | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| first = t; | |
| } else { | |
| for (; k1 != k0; --k1) | |
| db.names.pop_back(); | |
| } | |
| break; | |
| } | |
| case 'D': | |
| t = parse_decltype(first, last, db); | |
| if (t != first) { | |
| if (db.names.empty()) | |
| return first; | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| first = t; | |
| } | |
| break; | |
| case 'S': | |
| t = parse_substitution(first, last, db); | |
| if (t != first) | |
| first = t; | |
| else { | |
| if (last - first > 2 && first[1] == 't') { | |
| t = parse_unqualified_name(first + 2, last, db); | |
| if (t != first + 2) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first.insert(0, "std::"); | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| first = t; | |
| } | |
| } | |
| } | |
| break; | |
| } | |
| } | |
| return first; | |
| } | |
| // <destructor-name> ::= <unresolved-type> # e.g., | |
| // ~T or ~decltype(f()) | |
| // ::= <simple-id> # e.g., | |
| // ~A<2*N> | |
| template <class C> | |
| static const char *parse_destructor_name(const char *first, const char *last, | |
| C &db) { | |
| if (first != last) { | |
| const char *t = parse_unresolved_type(first, last, db); | |
| if (t == first) | |
| t = parse_simple_id(first, last, db); | |
| if (t != first) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first.insert(0, "~"); | |
| first = t; | |
| } | |
| } | |
| return first; | |
| } | |
| // <base-unresolved-name> ::= <simple-id> # | |
| // unresolved name | |
| // extension ::= <operator-name> # | |
| // unresolved operator-function-id | |
| // extension ::= <operator-name> <template-args> # | |
| // unresolved operator template-id | |
| // ::= on <operator-name> # | |
| // unresolved operator-function-id | |
| // ::= on <operator-name> <template-args> # | |
| // unresolved operator template-id | |
| // ::= dn <destructor-name> # | |
| // destructor or pseudo-destructor; | |
| // # | |
| // e.g. | |
| // ~X or | |
| // ~X<N-1> | |
| template <class C> | |
| static const char *parse_base_unresolved_name(const char *first, | |
| const char *last, C &db) { | |
| if (last - first >= 2) { | |
| if ((first[0] == 'o' || first[0] == 'd') && first[1] == 'n') { | |
| if (first[0] == 'o') { | |
| const char *t = parse_operator_name(first + 2, last, db); | |
| if (t != first + 2) { | |
| first = parse_template_args(t, last, db); | |
| if (first != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto args = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back().first += std::move(args); | |
| } | |
| } | |
| } else { | |
| const char *t = parse_destructor_name(first + 2, last, db); | |
| if (t != first + 2) | |
| first = t; | |
| } | |
| } else { | |
| const char *t = parse_simple_id(first, last, db); | |
| if (t == first) { | |
| t = parse_operator_name(first, last, db); | |
| if (t != first) { | |
| first = parse_template_args(t, last, db); | |
| if (first != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto args = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back().first += std::move(args); | |
| } | |
| } | |
| } else | |
| first = t; | |
| } | |
| } | |
| return first; | |
| } | |
| // <unresolved-qualifier-level> ::= <simple-id> | |
| template <class C> | |
| static const char *parse_unresolved_qualifier_level(const char *first, | |
| const char *last, C &db) { | |
| return parse_simple_id(first, last, db); | |
| } | |
| // <unresolved-name> | |
| // extension ::= srN <unresolved-type> [<template-args>] | |
| // <unresolved-qualifier-level>* E <base-unresolved-name> | |
| // ::= [gs] <base-unresolved-name> # x or | |
| // (with "gs") ::x | |
| // ::= [gs] sr <unresolved-qualifier-level>+ E | |
| // <base-unresolved-name> | |
| // # A::x, | |
| // N::y, | |
| // A<T>::z; | |
| // "gs" | |
| // means | |
| // leading | |
| // "::" | |
| // ::= sr <unresolved-type> <base-unresolved-name> # T::x | |
| // / decltype(p)::x | |
| // extension ::= sr <unresolved-type> <template-args> | |
| // <base-unresolved-name> | |
| // # | |
| // T::N::x | |
| // /decltype(p)::N::x | |
| // (ignored) ::= srN <unresolved-type> <unresolved-qualifier-level>+ E | |
| // <base-unresolved-name> | |
| template <class C> | |
| static const char *parse_unresolved_name(const char *first, const char *last, | |
| C &db) { | |
| if (last - first > 2) { | |
| const char *t = first; | |
| bool global = false; | |
| if (t[0] == 'g' && t[1] == 's') { | |
| global = true; | |
| t += 2; | |
| } | |
| const char *t2 = parse_base_unresolved_name(t, last, db); | |
| if (t2 != t) { | |
| if (global) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first.insert(0, "::"); | |
| } | |
| first = t2; | |
| } else if (last - t > 2 && t[0] == 's' && t[1] == 'r') { | |
| if (t[2] == 'N') { | |
| t += 3; | |
| const char *t1 = parse_unresolved_type(t, last, db); | |
| if (t1 == t || t1 == last) | |
| return first; | |
| t = t1; | |
| t1 = parse_template_args(t, last, db); | |
| if (t1 != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto args = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back().first += std::move(args); | |
| t = t1; | |
| if (t == last) { | |
| db.names.pop_back(); | |
| return first; | |
| } | |
| } | |
| while (*t != 'E') { | |
| t1 = parse_unresolved_qualifier_level(t, last, db); | |
| if (t1 == t || t1 == last || db.names.size() < 2) | |
| return first; | |
| auto s = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back().first += "::" + std::move(s); | |
| t = t1; | |
| } | |
| ++t; | |
| t1 = parse_base_unresolved_name(t, last, db); | |
| if (t1 == t) { | |
| if (!db.names.empty()) | |
| db.names.pop_back(); | |
| return first; | |
| } | |
| if (db.names.size() < 2) | |
| return first; | |
| auto s = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back().first += "::" + std::move(s); | |
| first = t1; | |
| } else { | |
| t += 2; | |
| const char *t1 = parse_unresolved_type(t, last, db); | |
| if (t1 != t) { | |
| t = t1; | |
| t1 = parse_template_args(t, last, db); | |
| if (t1 != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto args = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back().first += std::move(args); | |
| t = t1; | |
| } | |
| t1 = parse_base_unresolved_name(t, last, db); | |
| if (t1 == t) { | |
| if (!db.names.empty()) | |
| db.names.pop_back(); | |
| return first; | |
| } | |
| if (db.names.size() < 2) | |
| return first; | |
| auto s = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back().first += "::" + std::move(s); | |
| first = t1; | |
| } else { | |
| t1 = parse_unresolved_qualifier_level(t, last, db); | |
| if (t1 == t || t1 == last) | |
| return first; | |
| t = t1; | |
| if (global) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first.insert(0, "::"); | |
| } | |
| while (*t != 'E') { | |
| t1 = parse_unresolved_qualifier_level(t, last, db); | |
| if (t1 == t || t1 == last || db.names.size() < 2) | |
| return first; | |
| auto s = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back().first += "::" + std::move(s); | |
| t = t1; | |
| } | |
| ++t; | |
| t1 = parse_base_unresolved_name(t, last, db); | |
| if (t1 == t) { | |
| if (!db.names.empty()) | |
| db.names.pop_back(); | |
| return first; | |
| } | |
| if (db.names.size() < 2) | |
| return first; | |
| auto s = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back().first += "::" + std::move(s); | |
| first = t1; | |
| } | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // dt <expression> <unresolved-name> # expr.name | |
| template <class C> | |
| static const char *parse_dot_expr(const char *first, const char *last, C &db) { | |
| if (last - first >= 3 && first[0] == 'd' && first[1] == 't') { | |
| const char *t = parse_expression(first + 2, last, db); | |
| if (t != first + 2) { | |
| const char *t1 = parse_unresolved_name(t, last, db); | |
| if (t1 != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto name = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first += "." + name; | |
| first = t1; | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // cl <expression>+ E # call | |
| template <class C> | |
| static const char *parse_call_expr(const char *first, const char *last, C &db) { | |
| if (last - first >= 4 && first[0] == 'c' && first[1] == 'l') { | |
| const char *t = parse_expression(first + 2, last, db); | |
| if (t != first + 2) { | |
| if (t == last) | |
| return first; | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first += db.names.back().second; | |
| db.names.back().second = std::string(); | |
| db.names.back().first.append("("); | |
| bool first_expr = true; | |
| while (*t != 'E') { | |
| const char *t1 = parse_expression(t, last, db); | |
| if (t1 == t || t1 == last) | |
| return first; | |
| if (db.names.empty()) | |
| return first; | |
| auto tmp = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| if (!tmp.empty()) { | |
| if (db.names.empty()) | |
| return first; | |
| if (!first_expr) { | |
| db.names.back().first.append(", "); | |
| first_expr = false; | |
| } | |
| db.names.back().first.append(tmp); | |
| } | |
| t = t1; | |
| } | |
| ++t; | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first.append(")"); | |
| first = t; | |
| } | |
| } | |
| return first; | |
| } | |
| // [gs] nw <expression>* _ <type> E # new (expr-list) type | |
| // [gs] nw <expression>* _ <type> <initializer> # new (expr-list) type | |
| // (init) | |
| // [gs] na <expression>* _ <type> E # new[] (expr-list) type | |
| // [gs] na <expression>* _ <type> <initializer> # new[] (expr-list) type | |
| // (init) | |
| // <initializer> ::= pi <expression>* E # parenthesized | |
| // initialization | |
| template <class C> | |
| static const char *parse_new_expr(const char *first, const char *last, C &db) { | |
| if (last - first >= 4) { | |
| const char *t = first; | |
| bool parsed_gs = false; | |
| if (t[0] == 'g' && t[1] == 's') { | |
| t += 2; | |
| parsed_gs = true; | |
| } | |
| if (t[0] == 'n' && (t[1] == 'w' || t[1] == 'a')) { | |
| bool is_array = t[1] == 'a'; | |
| t += 2; | |
| if (t == last) | |
| return first; | |
| bool has_expr_list = false; | |
| bool first_expr = true; | |
| while (*t != '_') { | |
| const char *t1 = parse_expression(t, last, db); | |
| if (t1 == t || t1 == last) | |
| return first; | |
| has_expr_list = true; | |
| if (!first_expr) { | |
| if (db.names.empty()) | |
| return first; | |
| auto tmp = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| if (!tmp.empty()) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first.append(", "); | |
| db.names.back().first.append(tmp); | |
| first_expr = false; | |
| } | |
| } | |
| t = t1; | |
| } | |
| ++t; | |
| const char *t1 = parse_type(t, last, db); | |
| if (t1 == t || t1 == last) | |
| return first; | |
| t = t1; | |
| bool has_init = false; | |
| if (last - t >= 3 && t[0] == 'p' && t[1] == 'i') { | |
| t += 2; | |
| has_init = true; | |
| first_expr = true; | |
| while (*t != 'E') { | |
| t1 = parse_expression(t, last, db); | |
| if (t1 == t || t1 == last) | |
| return first; | |
| if (!first_expr) { | |
| if (db.names.empty()) | |
| return first; | |
| auto tmp = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| if (!tmp.empty()) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first.append(", "); | |
| db.names.back().first.append(tmp); | |
| first_expr = false; | |
| } | |
| } | |
| t = t1; | |
| } | |
| } | |
| if (*t != 'E') | |
| return first; | |
| std::string init_list; | |
| if (has_init) { | |
| if (db.names.empty()) | |
| return first; | |
| init_list = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| } | |
| if (db.names.empty()) | |
| return first; | |
| auto type = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| std::string expr_list; | |
| if (has_expr_list) { | |
| if (db.names.empty()) | |
| return first; | |
| expr_list = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| } | |
| std::string r; | |
| if (parsed_gs) | |
| r = "::"; | |
| if (is_array) | |
| r += "[] "; | |
| else | |
| r += " "; | |
| if (has_expr_list) | |
| r += "(" + expr_list + ") "; | |
| r += type; | |
| if (has_init) | |
| r += " (" + init_list + ")"; | |
| db.names.push_back(std::move(r)); | |
| first = t + 1; | |
| } | |
| } | |
| return first; | |
| } | |
| // cv <type> <expression> # conversion with one | |
| // argument | |
| // cv <type> _ <expression>* E # conversion with a | |
| // different number of arguments | |
| template <class C> | |
| static const char *parse_conversion_expr(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 3 && first[0] == 'c' && first[1] == 'v') { | |
| bool try_to_parse_template_args = db.try_to_parse_template_args; | |
| db.try_to_parse_template_args = false; | |
| const char *t = parse_type(first + 2, last, db); | |
| db.try_to_parse_template_args = try_to_parse_template_args; | |
| if (t != first + 2 && t != last) { | |
| if (*t != '_') { | |
| const char *t1 = parse_expression(t, last, db); | |
| if (t1 == t) | |
| return first; | |
| t = t1; | |
| } else { | |
| ++t; | |
| if (t == last) | |
| return first; | |
| if (*t == 'E') | |
| db.names.emplace_back(); | |
| else { | |
| bool first_expr = true; | |
| while (*t != 'E') { | |
| const char *t1 = parse_expression(t, last, db); | |
| if (t1 == t || t1 == last) | |
| return first; | |
| if (!first_expr) { | |
| if (db.names.empty()) | |
| return first; | |
| auto tmp = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| if (!tmp.empty()) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first.append(", "); | |
| db.names.back().first.append(tmp); | |
| first_expr = false; | |
| } | |
| } | |
| t = t1; | |
| } | |
| } | |
| ++t; | |
| } | |
| if (db.names.size() < 2) | |
| return first; | |
| auto tmp = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back() = "(" + db.names.back().move_full() + ")(" + tmp + ")"; | |
| first = t; | |
| } | |
| } | |
| return first; | |
| } | |
| // pt <expression> <expression> # expr->name | |
| template <class C> | |
| static const char *parse_arrow_expr(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 3 && first[0] == 'p' && first[1] == 't') { | |
| const char *t = parse_expression(first + 2, last, db); | |
| if (t != first + 2) { | |
| const char *t1 = parse_expression(t, last, db); | |
| if (t1 != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto tmp = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back().first += "->"; | |
| db.names.back().first += tmp; | |
| first = t1; | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // <ref-qualifier> ::= R # & ref-qualifier | |
| // <ref-qualifier> ::= O # && ref-qualifier | |
| // <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] E | |
| template <class C> | |
| static const char *parse_function_type(const char *first, const char *last, | |
| C &db) { | |
| if (first != last && *first == 'F') { | |
| const char *t = first + 1; | |
| if (t != last) { | |
| if (*t == 'Y') { | |
| /* extern "C" */ | |
| if (++t == last) | |
| return first; | |
| } | |
| const char *t1 = parse_type(t, last, db); | |
| if (t1 != t) { | |
| t = t1; | |
| std::string sig("("); | |
| int ref_qual = 0; | |
| while (true) { | |
| if (t == last) { | |
| db.names.pop_back(); | |
| return first; | |
| } | |
| if (*t == 'E') { | |
| ++t; | |
| break; | |
| } | |
| if (*t == 'v') { | |
| ++t; | |
| continue; | |
| } | |
| if (*t == 'R' && t + 1 != last && t[1] == 'E') { | |
| ref_qual = 1; | |
| ++t; | |
| continue; | |
| } | |
| if (*t == 'O' && t + 1 != last && t[1] == 'E') { | |
| ref_qual = 2; | |
| ++t; | |
| continue; | |
| } | |
| size_t k0 = db.names.size(); | |
| t1 = parse_type(t, last, db); | |
| size_t k1 = db.names.size(); | |
| if (t1 == t || t1 == last) | |
| return first; | |
| for (size_t k = k0; k < k1; ++k) { | |
| if (sig.size() > 1) | |
| sig += ", "; | |
| sig += db.names[k].move_full(); | |
| } | |
| for (size_t k = k0; k < k1; ++k) | |
| db.names.pop_back(); | |
| t = t1; | |
| } | |
| sig += ")"; | |
| switch (ref_qual) { | |
| case 1: | |
| sig += " &"; | |
| break; | |
| case 2: | |
| sig += " &&"; | |
| break; | |
| } | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first += " "; | |
| db.names.back().second.insert(0, sig); | |
| first = t; | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // <pointer-to-member-type> ::= M <class type> <member type> | |
| template <class C> | |
| static const char *parse_pointer_to_member_type(const char *first, | |
| const char *last, C &db) { | |
| if (first != last && *first == 'M') { | |
| const char *t = parse_type(first + 1, last, db); | |
| if (t != first + 1) { | |
| const char *t2 = parse_type(t, last, db); | |
| if (t2 != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto func = std::move(db.names.back()); | |
| db.names.pop_back(); | |
| auto class_type = std::move(db.names.back()); | |
| if (!func.second.empty() && func.second.front() == '(') { | |
| db.names.back().first = | |
| std::move(func.first) + "(" + class_type.move_full() + "::*"; | |
| db.names.back().second = ")" + std::move(func.second); | |
| } else { | |
| db.names.back().first = | |
| std::move(func.first) + " " + class_type.move_full() + "::*"; | |
| db.names.back().second = std::move(func.second); | |
| } | |
| first = t2; | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // <array-type> ::= A <positive dimension number> _ <element type> | |
| // ::= A [<dimension expression>] _ <element type> | |
| template <class C> | |
| static const char *parse_array_type(const char *first, const char *last, | |
| C &db) { | |
| if (first != last && *first == 'A' && first + 1 != last) { | |
| if (first[1] == '_') { | |
| const char *t = parse_type(first + 2, last, db); | |
| if (t != first + 2) { | |
| if (db.names.empty()) | |
| return first; | |
| if (db.names.back().second.substr(0, 2) == " [") | |
| db.names.back().second.erase(0, 1); | |
| db.names.back().second.insert(0, " []"); | |
| first = t; | |
| } | |
| } else if ('1' <= first[1] && first[1] <= '9') { | |
| const char *t = parse_number(first + 1, last); | |
| if (t != last && *t == '_') { | |
| const char *t2 = parse_type(t + 1, last, db); | |
| if (t2 != t + 1) { | |
| if (db.names.empty()) | |
| return first; | |
| if (db.names.back().second.substr(0, 2) == " [") | |
| db.names.back().second.erase(0, 1); | |
| db.names.back().second.insert(0, | |
| " [" + std::string(first + 1, t) + "]"); | |
| first = t2; | |
| } | |
| } | |
| } else { | |
| const char *t = parse_expression(first + 1, last, db); | |
| if (t != first + 1 && t != last && *t == '_') { | |
| const char *t2 = parse_type(++t, last, db); | |
| if (t2 != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto type = std::move(db.names.back()); | |
| db.names.pop_back(); | |
| auto expr = std::move(db.names.back()); | |
| db.names.back().first = std::move(type.first); | |
| if (type.second.substr(0, 2) == " [") | |
| type.second.erase(0, 1); | |
| db.names.back().second = | |
| " [" + expr.move_full() + "]" + std::move(type.second); | |
| first = t2; | |
| } | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // <decltype> ::= Dt <expression> E # decltype of an id-expression or class | |
| // member access (C++0x) | |
| // ::= DT <expression> E # decltype of an expression (C++0x) | |
| template <class C> | |
| static const char *parse_decltype(const char *first, const char *last, C &db) { | |
| if (last - first >= 4 && first[0] == 'D') { | |
| switch (first[1]) { | |
| case 't': | |
| case 'T': { | |
| const char *t = parse_expression(first + 2, last, db); | |
| if (t != first + 2 && t != last && *t == 'E') { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back() = "decltype(" + db.names.back().move_full() + ")"; | |
| first = t + 1; | |
| } | |
| } break; | |
| } | |
| } | |
| return first; | |
| } | |
| // extension: | |
| // <vector-type> ::= Dv <positive dimension number> _ | |
| // <extended element type> | |
| // ::= Dv [<dimension expression>] _ <element type> | |
| // <extended element type> ::= <element type> | |
| // ::= p # AltiVec vector pixel | |
| template <class C> | |
| static const char *parse_vector_type(const char *first, const char *last, | |
| C &db) { | |
| if (last - first > 3 && first[0] == 'D' && first[1] == 'v') { | |
| if ('1' <= first[2] && first[2] <= '9') { | |
| const char *t = parse_number(first + 2, last); | |
| if (t == last || *t != '_') | |
| return first; | |
| const char *num = first + 2; | |
| size_t sz = static_cast<size_t>(t - num); | |
| if (++t != last) { | |
| if (*t != 'p') { | |
| const char *t1 = parse_type(t, last, db); | |
| if (t1 != t) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first += " vector[" + std::string(num, sz) + "]"; | |
| first = t1; | |
| } | |
| } else { | |
| ++t; | |
| db.names.push_back("pixel vector[" + std::string(num, sz) + "]"); | |
| first = t; | |
| } | |
| } | |
| } else { | |
| std::string num; | |
| const char *t1 = first + 2; | |
| if (*t1 != '_') { | |
| const char *t = parse_expression(t1, last, db); | |
| if (t != t1) { | |
| if (db.names.empty()) | |
| return first; | |
| num = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| t1 = t; | |
| } | |
| } | |
| if (t1 != last && *t1 == '_' && ++t1 != last) { | |
| const char *t = parse_type(t1, last, db); | |
| if (t != t1) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first += " vector[" + num + "]"; | |
| first = t; | |
| } | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // <type> ::= <builtin-type> | |
| // ::= <function-type> | |
| // ::= <class-enum-type> | |
| // ::= <array-type> | |
| // ::= <pointer-to-member-type> | |
| // ::= <template-param> | |
| // ::= <template-template-param> <template-args> | |
| // ::= <decltype> | |
| // ::= <substitution> | |
| // ::= <CV-qualifiers> <type> | |
| // ::= P <type> # pointer-to | |
| // ::= R <type> # reference-to | |
| // ::= O <type> # rvalue reference-to (C++0x) | |
| // ::= C <type> # complex pair (C 2000) | |
| // ::= G <type> # imaginary (C 2000) | |
| // ::= Dp <type> # pack expansion (C++0x) | |
| // ::= U <source-name> <type> # vendor extended type qualifier | |
| // extension := U <objc-name> <objc-type> # objc-type<identifier> | |
| // extension := <vector-type> # <vector-type> starts with Dv | |
| // <objc-name> ::= <k0 number> objcproto <k1 number> <identifier> # k0 = 9 + | |
| // <number of digits in k1> + k1 | |
| // <objc-type> := <source-name> # PU<11+>objcproto 11objc_object<source-name> | |
| // 11objc_object -> id<source-name> | |
| template <class C> | |
| static const char *parse_type(const char *first, const char *last, C &db) { | |
| if (first != last) { | |
| switch (*first) { | |
| case 'r': | |
| case 'V': | |
| case 'K': { | |
| unsigned cv = 0; | |
| const char *t = parse_cv_qualifiers(first, last, cv); | |
| if (t != first) { | |
| bool is_function = *t == 'F'; | |
| size_t k0 = db.names.size(); | |
| const char *t1 = parse_type(t, last, db); | |
| size_t k1 = db.names.size(); | |
| if (t1 != t) { | |
| if (is_function) | |
| db.subs.pop_back(); | |
| db.subs.emplace_back(); | |
| for (size_t k = k0; k < k1; ++k) { | |
| if (is_function) { | |
| size_t p = db.names[k].second.size(); | |
| if (db.names[k].second[p - 2] == '&') | |
| p -= 3; | |
| else if (db.names[k].second.back() == '&') | |
| p -= 2; | |
| if (cv & 1) { | |
| db.names[k].second.insert(p, " const"); | |
| p += 6; | |
| } | |
| if (cv & 2) { | |
| db.names[k].second.insert(p, " volatile"); | |
| p += 9; | |
| } | |
| if (cv & 4) | |
| db.names[k].second.insert(p, " restrict"); | |
| } else { | |
| if (cv & 1) | |
| db.names[k].first.append(" const"); | |
| if (cv & 2) | |
| db.names[k].first.append(" volatile"); | |
| if (cv & 4) | |
| db.names[k].first.append(" restrict"); | |
| } | |
| db.subs.back().push_back(db.names[k]); | |
| } | |
| first = t1; | |
| } | |
| } | |
| } break; | |
| default: { | |
| const char *t = parse_builtin_type(first, last, db); | |
| if (t != first) { | |
| first = t; | |
| } else { | |
| switch (*first) { | |
| case 'A': | |
| t = parse_array_type(first, last, db); | |
| if (t != first) { | |
| if (db.names.empty()) | |
| return first; | |
| first = t; | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| } | |
| break; | |
| case 'C': | |
| t = parse_type(first + 1, last, db); | |
| if (t != first + 1) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first.append(" complex"); | |
| first = t; | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| } | |
| break; | |
| case 'F': | |
| t = parse_function_type(first, last, db); | |
| if (t != first) { | |
| if (db.names.empty()) | |
| return first; | |
| first = t; | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| } | |
| break; | |
| case 'G': | |
| t = parse_type(first + 1, last, db); | |
| if (t != first + 1) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first.append(" imaginary"); | |
| first = t; | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| } | |
| break; | |
| case 'M': | |
| t = parse_pointer_to_member_type(first, last, db); | |
| if (t != first) { | |
| if (db.names.empty()) | |
| return first; | |
| first = t; | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| } | |
| break; | |
| case 'O': { | |
| size_t k0 = db.names.size(); | |
| t = parse_type(first + 1, last, db); | |
| size_t k1 = db.names.size(); | |
| if (t != first + 1) { | |
| db.subs.emplace_back(); | |
| for (size_t k = k0; k < k1; ++k) { | |
| if (db.names[k].second.substr(0, 2) == " [") { | |
| db.names[k].first += " ("; | |
| db.names[k].second.insert(0, ")"); | |
| } else if (!db.names[k].second.empty() && | |
| db.names[k].second.front() == '(') { | |
| db.names[k].first += "("; | |
| db.names[k].second.insert(0, ")"); | |
| } | |
| db.names[k].first.append("&&"); | |
| db.subs.back().push_back(db.names[k]); | |
| } | |
| first = t; | |
| } | |
| break; | |
| } | |
| case 'P': { | |
| size_t k0 = db.names.size(); | |
| t = parse_type(first + 1, last, db); | |
| size_t k1 = db.names.size(); | |
| if (t != first + 1) { | |
| db.subs.emplace_back(); | |
| for (size_t k = k0; k < k1; ++k) { | |
| if (db.names[k].second.substr(0, 2) == " [") { | |
| db.names[k].first += " ("; | |
| db.names[k].second.insert(0, ")"); | |
| } else if (!db.names[k].second.empty() && | |
| db.names[k].second.front() == '(') { | |
| db.names[k].first += "("; | |
| db.names[k].second.insert(0, ")"); | |
| } | |
| if (first[1] != 'U' || | |
| db.names[k].first.substr(0, 12) != "objc_object<") { | |
| db.names[k].first.append("*"); | |
| } else { | |
| db.names[k].first.replace(0, 11, "id"); | |
| } | |
| db.subs.back().push_back(db.names[k]); | |
| } | |
| first = t; | |
| } | |
| break; | |
| } | |
| case 'R': { | |
| size_t k0 = db.names.size(); | |
| t = parse_type(first + 1, last, db); | |
| size_t k1 = db.names.size(); | |
| if (t != first + 1) { | |
| db.subs.emplace_back(); | |
| for (size_t k = k0; k < k1; ++k) { | |
| if (db.names[k].second.substr(0, 2) == " [") { | |
| db.names[k].first += " ("; | |
| db.names[k].second.insert(0, ")"); | |
| } else if (!db.names[k].second.empty() && | |
| db.names[k].second.front() == '(') { | |
| db.names[k].first += "("; | |
| db.names[k].second.insert(0, ")"); | |
| } | |
| db.names[k].first.append("&"); | |
| db.subs.back().push_back(db.names[k]); | |
| } | |
| first = t; | |
| } | |
| break; | |
| } | |
| case 'T': { | |
| size_t k0 = db.names.size(); | |
| t = parse_template_param(first, last, db); | |
| size_t k1 = db.names.size(); | |
| if (t != first) { | |
| db.subs.emplace_back(); | |
| for (size_t k = k0; k < k1; ++k) | |
| db.subs.back().push_back(db.names[k]); | |
| if (db.try_to_parse_template_args && k1 == k0 + 1) { | |
| const char *t1 = parse_template_args(t, last, db); | |
| if (t1 != t) { | |
| auto args = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back().first += std::move(args); | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| t = t1; | |
| } | |
| } | |
| first = t; | |
| } | |
| break; | |
| } | |
| case 'U': | |
| if (first + 1 != last) { | |
| t = parse_source_name(first + 1, last, db); | |
| if (t != first + 1) { | |
| const char *t2 = parse_type(t, last, db); | |
| if (t2 != t) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto type = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| if (db.names.back().first.substr(0, 9) != "objcproto") { | |
| db.names.back() = type + " " + db.names.back().move_full(); | |
| } else { | |
| auto proto = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| t = parse_source_name(proto.data() + 9, | |
| proto.data() + proto.size(), db); | |
| if (t != proto.data() + 9) { | |
| db.names.back() = | |
| type + "<" + db.names.back().move_full() + ">"; | |
| } else { | |
| db.names.push_back(type + " " + proto); | |
| } | |
| } | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| first = t2; | |
| } | |
| } | |
| } | |
| break; | |
| case 'S': | |
| if (first + 1 != last && first[1] == 't') { | |
| t = parse_name(first, last, db); | |
| if (t != first) { | |
| if (db.names.empty()) | |
| return first; | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| first = t; | |
| } | |
| } else { | |
| t = parse_substitution(first, last, db); | |
| if (t != first) { | |
| first = t; | |
| // Parsed a substitution. If the substitution is a | |
| // <template-param> it might be followed by <template-args>. | |
| t = parse_template_args(first, last, db); | |
| if (t != first) { | |
| if (db.names.size() < 2) | |
| return first; | |
| auto template_args = db.names.back().move_full(); | |
| db.names.pop_back(); | |
| db.names.back().first += template_args; | |
| // Need to create substitution for <template-template-param> | |
| // <template-args> | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| first = t; | |
| } | |
| } | |
| } | |
| break; | |
| case 'D': | |
| if (first + 1 != last) { | |
| switch (first[1]) { | |
| case 'p': { | |
| size_t k0 = db.names.size(); | |
| t = parse_type(first + 2, last, db); | |
| size_t k1 = db.names.size(); | |
| if (t != first + 2) { | |
| db.subs.emplace_back(); | |
| for (size_t k = k0; k < k1; ++k) | |
| db.subs.back().push_back(db.names[k]); | |
| first = t; | |
| return first; | |
| } | |
| break; | |
| } | |
| case 't': | |
| case 'T': | |
| t = parse_decltype(first, last, db); | |
| if (t != first) { | |
| if (db.names.empty()) | |
| return first; | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| first = t; | |
| return first; | |
| } | |
| break; | |
| case 'v': | |
| t = parse_vector_type(first, last, db); | |
| if (t != first) { | |
| if (db.names.empty()) | |
| return first; | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| first = t; | |
| return first; | |
| } | |
| break; | |
| } | |
| } | |
| // drop through | |
| default: | |
| // must check for builtin-types before class-enum-types to avoid | |
| // ambiguities with operator-names | |
| t = parse_builtin_type(first, last, db); | |
| if (t != first) { | |
| first = t; | |
| } else { | |
| t = parse_name(first, last, db); | |
| if (t != first) { | |
| if (db.names.empty()) | |
| return first; | |
| db.subs.push_back(typename C::sub_type(1, db.names.back())); | |
| first = t; | |
| } | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| return first; | |
| } | |
| // <operator-name> | |
| // ::= aa # && | |
| // ::= ad # & (unary) | |
| // ::= an # & | |
| // ::= aN # &= | |
| // ::= aS # = | |
| // ::= cl # () | |
| // ::= cm # , | |
| // ::= co # ~ | |
| // ::= cv <type> # (cast) | |
| // ::= da # delete[] | |
| // ::= de # * (unary) | |
| // ::= dl # delete | |
| // ::= dv # / | |
| // ::= dV # /= | |
| // ::= eo # ^ | |
| // ::= eO # ^= | |
| // ::= eq # == | |
| // ::= ge # >= | |
| // ::= gt # > | |
| // ::= ix # [] | |
| // ::= le # <= | |
| // ::= li <source-name> # operator "" | |
| // ::= ls # << | |
| // ::= lS # <<= | |
| // ::= lt # < | |
| // ::= mi # - | |
| // ::= mI # -= | |
| // ::= ml # * | |
| // ::= mL # *= | |
| // ::= mm # -- (postfix in <expression> context) | |
| // ::= na # new[] | |
| // ::= ne # != | |
| // ::= ng # - (unary) | |
| // ::= nt # ! | |
| // ::= nw # new | |
| // ::= oo # || | |
| // ::= or # | | |
| // ::= oR # |= | |
| // ::= pm # ->* | |
| // ::= pl # + | |
| // ::= pL # += | |
| // ::= pp # ++ (postfix in <expression> context) | |
| // ::= ps # + (unary) | |
| // ::= pt # -> | |
| // ::= qu # ? | |
| // ::= rm # % | |
| // ::= rM # %= | |
| // ::= rs # >> | |
| // ::= rS # >>= | |
| // ::= v <digit> <source-name> # vendor extended | |
| // operator | |
| template <class C> | |
| static const char *parse_operator_name(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 2) { | |
| switch (first[0]) { | |
| case 'a': | |
| switch (first[1]) { | |
| case 'a': | |
| db.names.push_back("operator&&"); | |
| first += 2; | |
| break; | |
| case 'd': | |
| case 'n': | |
| db.names.push_back("operator&"); | |
| first += 2; | |
| break; | |
| case 'N': | |
| db.names.push_back("operator&="); | |
| first += 2; | |
| break; | |
| case 'S': | |
| db.names.push_back("operator="); | |
| first += 2; | |
| break; | |
| } | |
| break; | |
| case 'c': | |
| switch (first[1]) { | |
| case 'l': | |
| db.names.push_back("operator()"); | |
| first += 2; | |
| break; | |
| case 'm': | |
| db.names.push_back("operator,"); | |
| first += 2; | |
| break; | |
| case 'o': | |
| db.names.push_back("operator~"); | |
| first += 2; | |
| break; | |
| case 'v': { | |
| bool try_to_parse_template_args = db.try_to_parse_template_args; | |
| db.try_to_parse_template_args = false; | |
| const char *t = parse_type(first + 2, last, db); | |
| db.try_to_parse_template_args = try_to_parse_template_args; | |
| if (t != first + 2) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first.insert(0, "operator "); | |
| db.parsed_ctor_dtor_cv = true; | |
| first = t; | |
| } | |
| } break; | |
| } | |
| break; | |
| case 'd': | |
| switch (first[1]) { | |
| case 'a': | |
| db.names.push_back("operator delete[]"); | |
| first += 2; | |
| break; | |
| case 'e': | |
| db.names.push_back("operator*"); | |
| first += 2; | |
| break; | |
| case 'l': | |
| db.names.push_back("operator delete"); | |
| first += 2; | |
| break; | |
| case 'v': | |
| db.names.push_back("operator/"); | |
| first += 2; | |
| break; | |
| case 'V': | |
| db.names.push_back("operator/="); | |
| first += 2; | |
| break; | |
| } | |
| break; | |
| case 'e': | |
| switch (first[1]) { | |
| case 'o': | |
| db.names.push_back("operator^"); | |
| first += 2; | |
| break; | |
| case 'O': | |
| db.names.push_back("operator^="); | |
| first += 2; | |
| break; | |
| case 'q': | |
| db.names.push_back("operator=="); | |
| first += 2; | |
| break; | |
| } | |
| break; | |
| case 'g': | |
| switch (first[1]) { | |
| case 'e': | |
| db.names.push_back("operator>="); | |
| first += 2; | |
| break; | |
| case 't': | |
| db.names.push_back("operator>"); | |
| first += 2; | |
| break; | |
| } | |
| break; | |
| case 'i': | |
| if (first[1] == 'x') { | |
| db.names.push_back("operator[]"); | |
| first += 2; | |
| } | |
| break; | |
| case 'l': | |
| switch (first[1]) { | |
| case 'e': | |
| db.names.push_back("operator<="); | |
| first += 2; | |
| break; | |
| case 'i': { | |
| const char *t = parse_source_name(first + 2, last, db); | |
| if (t != first + 2) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first.insert(0, "operator\"\" "); | |
| first = t; | |
| } | |
| } break; | |
| case 's': | |
| db.names.push_back("operator<<"); | |
| first += 2; | |
| break; | |
| case 'S': | |
| db.names.push_back("operator<<="); | |
| first += 2; | |
| break; | |
| case 't': | |
| db.names.push_back("operator<"); | |
| first += 2; | |
| break; | |
| } | |
| break; | |
| case 'm': | |
| switch (first[1]) { | |
| case 'i': | |
| db.names.push_back("operator-"); | |
| first += 2; | |
| break; | |
| case 'I': | |
| db.names.push_back("operator-="); | |
| first += 2; | |
| break; | |
| case 'l': | |
| db.names.push_back("operator*"); | |
| first += 2; | |
| break; | |
| case 'L': | |
| db.names.push_back("operator*="); | |
| first += 2; | |
| break; | |
| case 'm': | |
| db.names.push_back("operator--"); | |
| first += 2; | |
| break; | |
| } | |
| break; | |
| case 'n': | |
| switch (first[1]) { | |
| case 'a': | |
| db.names.push_back("operator new[]"); | |
| first += 2; | |
| break; | |
| case 'e': | |
| db.names.push_back("operator!="); | |
| first += 2; | |
| break; | |
| case 'g': | |
| db.names.push_back("operator-"); | |
| first += 2; | |
| break; | |
| case 't': | |
| db.names.push_back("operator!"); | |
| first += 2; | |
| break; | |
| case 'w': | |
| db.names.push_back("operator new"); | |
| first += 2; | |
| break; | |
| } | |
| break; | |
| case 'o': | |
| switch (first[1]) { | |
| case 'o': | |
| db.names.push_back("operator||"); | |
| first += 2; | |
| break; | |
| case 'r': | |
| db.names.push_back("operator|"); | |
| first += 2; | |
| break; | |
| case 'R': | |
| db.names.push_back("operator|="); | |
| first += 2; | |
| break; | |
| } | |
| break; | |
| case 'p': | |
| switch (first[1]) { | |
| case 'm': | |
| db.names.push_back("operator->*"); | |
| first += 2; | |
| break; | |
| case 'l': | |
| db.names.push_back("operator+"); | |
| first += 2; | |
| break; | |
| case 'L': | |
| db.names.push_back("operator+="); | |
| first += 2; | |
| break; | |
| case 'p': | |
| db.names.push_back("operator++"); | |
| first += 2; | |
| break; | |
| case 's': | |
| db.names.push_back("operator+"); | |
| first += 2; | |
| break; | |
| case 't': | |
| db.names.push_back("operator->"); | |
| first += 2; | |
| break; | |
| } | |
| break; | |
| case 'q': | |
| if (first[1] == 'u') { | |
| db.names.push_back("operator?"); | |
| first += 2; | |
| } | |
| break; | |
| case 'r': | |
| switch (first[1]) { | |
| case 'm': | |
| db.names.push_back("operator%"); | |
| first += 2; | |
| break; | |
| case 'M': | |
| db.names.push_back("operator%="); | |
| first += 2; | |
| break; | |
| case 's': | |
| db.names.push_back("operator>>"); | |
| first += 2; | |
| break; | |
| case 'S': | |
| db.names.push_back("operator>>="); | |
| first += 2; | |
| break; | |
| } | |
| break; | |
| case 'v': | |
| if (std::isdigit(first[1])) { | |
| const char *t = parse_source_name(first + 2, last, db); | |
| if (t != first + 2) { | |
| if (db.names.empty()) | |
| return first; | |
| db.names.back().first.insert(0, "operator "); | |
| first = t; | |
| } | |
| } | |
| break; | |
| } | |
| } | |
| return first; | |
| } | |
| template <class C> | |
| static const char *parse_integer_literal(const char *first, const char *last, | |
| const std::string &lit, C &db) { | |
| const char *t = parse_number(first, last); | |
| if (t != first && t != last && *t == 'E') { | |
| if (lit.size() > 3) | |
| db.names.push_back("(" + lit + ")"); | |
| else | |
| db.names.emplace_back(); | |
| if (*first == 'n') { | |
| db.names.back().first += '-'; | |
| ++first; | |
| } | |
| db.names.back().first.append(first, t); | |
| if (lit.size() <= 3) | |
| db.names.back().first += lit; | |
| first = t + 1; | |
| } | |
| return first; | |
| } | |
| // <expr-primary> ::= L <type> <value number> E # | |
| // integer literal | |
| // ::= L <type> <value float> E # | |
| // floating literal | |
| // ::= L <string type> E # | |
| // string literal | |
| // ::= L <nullptr type> E # | |
| // nullptr literal (i.e., "LDnE") | |
| // ::= L <type> <real-part float> _ <imag-part float> E # | |
| // complex floating point literal (C 2000) | |
| // ::= L <mangled-name> E # | |
| // external name | |
| template <class C> | |
| static const char *parse_expr_primary(const char *first, const char *last, | |
| C &db) { | |
| if (last - first >= 4 && *first == 'L') { | |
| switch (first[1]) { | |
| case 'w': { | |
| const char *t = parse_integer_literal(first + 2, last, "wchar_t", db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 'b': | |
| if (first[3] == 'E') { | |
| switch (first[2]) { | |
| case '0': | |
| db.names.push_back("false"); | |
| first += 4; | |
| break; | |
| case '1': | |
| db.names.push_back("true"); | |
| first += 4; | |
| break; | |
| } | |
| } | |
| break; | |
| case 'c': { | |
| const char *t = parse_integer_literal(first + 2, last, "char", db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 'a': { | |
| const char *t = parse_integer_literal(first + 2, last, "signed char", db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 'h': { | |
| const char *t = | |
| parse_integer_literal(first + 2, last, "unsigned char", db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 's': { | |
| const char *t = parse_integer_literal(first + 2, last, "short", db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 't': { | |
| const char *t = | |
| parse_integer_literal(first + 2, last, "unsigned short", db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 'i': { | |
| const char *t = parse_integer_literal(first + 2, last, "", db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 'j': { | |
| const char *t = parse_integer_literal(first + 2, last, "u", db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 'l': { | |
| const char *t = parse_integer_literal(first + 2, last, "l", db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 'm': { | |
| const char *t = parse_integer_literal(first + 2, last, "ul", db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 'x': { | |
| const char *t = parse_integer_literal(first + 2, last, "ll", db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 'y': { | |
| const char *t = parse_integer_literal(first + 2, last, "ull", db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 'n': { | |
| const char *t = parse_integer_literal(first + 2, last, "__int128", db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 'o': { | |
| const char *t = | |
| parse_integer_literal(first + 2, last, "unsigned __int128", db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 'f': { | |
| const char *t = parse_floating_number<float>(first + 2, last, db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 'd': { | |
| const char *t = parse_floating_number<double>(first + 2, last, db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case 'e': { | |
| const char *t = parse_floating_number<long double>(first + 2, last, db); | |
| if (t != first + 2) | |
| first = t; | |
| } break; | |
| case '_': | |
| if (first[2] == 'Z') { | |
| const char *t = parse_encoding(first + 3, last, db); | |
| if (t != first + 3 && t != last && *t == 'E') | |