| //===-------------------------- cxa_demangle.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. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #define _LIBCPP_EXTERN_TEMPLATE(...) |
| #define _LIBCPP_NO_EXCEPTIONS |
| |
| #include "__cxxabi_config.h" |
| |
| #include <vector> |
| #include <algorithm> |
| #include <string> |
| #include <numeric> |
| #include <cstdlib> |
| #include <cstring> |
| #include <cctype> |
| |
| #ifdef _MSC_VER |
| // snprintf is implemented in VS 2015 |
| #if _MSC_VER < 1900 |
| #define snprintf _snprintf_s |
| #endif |
| #endif |
| |
| namespace __cxxabiv1 |
| { |
| |
| namespace |
| { |
| |
| enum |
| { |
| unknown_error = -4, |
| invalid_args = -3, |
| invalid_mangled_name, |
| memory_alloc_failure, |
| success |
| }; |
| |
| template <class C> |
| const char* parse_type(const char* first, const char* last, C& db); |
| template <class C> |
| const char* parse_encoding(const char* first, const char* last, C& db); |
| template <class C> |
| const char* parse_name(const char* first, const char* last, C& db, |
| bool* ends_with_template_args = 0); |
| template <class C> |
| const char* parse_expression(const char* first, const char* last, C& db); |
| template <class C> |
| const char* parse_template_args(const char* first, const char* last, C& db); |
| template <class C> |
| const char* parse_operator_name(const char* first, const char* last, C& db); |
| template <class C> |
| const char* parse_unqualified_name(const char* first, const char* last, C& db); |
| template <class C> |
| const char* parse_decltype(const char* first, const char* last, C& db); |
| |
| template <class C> |
| void |
| print_stack(const C& db) |
| { |
| fprintf(stderr, "---------\n"); |
| fprintf(stderr, "names:\n"); |
| for (auto& s : db.names) |
| fprintf(stderr, "{%s#%s}\n", s.first.c_str(), s.second.c_str()); |
| int i = -1; |
| fprintf(stderr, "subs:\n"); |
| for (auto& v : db.subs) |
| { |
| if (i >= 0) |
| fprintf(stderr, "S%i_ = {", i); |
| else |
| fprintf(stderr, "S_ = {"); |
| for (auto& s : v) |
| fprintf(stderr, "{%s#%s}", s.first.c_str(), s.second.c_str()); |
| fprintf(stderr, "}\n"); |
| ++i; |
| } |
| fprintf(stderr, "template_param:\n"); |
| for (auto& t : db.template_param) |
| { |
| fprintf(stderr, "--\n"); |
| i = -1; |
| for (auto& v : t) |
| { |
| if (i >= 0) |
| fprintf(stderr, "T%i_ = {", i); |
| else |
| fprintf(stderr, "T_ = {"); |
| for (auto& s : v) |
| fprintf(stderr, "{%s#%s}", s.first.c_str(), s.second.c_str()); |
| fprintf(stderr, "}\n"); |
| ++i; |
| } |
| } |
| fprintf(stderr, "---------\n\n"); |
| } |
| |
| template <class C> |
| void |
| print_state(const char* msg, const char* first, const char* last, const C& db) |
| { |
| fprintf(stderr, "%s: ", msg); |
| for (; first != last; ++first) |
| fprintf(stderr, "%c", *first); |
| fprintf(stderr, "\n"); |
| print_stack(db); |
| } |
| |
| // <number> ::= [n] <non-negative decimal integer> |
| |
| 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; |
| } |
| |
| 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 constexpr const char* spec = "%af"; |
| }; |
| |
| constexpr const char* float_data<float>::spec; |
| |
| template <> |
| struct float_data<double> |
| { |
| static const size_t mangled_size = 16; |
| static const size_t max_demangled_size = 32; |
| static constexpr const char* spec = "%a"; |
| }; |
| |
| constexpr const char* float_data<double>::spec; |
| |
| 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 constexpr const char* spec = "%LaL"; |
| }; |
| |
| constexpr const char* float_data<long double>::spec; |
| |
| template <class Float, class C> |
| 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(typename C::String(num, static_cast<std::size_t>(n))); |
| first = t+1; |
| } |
| } |
| return first; |
| } |
| |
| // <source-name> ::= <positive length number> <identifier> |
| |
| template <class C> |
| 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) |
| { |
| typename C::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> |
| 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> |
| 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] |
| |
| 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> |
| 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(typename C::String(first, t+1)); |
| first = t+1; |
| db.fix_forward_references = true; |
| } |
| } |
| } |
| } |
| return first; |
| } |
| |
| // cc <type> <expression> # const_cast<type> (expression) |
| |
| template <class C> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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) |
| { |
| typename C::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> |
| 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" + typename C::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" + typename C::String(t, t1)); |
| first = t1+1; |
| } |
| } |
| } |
| } |
| return first; |
| } |
| |
| // sZ <function-param> # size of a function parameter pack |
| |
| template <class C> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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(), db.names.get_allocator())); |
| 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(), db.names.get_allocator())); |
| 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(), db.names.get_allocator())); |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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> |
| 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 = typename C::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> |
| 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; |
| typename C::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(); |
| typename C::String expr_list; |
| if (has_expr_list) |
| { |
| if (db.names.empty()) |
| return first; |
| expr_list = db.names.back().move_full(); |
| db.names.pop_back(); |
| } |
| typename C::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> |
| 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> |
| 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> |
| 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; |
| typename C::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> |
| 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> |
| 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, " [" + typename C::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> |
| 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> |
| 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[" + typename C::String(num, sz) + "]"; |
| first = t1; |
| } |
| } |
| else |
| { |
| ++t; |
| db.names.push_back("pixel vector[" + typename C::String(num, sz) + "]"); |
| first = t; |
| } |
| } |
| } |
| else |
| { |
| typename C::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> |
| 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(db.names.get_allocator()); |
| 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(), db.names.get_allocator())); |
| } |
| 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(), db.names.get_allocator())); |
| } |
| 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(), db.names.get_allocator())); |
| } |
| 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(), db.names.get_allocator())); |
| } |
| 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(), db.names.get_allocator())); |
| } |
| 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(db.names.get_allocator()); |
| 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(db.names.get_allocator()); |
| 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(db.names.get_allocator()); |
| 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(db.names.get_allocator()); |
| 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(), db.names.get_allocator())); |
| 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(), db.names.get_allocator())); |
| 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(), db.names.get_allocator())); |
| 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(), db.names.get_allocator())); |
| 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(db.names.get_allocator()); |
| 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(), db.names.get_allocator())); |
| 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(), db.names.get_allocator())); |
| 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(), db.names.get_allocator())); |
| 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> |
| 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> |
| const char* |
| parse_integer_literal(const char* first, const char* last, const typename C::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> |
| 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; |
|