[Demangler] NFC: Don't make the parse_* functions templates

Differential revision: https://reviews.llvm.org/D35158

llvm-svn: 307482

diff --git a/libcxxabi/src/cxa_demangle.cpp b/libcxxabi/src/cxa_demangle.cpp
index 67c8100..355ba66 100644 (file)
--- a/libcxxabi/src/cxa_demangle.cpp
+++ b/libcxxabi/src/cxa_demangle.cpp
@@ -41,23 +41,6 @@ enum
     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 <std::size_t N>
 class arena
 {
@@ -265,6 +248,17 @@ struct Db
     {}
 };
 
+
+const char* parse_type(const char* first, const char* last, Db& db);
+const char* parse_encoding(const char* first, const char* last, Db& db);
+const char* parse_name(const char* first, const char* last, Db& db,
+                       bool* ends_with_template_args = 0);
+const char* parse_expression(const char* first, const char* last, Db& db);
+const char* parse_template_args(const char* first, const char* last, Db& db);
+const char* parse_operator_name(const char* first, const char* last, Db& db);
+const char* parse_unqualified_name(const char* first, const char* last, Db& db);
+const char* parse_decltype(const char* first, const char* last, Db& db);
+
 template <class C>
 void
 print_stack(const C& db)
@@ -384,9 +378,9 @@ struct float_data<long double>
 
 constexpr const char* float_data<long double>::spec;
 
-template <class Float, class C>
+template <class Float>
 const char*
-parse_floating_number(const char* first, const char* last, C& db)
+parse_floating_number(const char* first, const char* last, Db& db)
 {
     const size_t N = float_data<Float>::mangled_size;
     if (static_cast<std::size_t>(last - first) > N)
@@ -419,7 +413,7 @@ parse_floating_number(const char* first, const char* last, C& db)
             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)));
+            db.names.push_back(Db::String(num, static_cast<std::size_t>(n)));
             first = t+1;
         }
     }
@@ -428,9 +422,8 @@ parse_floating_number(const char* first, const char* last, C& db)
 
 // <source-name> ::= <positive length number> <identifier>
 
-template <class C>
 const char*
-parse_source_name(const char* first, const char* last, C& db)
+parse_source_name(const char* first, const char* last, Db& db)
 {
     if (first != last)
     {
@@ -447,7 +440,7 @@ parse_source_name(const char* first, const char* last, C& db)
             }
             if (static_cast<size_t>(last - t) >= n)
             {
-                typename C::String r(t, n);
+                Db::String r(t, n);
                 if (r.substr(0, 10) == "_GLOBAL__N")
                     db.names.push_back("(anonymous namespace)");
                 else
@@ -470,9 +463,8 @@ parse_source_name(const char* first, const char* last, C& db)
 // <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)
+parse_substitution(const char* first, const char* last, Db& db)
 {
     if (last - first >= 2)
     {
@@ -578,9 +570,8 @@ parse_substitution(const char* first, const char* last, C& db)
 //                ::= 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)
+parse_builtin_type(const char* first, const char* last, Db& db)
 {
     if (first != last)
     {
@@ -756,9 +747,8 @@ parse_cv_qualifiers(const char* first, const char* last, unsigned& cv)
 // <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)
+parse_template_param(const char* first, const char* last, Db& db)
 {
     if (last - first >= 2)
     {
@@ -801,7 +791,7 @@ parse_template_param(const char* first, const char* last, C& db)
                 }
                 else
                 {
-                    db.names.push_back(typename C::String(first, t+1));
+                    db.names.push_back(Db::String(first, t+1));
                     first = t+1;
                     db.fix_forward_references = true;
                 }
@@ -813,9 +803,8 @@ parse_template_param(const char* first, const char* last, C& db)
 
 // cc <type> <expression>                               # const_cast<type> (expression)
 
-template <class C>
 const char*
-parse_const_cast_expr(const char* first, const char* last, C& db)
+parse_const_cast_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 'c' && first[1] == 'c')
     {
@@ -841,9 +830,8 @@ parse_const_cast_expr(const char* first, const char* last, C& db)
 
 // dc <type> <expression>                               # dynamic_cast<type> (expression)
 
-template <class C>
 const char*
-parse_dynamic_cast_expr(const char* first, const char* last, C& db)
+parse_dynamic_cast_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 'd' && first[1] == 'c')
     {
@@ -869,9 +857,8 @@ parse_dynamic_cast_expr(const char* first, const char* last, C& db)
 
 // rc <type> <expression>                               # reinterpret_cast<type> (expression)
 
-template <class C>
 const char*
-parse_reinterpret_cast_expr(const char* first, const char* last, C& db)
+parse_reinterpret_cast_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 'r' && first[1] == 'c')
     {
@@ -897,9 +884,8 @@ parse_reinterpret_cast_expr(const char* first, const char* last, C& db)
 
 // sc <type> <expression>                               # static_cast<type> (expression)
 
-template <class C>
 const char*
-parse_static_cast_expr(const char* first, const char* last, C& db)
+parse_static_cast_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 's' && first[1] == 'c')
     {
@@ -923,9 +909,8 @@ parse_static_cast_expr(const char* first, const char* last, C& db)
 
 // sp <expression>                                  # pack expansion
 
-template <class C>
 const char*
-parse_pack_expansion(const char* first, const char* last, C& db)
+parse_pack_expansion(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 's' && first[1] == 'p')
     {
@@ -938,9 +923,8 @@ parse_pack_expansion(const char* first, const char* last, C& db)
 
 // st <type>                                            # sizeof (a type)
 
-template <class C>
 const char*
-parse_sizeof_type_expr(const char* first, const char* last, C& db)
+parse_sizeof_type_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 's' && first[1] == 't')
     {
@@ -958,9 +942,8 @@ parse_sizeof_type_expr(const char* first, const char* last, C& db)
 
 // sz <expr>                                            # sizeof (a expression)
 
-template <class C>
 const char*
-parse_sizeof_expr_expr(const char* first, const char* last, C& db)
+parse_sizeof_expr_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 's' && first[1] == 'z')
     {
@@ -978,9 +961,8 @@ parse_sizeof_expr_expr(const char* first, const char* last, C& db)
 
 // 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)
+parse_sizeof_param_pack_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'T')
     {
@@ -989,7 +971,7 @@ parse_sizeof_param_pack_expr(const char* first, const char* last, C& db)
         size_t k1 = db.names.size();
         if (t != first+2)
         {
-            typename C::String tmp("sizeof...(");
+            Db::String tmp("sizeof...(");
             size_t k = k0;
             if (k != k1)
             {
@@ -1012,9 +994,8 @@ parse_sizeof_param_pack_expr(const char* first, const char* last, C& db)
 //                  ::= 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)
+parse_function_param(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && *first == 'f')
     {
@@ -1025,7 +1006,7 @@ parse_function_param(const char* first, const char* last, C& db)
             const char* t1 = parse_number(t, last);
             if (t1 != last && *t1 == '_')
             {
-                db.names.push_back("fp" + typename C::String(t, t1));
+                db.names.push_back("fp" + Db::String(t, t1));
                 first = t1+1;
             }
         }
@@ -1040,7 +1021,7 @@ parse_function_param(const char* first, const char* last, C& db)
                 const char* t1 = parse_number(t, last);
                 if (t1 != last && *t1 == '_')
                 {
-                    db.names.push_back("fp" + typename C::String(t, t1));
+                    db.names.push_back("fp" + Db::String(t, t1));
                     first = t1+1;
                 }
             }
@@ -1051,9 +1032,8 @@ parse_function_param(const char* first, const char* last, C& db)
 
 // 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)
+parse_sizeof_function_param_pack_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 's' && first[1] == 'Z' && first[2] == 'f')
     {
@@ -1072,9 +1052,8 @@ parse_sizeof_function_param_pack_expr(const char* first, const char* last, C& db
 // te <expression>                                      # typeid (expression)
 // ti <type>                                            # typeid (type)
 
-template <class C>
 const char*
-parse_typeid_expr(const char* first, const char* last, C& db)
+parse_typeid_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 't' && (first[1] == 'e' || first[1] == 'i'))
     {
@@ -1096,9 +1075,8 @@ parse_typeid_expr(const char* first, const char* last, C& db)
 
 // tw <expression>                                      # throw expression
 
-template <class C>
 const char*
-parse_throw_expr(const char* first, const char* last, C& db)
+parse_throw_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 't' && first[1] == 'w')
     {
@@ -1116,9 +1094,8 @@ parse_throw_expr(const char* first, const char* last, C& db)
 
 // ds <expression> <expression>                         # expr.*expr
 
-template <class C>
 const char*
-parse_dot_star_expr(const char* first, const char* last, C& db)
+parse_dot_star_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 'd' && first[1] == 's')
     {
@@ -1142,9 +1119,8 @@ parse_dot_star_expr(const char* first, const char* last, C& db)
 
 // <simple-id> ::= <source-name> [ <template-args> ]
 
-template <class C>
 const char*
-parse_simple_id(const char* first, const char* last, C& db)
+parse_simple_id(const char* first, const char* last, Db& db)
 {
     if (first != last)
     {
@@ -1172,9 +1148,8 @@ parse_simple_id(const char* first, const char* last, C& db)
 //                   ::= <decltype>
 //                   ::= <substitution>
 
-template <class C>
 const char*
-parse_unresolved_type(const char* first, const char* last, C& db)
+parse_unresolved_type(const char* first, const char* last, Db& db)
 {
     if (first != last)
     {
@@ -1188,7 +1163,7 @@ parse_unresolved_type(const char* first, const char* last, C& 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()));
+                db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                 first = t;
             }
             else
@@ -1204,7 +1179,7 @@ parse_unresolved_type(const char* first, const char* last, C& db)
             {
                 if (db.names.empty())
                     return first;
-                db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                 first = t;
             }
             break;
@@ -1222,7 +1197,7 @@ parse_unresolved_type(const char* first, const char* last, C& db)
                         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()));
+                        db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                         first = t;
                     }
                 }
@@ -1236,9 +1211,8 @@ parse_unresolved_type(const char* first, const char* last, C& db)
 // <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)
+parse_destructor_name(const char* first, const char* last, Db& db)
 {
     if (first != last)
     {
@@ -1264,9 +1238,8 @@ parse_destructor_name(const char* first, const char* last, C& db)
 //                        ::= 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)
+parse_base_unresolved_name(const char* first, const char* last, Db& db)
 {
     if (last - first >= 2)
     {
@@ -1323,9 +1296,8 @@ parse_base_unresolved_name(const char* first, const char* last, C& db)
 
 // <unresolved-qualifier-level> ::= <simple-id>
 
-template <class C>
 const char*
-parse_unresolved_qualifier_level(const char* first, const char* last, C& db)
+parse_unresolved_qualifier_level(const char* first, const char* last, Db& db)
 {
     return parse_simple_id(first, last, db);
 }
@@ -1340,9 +1312,8 @@ parse_unresolved_qualifier_level(const char* first, const char* last, C& db)
 //                                                                       # 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)
+parse_unresolved_name(const char* first, const char* last, Db& db)
 {
     if (last - first > 2)
     {
@@ -1489,9 +1460,8 @@ parse_unresolved_name(const char* first, const char* last, C& db)
 
 // dt <expression> <unresolved-name>                    # expr.name
 
-template <class C>
 const char*
-parse_dot_expr(const char* first, const char* last, C& db)
+parse_dot_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 'd' && first[1] == 't')
     {
@@ -1517,9 +1487,8 @@ parse_dot_expr(const char* first, const char* last, C& db)
 
 // cl <expression>+ E                                   # call
 
-template <class C>
 const char*
-parse_call_expr(const char* first, const char* last, C& db)
+parse_call_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 4 && first[0] == 'c' && first[1] == 'l')
     {
@@ -1531,7 +1500,7 @@ parse_call_expr(const char* first, const char* last, C& db)
             if (db.names.empty())
                 return first;
             db.names.back().first += db.names.back().second;
-            db.names.back().second = typename C::String();
+            db.names.back().second = Db::String();
             db.names.back().first.append("(");
             bool first_expr = true;
             while (*t != 'E')
@@ -1572,9 +1541,8 @@ parse_call_expr(const char* first, const char* last, C& db)
 // [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)
+parse_new_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 4)
     {
@@ -1652,7 +1620,7 @@ parse_new_expr(const char* first, const char* last, C& db)
             }
             if (*t != 'E')
                 return first;
-            typename C::String init_list;
+            Db::String init_list;
             if (has_init)
             {
                 if (db.names.empty())
@@ -1664,7 +1632,7 @@ parse_new_expr(const char* first, const char* last, C& db)
                 return first;
             auto type = db.names.back().move_full();
             db.names.pop_back();
-            typename C::String expr_list;
+            Db::String expr_list;
             if (has_expr_list)
             {
                 if (db.names.empty())
@@ -1672,7 +1640,7 @@ parse_new_expr(const char* first, const char* last, C& db)
                 expr_list = db.names.back().move_full();
                 db.names.pop_back();
             }
-            typename C::String r;
+            Db::String r;
             if (parsed_gs)
                 r = "::";
             if (is_array)
@@ -1694,9 +1662,8 @@ parse_new_expr(const char* first, const char* last, C& db)
 // 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)
+parse_conversion_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 'c' && first[1] == 'v')
     {
@@ -1761,9 +1728,8 @@ parse_conversion_expr(const char* first, const char* last, C& db)
 
 // pt <expression> <expression>                    # expr->name
 
-template <class C>
 const char*
-parse_arrow_expr(const char* first, const char* last, C& db)
+parse_arrow_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 'p' && first[1] == 't')
     {
@@ -1791,9 +1757,8 @@ parse_arrow_expr(const char* first, const char* last, C& db)
 
 // <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)
+parse_function_type(const char* first, const char* last, Db& db)
 {
     if (first != last && *first == 'F')
     {
@@ -1810,7 +1775,7 @@ parse_function_type(const char* first, const char* last, C& db)
             if (t1 != t)
             {
                 t = t1;
-                typename C::String sig("(");
+                Db::String sig("(");
                 int ref_qual = 0;
                 while (true)
                 {
@@ -1880,9 +1845,8 @@ parse_function_type(const char* first, const char* last, C& db)
 
 // <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)
+parse_pointer_to_member_type(const char* first, const char* last, Db& db)
 {
     if (first != last && *first == 'M')
     {
@@ -1917,9 +1881,8 @@ parse_pointer_to_member_type(const char* first, const char* last, C& db)
 // <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)
+parse_array_type(const char* first, const char* last, Db& db)
 {
     if (first != last && *first == 'A' && first+1 != last)
     {
@@ -1948,7 +1911,7 @@ parse_array_type(const char* first, const char* last, C& db)
                         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) + "]");
+                    db.names.back().second.insert(0, " [" + Db::String(first+1, t) + "]");
                     first = t2;
                 }
             }
@@ -1981,9 +1944,8 @@ parse_array_type(const char* first, const char* last, C& db)
 // <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)
+parse_decltype(const char* first, const char* last, Db& db)
 {
     if (last - first >= 4 && first[0] == 'D')
     {
@@ -2014,9 +1976,8 @@ parse_decltype(const char* first, const char* last, C& db)
 // <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)
+parse_vector_type(const char* first, const char* last, Db& db)
 {
     if (last - first > 3 && first[0] == 'D' && first[1] == 'v')
     {
@@ -2036,21 +1997,21 @@ parse_vector_type(const char* first, const char* last, C& db)
                     {
                         if (db.names.empty())
                             return first;
-                        db.names.back().first += " vector[" + typename C::String(num, sz) + "]";
+                        db.names.back().first += " vector[" + Db::String(num, sz) + "]";
                         first = t1;
                     }
                 }
                 else
                 {
                     ++t;
-                    db.names.push_back("pixel vector[" + typename C::String(num, sz) + "]");
+                    db.names.push_back("pixel vector[" + Db::String(num, sz) + "]");
                     first = t;
                 }
             }
         }
         else
         {
-            typename C::String num;
+            Db::String num;
             const char* t1 = first+2;
             if (*t1 != '_')
             {
@@ -2103,9 +2064,8 @@ parse_vector_type(const char* first, const char* last, C& db)
 // <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)
+parse_type(const char* first, const char* last, Db& db)
 {
     if (first != last)
     {
@@ -2185,7 +2145,7 @@ parse_type(const char* first, const char* last, C& db)
                             if (db.names.empty())
                                 return first;
                             first = t;
-                            db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                            db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                         }
                         break;
                     case 'C':
@@ -2196,7 +2156,7 @@ parse_type(const char* first, const char* last, C& db)
                                 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()));
+                            db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                         }
                         break;
                     case 'F':
@@ -2206,7 +2166,7 @@ parse_type(const char* first, const char* last, C& db)
                             if (db.names.empty())
                                 return first;
                             first = t;
-                            db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                            db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                         }
                         break;
                     case 'G':
@@ -2217,7 +2177,7 @@ parse_type(const char* first, const char* last, C& db)
                                 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()));
+                            db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                         }
                         break;
                     case 'M':
@@ -2227,7 +2187,7 @@ parse_type(const char* first, const char* last, C& db)
                             if (db.names.empty())
                                 return first;
                             first = t;
-                            db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                            db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                         }
                         break;
                     case 'O':
@@ -2339,7 +2299,7 @@ parse_type(const char* first, const char* last, C& db)
                                     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()));
+                                    db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                                     t = t1;
                                 }
                             }
@@ -2378,7 +2338,7 @@ parse_type(const char* first, const char* last, C& db)
                                             db.names.push_back(type + " " + proto);
                                         }
                                     }
-                                    db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                                    db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                                     first = t2;
                                 }
                             }
@@ -2392,7 +2352,7 @@ parse_type(const char* first, const char* last, C& db)
                             {
                                 if (db.names.empty())
                                     return first;
-                                db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                                db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                                 first = t;
                             }
                         }
@@ -2413,7 +2373,7 @@ parse_type(const char* first, const char* last, C& db)
                                     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()));
+                                    db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                                     first = t;
                                 }
                             }
@@ -2446,7 +2406,7 @@ parse_type(const char* first, const char* last, C& db)
                                 {
                                     if (db.names.empty())
                                         return first;
-                                    db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                                    db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                                     first = t;
                                     return first;
                                 }
@@ -2457,7 +2417,7 @@ parse_type(const char* first, const char* last, C& db)
                                 {
                                     if (db.names.empty())
                                         return first;
-                                    db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                                    db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                                     first = t;
                                     return first;
                                 }
@@ -2480,7 +2440,7 @@ parse_type(const char* first, const char* last, C& db)
                             {
                                 if (db.names.empty())
                                     return first;
-                                db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                                db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                                 first = t;
                             }
                         }
@@ -2546,9 +2506,8 @@ parse_type(const char* first, const char* last, C& db)
 //                   ::= rS    # >>=           
 //                   ::= v <digit> <source-name>        # vendor extended operator
 
-template <class C>
 const char*
-parse_operator_name(const char* first, const char* last, C& db)
+parse_operator_name(const char* first, const char* last, Db& db)
 {
     if (last - first >= 2)
     {
@@ -2846,9 +2805,8 @@ parse_operator_name(const char* first, const char* last, C& db)
     return first;
 }
 
-template <class C>
 const char*
-parse_integer_literal(const char* first, const char* last, const typename C::String& lit, C& db)
+parse_integer_literal(const char* first, const char* last, const Db::String& lit, Db& db)
 {
     const char* t = parse_number(first, last);
     if (t != first && t != last && *t == 'E')
@@ -2877,9 +2835,8 @@ parse_integer_literal(const char* first, const char* last, const typename C::Str
 //                ::= 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)
+parse_expr_primary(const char* first, const char* last, Db& db)
 {
     if (last - first >= 4 && *first == 'L')
     {
@@ -3047,7 +3004,7 @@ parse_expr_primary(const char* first, const char* last, C& db)
                         {
                             if (db.names.empty())
                                 return first;
-                            db.names.back() = "(" + db.names.back().move_full() + ")" + typename C::String(t, n);
+                            db.names.back() = "(" + db.names.back().move_full() + ")" + Db::String(t, n);
                             first = n+1;
                             break;
                         }
@@ -3138,9 +3095,8 @@ base_name(String& s)
 //                  ::= D2    # base object destructor
 //   extension      ::= D5    # ?
 
-template <class C>
 const char*
-parse_ctor_dtor_name(const char* first, const char* last, C& db)
+parse_ctor_dtor_name(const char* first, const char* last, Db& db)
 {
     if (last-first >= 2 && !db.names.empty())
     {
@@ -3188,9 +3144,8 @@ parse_ctor_dtor_name(const char* first, const char* last, C& db)
 // 
 // <lambda-sig> ::= <parameter type>+  # Parameter types or "v" if the lambda has no parameters
 
-template <class C>
 const char*
-parse_unnamed_type_name(const char* first, const char* last, C& db)
+parse_unnamed_type_name(const char* first, const char* last, Db& db)
 {
     if (last - first > 2 && first[0] == 'U')
     {
@@ -3199,7 +3154,7 @@ parse_unnamed_type_name(const char* first, const char* last, C& db)
         {
         case 't':
           {
-            db.names.push_back(typename C::String("'unnamed"));
+            db.names.push_back(Db::String("'unnamed"));
             const char* t0 = first+2;
             if (t0 == last)
             {
@@ -3226,7 +3181,7 @@ parse_unnamed_type_name(const char* first, const char* last, C& db)
         case 'l':
           {
             size_t lambda_pos = db.names.size();
-            db.names.push_back(typename C::String("'lambda'("));
+            db.names.push_back(Db::String("'lambda'("));
             const char* t0 = first+2;
             if (first[2] == 'v')
             {
@@ -3250,7 +3205,7 @@ parse_unnamed_type_name(const char* first, const char* last, C& db)
                     // inserted into the name table. Walk through the names,
                     // appending each onto the lambda's parameter list.
                     std::for_each(db.names.begin() + k0, db.names.begin() + k1,
-                                  [&](typename C::sub_type::value_type &pair) {
+                                  [&](Db::sub_type::value_type &pair) {
                                       if (pair.empty())
                                           return;
                                       auto &lambda = db.names[lambda_pos].first;
@@ -3312,9 +3267,8 @@ parse_unnamed_type_name(const char* first, const char* last, C& db)
 //                    ::= <source-name>   
 //                    ::= <unnamed-type-name>
 
-template <class C>
 const char*
-parse_unqualified_name(const char* first, const char* last, C& db)
+parse_unqualified_name(const char* first, const char* last, Db& db)
 {
     if (first != last)
     {
@@ -3359,9 +3313,8 @@ parse_unqualified_name(const char* first, const char* last, C& db)
 //                 ::= St <unqualified-name>   # ::std::
 // extension       ::= StL<unqualified-name>
 
-template <class C>
 const char*
-parse_unscoped_name(const char* first, const char* last, C& db)
+parse_unscoped_name(const char* first, const char* last, Db& db)
 {
     if (last - first >= 2)
     {
@@ -3391,9 +3344,8 @@ parse_unscoped_name(const char* first, const char* last, C& db)
 
 // at <type>                                            # alignof (a type)
 
-template <class C>
 const char*
-parse_alignof_type(const char* first, const char* last, C& db)
+parse_alignof_type(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 'a' && first[1] == 't')
     {
@@ -3411,9 +3363,8 @@ parse_alignof_type(const char* first, const char* last, C& db)
 
 // az <expression>                                            # alignof (a expression)
 
-template <class C>
 const char*
-parse_alignof_expr(const char* first, const char* last, C& db)
+parse_alignof_expr(const char* first, const char* last, Db& db)
 {
     if (last - first >= 3 && first[0] == 'a' && first[1] == 'z')
     {
@@ -3429,9 +3380,8 @@ parse_alignof_expr(const char* first, const char* last, C& db)
     return first;
 }
 
-template <class C>
 const char*
-parse_noexcept_expression(const char* first, const char* last, C& db)
+parse_noexcept_expression(const char* first, const char* last, Db& db)
 {
     const char* t1 = parse_expression(first, last, db);
     if (t1 != first)
@@ -3444,9 +3394,8 @@ parse_noexcept_expression(const char* first, const char* last, C& db)
     return first;
 }
 
-template <class C>
 const char*
-parse_prefix_expression(const char* first, const char* last, const typename C::String& op, C& db)
+parse_prefix_expression(const char* first, const char* last, const Db::String& op, Db& db)
 {
     const char* t1 = parse_expression(first, last, db);
     if (t1 != first)
@@ -3459,9 +3408,8 @@ parse_prefix_expression(const char* first, const char* last, const typename C::S
     return first;
 }
 
-template <class C>
 const char*
-parse_binary_expression(const char* first, const char* last, const typename C::String& op, C& db)
+parse_binary_expression(const char* first, const char* last, const Db::String& op, Db& db)
 {
     const char* t1 = parse_expression(first, last, db);
     if (t1 != first)
@@ -3529,9 +3477,8 @@ parse_binary_expression(const char* first, const char* last, const typename C::S
 //                                                                       # objectless nonstatic member reference
 //              ::= <expr-primary>
 
-template <class C>
 const char*
-parse_expression(const char* first, const char* last, C& db)
+parse_expression(const char* first, const char* last, Db& db)
 {
     if (last - first >= 2)
     {
@@ -3623,7 +3570,7 @@ parse_expression(const char* first, const char* last, C& db)
                     {
                         if (db.names.empty())
                             return first;
-                        db.names.back().first = (parsed_gs ? typename C::String("::") : typename C::String()) +
+                        db.names.back().first = (parsed_gs ? Db::String("::") : Db::String()) +
                                           "delete[] " + db.names.back().move_full();
                         first = t1;
                     }
@@ -3644,7 +3591,7 @@ parse_expression(const char* first, const char* last, C& db)
                     {
                         if (db.names.empty())
                             return first;
-                        db.names.back().first = (parsed_gs ? typename C::String("::") : typename C::String()) +
+                        db.names.back().first = (parsed_gs ? Db::String("::") : Db::String()) +
                                           "delete " + db.names.back().move_full();
                         first = t1;
                     }
@@ -4027,9 +3974,8 @@ parse_expression(const char* first, const char* last, C& db)
 //                ::= J <template-arg>* E                                # argument pack
 //                ::= LZ <encoding> E                                    # extension
 
-template <class C>
 const char*
-parse_template_arg(const char* first, const char* last, C& db)
+parse_template_arg(const char* first, const char* last, Db& db)
 {
     if (first != last)
     {
@@ -4080,16 +4026,15 @@ parse_template_arg(const char* first, const char* last, C& db)
 // <template-args> ::= I <template-arg>* E
 //     extension, the abi says <template-arg>+
 
-template <class C>
 const char*
-parse_template_args(const char* first, const char* last, C& db)
+parse_template_args(const char* first, const char* last, Db& db)
 {
     if (last - first >= 2 && *first == 'I')
     {
         if (db.tag_templates)
             db.template_param.back().clear();
         const char* t = first+1;
-        typename C::String args("<");
+        Db::String args("<");
         while (*t != 'E')
         {
             if (db.tag_templates)
@@ -4145,9 +4090,8 @@ parse_template_args(const char* first, const char* last, C& db)
 //                   ::= <template-param>
 //                   ::= <substitution>
 
-template <class C>
 const char*
-parse_nested_name(const char* first, const char* last, C& db,
+parse_nested_name(const char* first, const char* last, Db& db,
                   bool* ends_with_template_args)
 {
     if (first != last && *first == 'N')
@@ -4199,7 +4143,7 @@ parse_nested_name(const char* first, const char* last, C& db,
                     if (!db.names.back().first.empty())
                     {
                         db.names.back().first += "::" + name;
-                        db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                        db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                     }
                     else
                         db.names.back().first = name;
@@ -4221,7 +4165,7 @@ parse_nested_name(const char* first, const char* last, C& db,
                         db.names.back().first += "::" + name;
                     else
                         db.names.back().first = name;
-                    db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                    db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                     pop_subs = true;
                     t0 = t1;
                 }
@@ -4242,7 +4186,7 @@ parse_nested_name(const char* first, const char* last, C& db,
                         db.names.back().first += "::" + name;
                     else
                         db.names.back().first = name;
-                    db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                    db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                     pop_subs = true;
                     t0 = t1;
                 }
@@ -4258,7 +4202,7 @@ parse_nested_name(const char* first, const char* last, C& db,
                     if (db.names.empty())
                         return first;
                     db.names.back().first += name;
-                    db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                    db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                     t0 = t1;
                     component_ends_with_template_args = true;
                 }
@@ -4282,7 +4226,7 @@ parse_nested_name(const char* first, const char* last, C& db,
                         db.names.back().first += "::" + name;
                     else
                         db.names.back().first = name;
-                    db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                    db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                     pop_subs = true;
                     t0 = t1;
                 }
@@ -4342,9 +4286,8 @@ parse_discriminator(const char* first, const char* last)
 //              := Z <function encoding> E s [<discriminator>]
 //              := Z <function encoding> Ed [ <parameter number> ] _ <entity name>
 
-template <class C>
 const char*
-parse_local_name(const char* first, const char* last, C& db,
+parse_local_name(const char* first, const char* last, Db& db,
                  bool* ends_with_template_args)
 {
     if (first != last && *first == 'Z')
@@ -4421,9 +4364,8 @@ parse_local_name(const char* first, const char* last, C& db,
 // <unscoped-template-name> ::= <unscoped-name>
 //                          ::= <substitution>
 
-template <class C>
 const char*
-parse_name(const char* first, const char* last, C& db,
+parse_name(const char* first, const char* last, Db& db,
            bool* ends_with_template_args)
 {
     if (last - first >= 2)
@@ -4459,7 +4401,7 @@ parse_name(const char* first, const char* last, C& db,
                 {
                     if (db.names.empty())
                         return first;
-                    db.subs.push_back(typename C::sub_type(1, db.names.back(), db.names.get_allocator()));
+                    db.subs.push_back(Db::sub_type(1, db.names.back(), db.names.get_allocator()));
                     t0 = t1;
                     t1 = parse_template_args(t0, last, db);
                     if (t1 != t0)
@@ -4564,9 +4506,8 @@ parse_call_offset(const char* first, const char* last)
 //      extension ::= TC <first type> <number> _ <second type> # construction vtable for second-in-first
 //      extension ::= GR <object name> # reference temporary for object
 
-template <class C>
 const char*
-parse_special_name(const char* first, const char* last, C& db)
+parse_special_name(const char* first, const char* last, Db& db)
 {
     if (last - first > 2)
     {
@@ -4768,9 +4709,8 @@ public:
 //            ::= <data name>
 //            ::= <special-name>
 
-template <class C>
 const char*
-parse_encoding(const char* first, const char* last, C& db)
+parse_encoding(const char* first, const char* last, Db& db)
 {
     if (first != last)
     {
@@ -4801,10 +4741,10 @@ parse_encoding(const char* first, const char* last, C& db)
                     save_value<bool> sb2(db.tag_templates);
                     db.tag_templates = false;
                     const char* t2;
-                    typename C::String ret2;
+                    Db::String ret2;
                     if (db.names.empty())
                         return first;
-                    const typename C::String& nm = db.names.back().first;
+                    const Db::String& nm = db.names.back().first;
                     if (nm.empty())
                         return first;
                     if (!db.parsed_ctor_dtor_cv && ends_with_template_args)
@@ -4842,7 +4782,7 @@ parse_encoding(const char* first, const char* last, C& db)
                                 break;
                             if (k1 > k0)
                             {
-                                typename C::String tmp;
+                                Db::String tmp;
                                 for (size_t k = k0; k < k1; ++k)
                                 {
                                     if (!tmp.empty())
@@ -4898,9 +4838,8 @@ parse_encoding(const char* first, const char* last, C& db)
 // _block_invoke<decimal-digit>+
 // _block_invoke_<decimal-digit>+
 
-template <class C>
 const char*
-parse_block_invoke(const char* first, const char* last, C& db)
+parse_block_invoke(const char* first, const char* last, Db& db)
 {
     if (last - first >= 13)
     {
@@ -4935,15 +4874,14 @@ parse_block_invoke(const char* first, const char* last, C& db)
 // extension
 // <dot-suffix> := .<anything and everything>
 
-template <class C>
 const char*
-parse_dot_suffix(const char* first, const char* last, C& db)
+parse_dot_suffix(const char* first, const char* last, Db& db)
 {
     if (first != last && *first == '.')
     {
         if (db.names.empty())
             return first;
-        db.names.back().first += " (" + typename C::String(first, last) + ")";
+        db.names.back().first += " (" + Db::String(first, last) + ")";
         first = last;
     }
     return first;
@@ -4955,9 +4893,8 @@ parse_dot_suffix(const char* first, const char* last, C& db)
 // <mangled-name> ::= _Z<encoding>
 //                ::= <type>
 
-template <class C>
 void
-demangle(const char* first, const char* last, C& db, int& status)
+demangle(const char* first, const char* last, Db& db, int& status)
 {
     if (first >= last)
     {