Update in-tree GCC to 3.4.4.
authorJoerg Sonnenberger <joerg@dragonflybsd.org>
Tue, 24 May 2005 06:29:33 +0000 (06:29 +0000)
committerJoerg Sonnenberger <joerg@dragonflybsd.org>
Tue, 24 May 2005 06:29:33 +0000 (06:29 +0000)
contrib/gcc-3.4/libstdc++-v3/include/ext/demangle.h [deleted file]
gnu/lib/gcc34/libstdc++/Makefile
gnu/usr.bin/cc34/Makefile.langs
gnu/usr.bin/cc34/cc_prep/patches/function.c.patch
gnu/usr.bin/cc34/cc_tools/Makefile.tools

diff --git a/contrib/gcc-3.4/libstdc++-v3/include/ext/demangle.h b/contrib/gcc-3.4/libstdc++-v3/include/ext/demangle.h
deleted file mode 100644 (file)
index 5de4f04..0000000
+++ /dev/null
@@ -1,2789 +0,0 @@
-// C++ IA64 / g++ v3 demangler  -*- C++ -*-
-
-// Copyright (C) 2003, 2004 Free Software Foundation, Inc.
-// Written by Carlo Wood <carlo@alinoe.com>
-//
-// This file is part of the GNU ISO C++ Library.  This library is free
-// software; you can redistribute it and/or modify it under the
-// terms of the GNU General Public License as published by the
-// Free Software Foundation; either version 2, or (at your option)
-// any later version.
-
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License along
-// with this library; see the file COPYING.  If not, write to the Free
-// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
-// USA.
-
-// As a special exception, you may use this file as part of a free software
-// library without restriction.  Specifically, if other files instantiate
-// templates or use macros or inline functions from this file, or you compile
-// this file and link it with other files to produce an executable, this
-// file does not by itself cause the resulting executable to be covered by
-// the GNU General Public License.  This exception does not however
-// invalidate any other reasons why the executable file might be covered by
-// the GNU General Public License.
-
-// This file implements demangling of "C++ ABI for Itanium"-mangled symbol
-// and type names as described in Revision 1.73 of the C++ ABI as can be found
-// at http://www.codesourcery.com/cxx-abi/abi.html#mangling
-
-#ifndef _DEMANGLER_H
-#define _DEMANGLER_H 1
-
-#include <vector>
-#include <string>
-#include <ext/new_allocator.h>
-
-#ifndef _GLIBCXX_DEMANGLER_DEBUG
-#define _GLIBCXX_DEMANGLER_CWDEBUG 0
-#define _GLIBCXX_DEMANGLER_DEBUG(x)
-#define _GLIBCXX_DEMANGLER_DOUT(cntrl, data)
-#define _GLIBCXX_DEMANGLER_DOUT_ENTERING(x)
-#define _GLIBCXX_DEMANGLER_DOUT_ENTERING2(x)
-#define _GLIBCXX_DEMANGLER_DOUT_ENTERING3(x)
-#define _GLIBCXX_DEMANGLER_RETURN return M_result
-#define _GLIBCXX_DEMANGLER_RETURN2 return M_result
-#define _GLIBCXX_DEMANGLER_RETURN3
-#define _GLIBCXX_DEMANGLER_FAILURE \
-    do { M_result = false; return false; } while(0)
-#else
-#define _GLIBCXX_DEMANGLER_CWDEBUG 1
-#endif
-
-namespace __gnu_cxx
-{
-  namespace demangler
-  {
-    enum substitution_nt
-    {
-      type,
-      template_template_param,
-      nested_name_prefix,
-      nested_name_template_prefix,
-      unscoped_template_name
-    };
-
-    struct substitution_st
-    {
-      int M_start_pos;
-      substitution_nt M_type;
-      int M_number_of_prefixes;
-
-      substitution_st(int start_pos,
-                     substitution_nt type,
-                     int number_of_prefixes)
-      : M_start_pos(start_pos), M_type(type),
-       M_number_of_prefixes(number_of_prefixes)
-      { }
-    };
-
-    enum simple_qualifier_nt
-    {
-      complex_or_imaginary = 'G',
-      pointer = 'P',
-      reference = 'R'
-    };
-
-    enum cv_qualifier_nt
-    {
-      cv_qualifier = 'K'
-    };
-
-    enum param_qualifier_nt
-    {
-      vendor_extension = 'U',
-      array = 'A',
-      pointer_to_member = 'M'
-    };
-
-    template<typename Tp, typename Allocator = __gnu_cxx::new_allocator<Tp> >
-      class qualifier;
-
-    template<typename Tp, typename Allocator = __gnu_cxx::new_allocator<Tp> >
-      class qualifier_list;
-
-    template<typename Tp, typename Allocator = __gnu_cxx::new_allocator<Tp> >
-      class session;
-
-    template<typename Tp, typename Allocator>
-      class qualifier
-      {
-       typedef typename Allocator::template rebind<char>::other
-               char_Allocator;
-       typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
-           string_type;
-
-      private:
-       char M_qualifier1;
-       char M_qualifier2;
-       char M_qualifier3;
-       mutable unsigned char M_cnt;
-       string_type M_optional_type;
-       int M_start_pos;
-       bool M_part_of_substitution;
-
-      public:
-       qualifier(int start_pos,
-                 simple_qualifier_nt simple_qualifier,
-                 int inside_substitution)
-       : M_qualifier1(simple_qualifier),
-         M_start_pos(start_pos),
-         M_part_of_substitution(inside_substitution)
-       { }
-
-       qualifier(int start_pos,
-                 cv_qualifier_nt,
-                 char const* start,
-                 int count,
-                 int inside_substitution)
-       : M_qualifier1(start[0]),
-         M_qualifier2((count > 1) ? start[1] : '\0'),
-         M_qualifier3((count > 2) ? start[2] : '\0'),
-         M_start_pos(start_pos),
-         M_part_of_substitution(inside_substitution)
-       { }
-
-       qualifier(int start_pos,
-                 param_qualifier_nt param_qualifier,
-                 string_type optional_type,
-                 int inside_substitution)
-       : M_qualifier1(param_qualifier),
-         M_optional_type(optional_type),
-         M_start_pos(start_pos),
-         M_part_of_substitution(inside_substitution)
-       { }
-
-       int
-       get_start_pos(void) const
-       { return M_start_pos; }
-
-       char
-       first_qualifier(void) const
-       { M_cnt = 1; return M_qualifier1; }
-
-       char
-       next_qualifier(void) const
-       {
-         return (++M_cnt == 2) ? M_qualifier2
-                               : ((M_cnt == 3) ? M_qualifier3 : 0);
-       }
-
-       string_type const&
-       get_optional_type(void) const
-       { return M_optional_type; }
-
-       bool
-       part_of_substitution(void) const
-       { return M_part_of_substitution; }
-
-#if _GLIBCXX_DEMANGLER_CWDEBUG
-       friend std::ostream& operator<<(std::ostream& os, qualifier const& qual)
-       {
-         os << (char)qual.M_qualifier1;
-         if (qual.M_qualifier1 == vendor_extension ||
-             qual.M_qualifier1 == array ||
-             qual.M_qualifier1 == pointer_to_member)
-           os << " [" << qual.M_optional_type << ']';
-         else if (qual.M_qualifier1 == 'K' ||
-                  qual.M_qualifier1 == 'V' ||
-                  qual.M_qualifier1 == 'r')
-         {
-           if (qual.M_qualifier2)
-           {
-             os << (char)qual.M_qualifier2;
-             if (qual.M_qualifier3)
-               os << (char)qual.M_qualifier3;
-           }
-         }
-         return os;
-       }
-#endif
-      };
-
-    template<typename Tp, typename Allocator>
-      class qualifier_list
-      {
-       typedef typename Allocator::template rebind<char>::other
-         char_Allocator;
-       typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
-         string_type;
-
-      private:
-       mutable bool M_printing_suppressed;
-       typedef qualifier<Tp, Allocator> qual;
-        typedef typename Allocator::template rebind<qual>::other qual_Allocator;
-       typedef std::vector<qual, qual_Allocator> qual_vector;
-       qual_vector M_qualifier_starts;
-       session<Tp, Allocator>& M_demangler;
-
-       void decode_KVrA(string_type& prefix, string_type& postfix, int cvq,
-                        typename qual_vector::
-                          const_reverse_iterator const& iter_array) const;
-
-      public:
-       qualifier_list(session<Tp, Allocator>& demangler_obj)
-       : M_printing_suppressed(false), M_demangler(demangler_obj)
-       { }
-
-       void
-       add_qualifier_start(simple_qualifier_nt simple_qualifier,
-                           int start_pos,
-                           int inside_substitution)
-       { M_qualifier_starts.
-             push_back(qualifier<Tp, Allocator>(start_pos,
-                 simple_qualifier, inside_substitution)); }
-
-       void
-       add_qualifier_start(cv_qualifier_nt cv_qualifier,
-                           int start_pos,
-                           int count,
-                           int inside_substitution)
-       { M_qualifier_starts.
-             push_back(qualifier<Tp, Allocator>(start_pos,
-                   cv_qualifier, &M_demangler.M_str[start_pos],
-                   count, inside_substitution)); }
-
-       void
-       add_qualifier_start(param_qualifier_nt param_qualifier,
-                           int start_pos,
-                           string_type optional_type,
-                           int inside_substitution)
-       { M_qualifier_starts.
-             push_back(qualifier<Tp, Allocator>(start_pos,
-                   param_qualifier, optional_type, inside_substitution)); }
-
-       void
-       decode_qualifiers(string_type& prefix,
-                         string_type& postfix,
-                         bool member_function_pointer_qualifiers) const;
-
-       bool
-       suppressed(void) const
-       { return M_printing_suppressed; }
-
-       void
-       printing_suppressed(void)
-       { M_printing_suppressed = true; }
-
-       size_t
-       size(void) const
-       { return M_qualifier_starts.size(); }
-
-#if _GLIBCXX_DEMANGLER_CWDEBUG
-       friend std::ostream& operator<<(std::ostream& os, qualifier_list const& list)
-       {
-         typename qual_vector::const_iterator
-             iter = list.M_qualifier_starts.begin();
-         if (iter != list.M_qualifier_starts.end())
-         {
-           os << "{ " << *iter;
-           while (++iter != list.M_qualifier_starts.end())
-             os << ", " << *iter;
-           os << " }";
-         }
-         else
-           os << "{ }";
-         return os;
-       }
-#endif
-      };
-
-    struct implementation_details
-    {
-      private:
-        unsigned int M_style;
-
-      public:
-       // The following flags change the behaviour of the demangler.  The
-       // default behaviour is that none of these flags is set.
-
-        static unsigned int const style_void = 1;
-       // Default behaviour:                           int f()
-       // Use (void) instead of ():                    int f(void)
-
-        static unsigned int const style_literal = 2;
-       // Default behaviour:                           (long)13,
-       //                                              (unsigned long long)19
-       // Use extensions 'u', 'l' and 'll' for integral
-       // literals (as in template arguments):         13l, 19ull
-
-        static unsigned int const style_literal_int = 4;
-       // Default behaviour:                           4
-       // Use also an explicit
-       //   cast for int in literals:                  (int)4
-
-        static unsigned int const style_compact_expr_ops = 8;
-       // Default behaviour:                           (i) < (3), sizeof (int)
-       // Don't output spaces around
-       //   operators in expressions:                  (i)<(3), sizeof(int)
-
-        static unsigned int const style_sizeof_typename = 16;
-       // Default behaviour:                           sizeof (X::t)
-       // Put 'typename' infront of <nested-name>
-       // types inside a 'sizeof':                     sizeof (typename X::t)
-
-      public:
-       implementation_details(unsigned int style_flags = 0) :
-           M_style(style_flags) { }
-       virtual ~implementation_details() { }
-       bool get_style_void(void) const
-           { return (M_style & style_void); }
-       bool get_style_literal(void) const
-           { return (M_style & style_literal); }
-       bool get_style_literal_int(void) const
-           { return (M_style & style_literal_int); }
-       bool get_style_compact_expr_ops(void) const
-           { return (M_style & style_compact_expr_ops); }
-       bool get_style_sizeof_typename(void) const
-           { return (M_style & style_sizeof_typename); }
-        // This can be overridden by user implementations.
-        virtual bool decode_real(char* /* output */, unsigned long* /* input */,
-                                size_t /* size_of_real */) const
-            { return false; }
-    };
-
-    template<typename Tp, typename Allocator>
-      class session
-      {
-      public:
-       friend class qualifier_list<Tp, Allocator>;
-       typedef typename Allocator::template rebind<char>::other
-           char_Allocator;
-       typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
-           string_type;
-
-      private:
-       char const* M_str;
-       int M_pos;
-       int M_maxpos;
-       bool M_result;
-       int M_inside_template_args;
-       int M_inside_type;
-       int M_inside_substitution;
-       bool M_saw_destructor;
-       bool M_name_is_cdtor;
-       bool M_name_is_template;
-       bool M_name_is_conversion_operator;
-       bool M_template_args_need_space;
-       string_type M_function_name;
-        typedef typename Allocator::template rebind<int>::other
-                int_Allocator;
-        typedef typename Allocator::template rebind<substitution_st>::other
-                subst_Allocator;
-       std::vector<int, int_Allocator> M_template_arg_pos;
-       int M_template_arg_pos_offset;
-       std::vector<substitution_st, subst_Allocator> M_substitutions_pos;
-       implementation_details const& M_implementation_details;
-       typedef typename Allocator::template
-           rebind<qualifier_list<Allocator> >::other qualifier_list_Allocator;
-       qualifier_list_Allocator M_qualifier_list_alloc;
-#if _GLIBCXX_DEMANGLER_CWDEBUG
-       bool M_inside_add_substitution;
-#endif
-
-      public:
-       explicit session(char const* in, int len,
-           implementation_details const& id = implementation_details())
-       : M_str(in), M_pos(0), M_maxpos(len - 1), M_result(true),
-         M_inside_template_args(0), M_inside_type(0),
-         M_inside_substitution(0), M_saw_destructor(false),
-         M_name_is_cdtor(false), M_name_is_template(false),
-         M_name_is_conversion_operator(false),
-         M_template_args_need_space(false), M_template_arg_pos_offset(0),
-         M_implementation_details(id)
-#if _GLIBCXX_DEMANGLER_CWDEBUG
-         , M_inside_add_substitution(false)
-#endif
-       { }
-
-       static int
-       decode_encoding(string_type& output, char const* input, int len,
-         implementation_details const& id = implementation_details());
-
-       bool
-       decode_type(string_type& output,
-                   qualifier_list<Tp, Allocator>* qualifiers = NULL)
-       {
-         string_type postfix;
-         bool res = decode_type_with_postfix(output, postfix, qualifiers);
-         output += postfix;
-         return res;
-       }
-
-       bool
-       remaining_input_characters(void) const
-       { return current() != 0; }
-
-      private:
-       char
-       current(void) const
-       { return (M_pos > M_maxpos) ? 0 : M_str[M_pos]; }
-
-       char
-       next_peek(void) const
-       { return (M_pos >= M_maxpos) ? 0 : M_str[M_pos + 1]; }
-
-       char
-       next(void)
-       { return (M_pos >= M_maxpos) ? 0 : M_str[++M_pos]; }
-
-       char
-       eat_current(void)
-       { return (M_pos > M_maxpos) ? 0 : M_str[M_pos++]; }
-
-       void
-       store(int& saved_pos)
-       { saved_pos = M_pos; }
-
-       void
-       restore(int saved_pos)
-       { M_pos = saved_pos; M_result = true; }
-
-       void
-       add_substitution(int start_pos,
-                        substitution_nt sub_type,
-                        int number_of_prefixes);
-
-       bool decode_type_with_postfix(string_type& prefix,
-           string_type& postfix, qualifier_list<Tp, Allocator>* qualifiers = NULL);
-       bool decode_bare_function_type(string_type& output);
-       bool decode_builtin_type(string_type& output);
-       bool decode_call_offset(string_type& output);
-       bool decode_class_enum_type(string_type& output);
-       bool decode_expression(string_type& output);
-       bool decode_literal(string_type& output);
-       bool decode_local_name(string_type& output);
-       bool decode_name(string_type& output,
-           string_type& nested_name_qualifiers);
-       bool decode_nested_name(string_type& output,
-           string_type& qualifiers);
-       bool decode_number(string_type& output);
-       bool decode_operator_name(string_type& output);
-       bool decode_source_name(string_type& output);
-       bool decode_substitution(string_type& output,
-           qualifier_list<Tp, Allocator>* qualifiers = NULL);
-       bool decode_template_args(string_type& output);
-       bool decode_template_param(string_type& output,
-           qualifier_list<Tp, Allocator>* qualifiers = NULL);
-       bool decode_unqualified_name(string_type& output);
-       bool decode_unscoped_name(string_type& output);
-       bool decode_non_negative_decimal_integer(string_type& output);
-       bool decode_special_name(string_type& output);
-        bool decode_real(string_type& output, size_t size_of_real);
-      };
-
-    template<typename Tp, typename Allocator>
-#if !_GLIBCXX_DEMANGLER_CWDEBUG
-      inline
-#endif
-      void
-      session<Tp, Allocator>::add_substitution(int start_pos,
-                                          substitution_nt sub_type,
-                                          int number_of_prefixes = 0)
-      {
-       if (!M_inside_substitution)
-       {
-#if _GLIBCXX_DEMANGLER_CWDEBUG
-         if (M_inside_add_substitution)
-           return;
-#endif
-         M_substitutions_pos.
-             push_back(substitution_st(start_pos,
-                 sub_type, number_of_prefixes));
-#if _GLIBCXX_DEMANGLER_CWDEBUG
-         if (!DEBUGCHANNELS::dc::demangler.is_on())
-           return;
-         string_type substitution_name("S");
-         int n = M_substitutions_pos.size() - 1;
-         if (n > 0)
-           substitution_name += (n <= 10) ? (char)(n + '0' - 1)
-                                          : (char)(n + 'A' - 11);
-         substitution_name += '_';
-         string_type subst;
-         int saved_pos = M_pos;
-         M_pos = start_pos;
-         M_inside_add_substitution = true;
-         _GLIBCXX_DEMANGLER_DEBUG( dc::demangler.off() );
-         switch(sub_type)
-         {
-           case type:
-             decode_type(subst);
-             break;
-           case template_template_param:
-             decode_template_param(subst);
-             break;
-           case nested_name_prefix:
-           case nested_name_template_prefix:
-             for (int cnt = number_of_prefixes; cnt > 0; --cnt)
-             {
-               if (current() == 'I')
-               {
-                 subst += ' ';
-                 decode_template_args(subst);
-               }
-               else
-               {
-                 if (cnt < number_of_prefixes)
-                   subst += "::";
-                 if (current() == 'S')
-                   decode_substitution(subst);
-                 else if (current() == 'T')
-                   decode_template_param(subst);
-                 else
-                   decode_unqualified_name(subst);
-               }
-             }
-             break;
-           case unscoped_template_name:
-             decode_unscoped_name(subst);
-             break;
-         }
-         M_pos = saved_pos;
-         _GLIBCXX_DEMANGLER_DEBUG( dc::demangler.on() );
-         _GLIBCXX_DEMANGLER_DOUT(dc::demangler,
-             "Adding substitution " << substitution_name
-             << " : " << subst
-             << " (from " << location_ct((char*)__builtin_return_address(0)
-                                         + builtin_return_address_offset)
-             << " <- " << location_ct((char*)__builtin_return_address(1)
-                                      + builtin_return_address_offset)
-             << " <- " << location_ct((char*)__builtin_return_address(2)
-                                      + builtin_return_address_offset)
-             << ").");
-         M_inside_add_substitution = false;
-#endif
-       }
-      }
-
-    // We don't want to depend on locale (or include <cctype> for that matter).
-    // We also don't want to use "safe-ctype.h" because that headerfile is not
-    // available to the users.
-    inline bool isdigit(char c) { return c >= '0' && c <= '9'; }
-    inline bool islower(char c) { return c >= 'a' && c <= 'z'; }
-    inline bool isupper(char c) { return c >= 'A' && c <= 'Z'; }
-    inline char tolower(char c) { return isupper(c) ? c - 'A' + 'a' : c; }
-
-    //
-    // <non-negative decimal integer> ::= 0
-    //                                ::= 1|2|3|4|5|6|7|8|9 [<digit>+]
-    // <digit>                        ::= 0|1|2|3|4|5|6|7|8|9
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::
-         decode_non_negative_decimal_integer(string_type& output)
-      {
-       char c = current();
-       if (c == '0')
-       {
-         output += '0';
-         eat_current();
-       }
-       else if (!isdigit(c))
-         M_result = false;
-       else
-       {
-         do
-         {
-           output += c;
-         }
-         while (isdigit((c = next())));
-       }
-       return M_result;
-      }
-
-    // <number> ::= [n] <non-negative decimal integer>
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_number(string_type& output)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_number");
-       if (current() != 'n')
-         decode_non_negative_decimal_integer(output);
-       else
-       {
-         output += '-';
-         eat_current();
-         decode_non_negative_decimal_integer(output);
-       }
-       _GLIBCXX_DEMANGLER_RETURN;
-      }
-
-    // <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
-    //                ::= u <source-name>    # vendor extended type
-    //
-    char const* const builtin_type_c[26] =
-    {
-      "signed char",   // a
-      "bool",          // b
-      "char",          // c
-      "double",                // d
-      "long double",   // e
-      "float",         // f
-      "__float128",            // g
-      "unsigned char", // h
-      "int",           // i
-      "unsigned int",  // j
-      NULL,                    // k
-      "long",          // l
-      "unsigned long", // m
-      "__int128",              // n
-      "unsigned __int128",     // o
-      NULL,                    // p
-      NULL,                    // q
-      NULL,                    // r
-      "short",         // s
-      "unsigned short",        // t
-      NULL,                    // u
-      "void",          // v
-      "wchar_t",               // w
-      "long long",             // x
-      "unsigned long long",    // y
-      "..."                    // z
-    };
-
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_builtin_type(string_type& output)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_builtin_type");
-       char const* bt;
-       if (!islower(current()) || !(bt = builtin_type_c[current() - 'a']))
-         _GLIBCXX_DEMANGLER_FAILURE;
-       output += bt;
-       eat_current();
-       _GLIBCXX_DEMANGLER_RETURN;
-      }
-
-    // <class-enum-type> ::= <name>
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_class_enum_type(string_type& output)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_class_enum_type");
-       string_type nested_name_qualifiers;
-       if (!decode_name(output, nested_name_qualifiers))
-         _GLIBCXX_DEMANGLER_FAILURE;
-       output += nested_name_qualifiers;
-       _GLIBCXX_DEMANGLER_RETURN;
-      }
-
-    // <substitution> ::=
-    //   S <seq-id> _
-    //   S_
-    //   St # ::std::
-    //   Sa # ::std::allocator
-    //   Sb # ::std::basic_string
-    //   Ss # ::std::basic_string<char, std::char_traits<char>,
-    //                            std::allocator<char> >
-    //   Si # ::std::basic_istream<char,  std::char_traits<char> >
-    //   So # ::std::basic_ostream<char,  std::char_traits<char> >
-    //   Sd # ::std::basic_iostream<char, std::char_traits<char> >
-    //
-    // <seq-id> ::=
-    //   0|1|2|3|4|5|6|7|8|9|A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z
-    //       [<seq-id>]        # Base 36 number
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_substitution(string_type& output,
-         qualifier_list<Tp, Allocator>* qualifiers)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_substitution");
-       unsigned int value = 0;
-       char c = next();
-       if (c != '_')
-       {
-         switch(c)
-         {
-           case 'a':
-           {
-             output += "std::allocator";
-             if (!M_inside_template_args)
-             {
-               M_function_name = "allocator";
-               M_name_is_template = true;
-               M_name_is_cdtor = false;
-               M_name_is_conversion_operator = false;
-             }
-             eat_current();
-             if (qualifiers)
-               qualifiers->printing_suppressed();
-             _GLIBCXX_DEMANGLER_RETURN;
-           }
-           case 'b':
-           {
-             output += "std::basic_string";
-             if (!M_inside_template_args)
-             {
-               M_function_name = "basic_string";
-               M_name_is_template = true;
-               M_name_is_cdtor = false;
-               M_name_is_conversion_operator = false;
-             }
-             eat_current();
-             if (qualifiers)
-               qualifiers->printing_suppressed();
-             _GLIBCXX_DEMANGLER_RETURN;
-           }
-           case 'd':
-             output += "std::iostream";
-             if (!M_inside_template_args)
-             {
-               M_function_name = "iostream";
-               M_name_is_template = true;
-               M_name_is_cdtor = false;
-               M_name_is_conversion_operator = false;
-             }
-             eat_current();
-             if (qualifiers)
-               qualifiers->printing_suppressed();
-             _GLIBCXX_DEMANGLER_RETURN;
-           case 'i':
-             output += "std::istream";
-             if (!M_inside_template_args)
-             {
-               M_function_name = "istream";
-               M_name_is_template = true;
-               M_name_is_cdtor = false;
-               M_name_is_conversion_operator = false;
-             }
-             eat_current();
-             if (qualifiers)
-               qualifiers->printing_suppressed();
-             _GLIBCXX_DEMANGLER_RETURN;
-           case 'o':
-             output += "std::ostream";
-             if (!M_inside_template_args)
-             {
-               M_function_name = "ostream";
-               M_name_is_template = true;
-               M_name_is_cdtor = false;
-               M_name_is_conversion_operator = false;
-             }
-             eat_current();
-             if (qualifiers)
-               qualifiers->printing_suppressed();
-             _GLIBCXX_DEMANGLER_RETURN;
-           case 's':
-             output += "std::string";
-             if (!M_inside_template_args)
-             {
-               M_function_name = "string";
-               M_name_is_template = true;
-               M_name_is_cdtor = false;
-               M_name_is_conversion_operator = false;
-             }
-             eat_current();
-             if (qualifiers)
-               qualifiers->printing_suppressed();
-             _GLIBCXX_DEMANGLER_RETURN;
-           case 't':
-             output += "std";
-             eat_current();
-             if (qualifiers)
-               qualifiers->printing_suppressed();
-             _GLIBCXX_DEMANGLER_RETURN;
-           default:
-             for(;; c = next())
-             {
-               if (isdigit(c))
-                 value = value * 36 + c - '0';
-               else if (isupper(c))
-                 value = value * 36 + c - 'A' + 10;
-               else if (c == '_')
-                 break;
-               else
-                 _GLIBCXX_DEMANGLER_FAILURE;
-             }
-             ++value;
-             break;
-         }
-       }
-       eat_current();
-       if (value >= M_substitutions_pos.size() ||
-           M_inside_type > 20)                 // Rather than core dump.
-         _GLIBCXX_DEMANGLER_FAILURE;
-       ++M_inside_substitution;
-       int saved_pos = M_pos;
-       substitution_st& substitution(M_substitutions_pos[value]);
-       M_pos = substitution.M_start_pos;
-       switch(substitution.M_type)
-       {
-         case type:
-           decode_type(output, qualifiers);
-           break;
-         case template_template_param:
-           decode_template_param(output, qualifiers);
-           break;
-         case nested_name_prefix:
-         case nested_name_template_prefix:
-           for (int cnt = substitution.M_number_of_prefixes; cnt > 0; --cnt)
-           {
-             if (current() == 'I')
-             {
-               if (M_template_args_need_space)
-                 output += ' ';
-               M_template_args_need_space = false;
-               if (!decode_template_args(output))
-                 _GLIBCXX_DEMANGLER_FAILURE;
-             }
-             else
-             {
-               if (cnt < substitution.M_number_of_prefixes)
-                 output += "::";
-               if (current() == 'S')
-               {
-                 if (!decode_substitution(output))
-                   _GLIBCXX_DEMANGLER_FAILURE;
-               }
-               else if (!decode_unqualified_name(output))
-                 _GLIBCXX_DEMANGLER_FAILURE;
-             }
-           }
-           if (qualifiers)
-             qualifiers->printing_suppressed();
-           break;
-         case unscoped_template_name:
-           decode_unscoped_name(output);
-           if (qualifiers)
-             qualifiers->printing_suppressed();
-           break;
-       }
-       M_pos = saved_pos;
-       --M_inside_substitution;
-       _GLIBCXX_DEMANGLER_RETURN;
-      }
-
-    // <template-param> ::= T_                 # first template parameter
-    //                  ::= T <parameter-2 non-negative number> _
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_template_param(string_type& output,
-         qualifier_list<Tp, Allocator>* qualifiers)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_template_parameter");
-       if (current() != 'T')
-         _GLIBCXX_DEMANGLER_FAILURE;
-       unsigned int value = 0;
-       char c;
-       if ((c = next()) != '_')
-       {
-         while(isdigit(c))
-         {
-           value = value * 10 + c - '0';
-           c = next();
-         }
-         ++value;
-       }
-       if (eat_current() != '_')
-         _GLIBCXX_DEMANGLER_FAILURE;
-       value += M_template_arg_pos_offset;
-       if (value >= M_template_arg_pos.size())
-         _GLIBCXX_DEMANGLER_FAILURE;
-       int saved_pos = M_pos;
-       M_pos = M_template_arg_pos[value];
-       if (M_inside_type > 20)         // Rather than core dump.
-         _GLIBCXX_DEMANGLER_FAILURE;
-       ++M_inside_substitution;
-       if (current() == 'X')
-       {
-         eat_current();
-         decode_expression(output);
-       }
-       else if (current() == 'L')
-         decode_literal(output);
-       else
-         decode_type(output, qualifiers);
-       --M_inside_substitution;
-       M_pos = saved_pos;
-       _GLIBCXX_DEMANGLER_RETURN;
-      }
-
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_real(string_type& output, size_t size_of_real)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_real");
-
-       unsigned long words[4]; // 32 bit per long, maximum of 128 bits.
-       unsigned long* word = &words[0];
-
-       int saved_pos;
-       store(saved_pos);
-
-       // The following assumes that leading zeroes are also included in the
-       // mangled name, I am not sure that is conforming to the C++-ABI, but
-       // it is what g++ does.
-       unsigned char nibble, c = current();
-       for(size_t word_cnt = size_of_real / 4; word_cnt > 0; --word_cnt)
-       {
-         for (int nibble_cnt = 0; nibble_cnt < 8; ++nibble_cnt)
-         {
-           // Translate character into nibble.
-           if (c < '0' || c > 'f')
-             _GLIBCXX_DEMANGLER_FAILURE;
-           if (c <= '9')
-             nibble = c - '0';
-           else if (c >= 'a')
-             nibble = c - 'a' + 10;
-           else
-             _GLIBCXX_DEMANGLER_FAILURE;
-           // Write nibble into word array.
-           if (nibble_cnt == 0)
-             *word = nibble << 28;
-           else
-             *word |= (nibble << (28 - 4 * nibble_cnt));
-           c = next();
-         }
-         ++word;
-       }
-       char buf[24];
-       if (M_implementation_details.decode_real(buf, words, size_of_real))
-       {
-         output += buf;
-         _GLIBCXX_DEMANGLER_RETURN;
-       }
-       restore(saved_pos);
-
-       output += '[';
-       c = current();
-       for(size_t nibble_cnt = 0; nibble_cnt < 2 * size_of_real; ++nibble_cnt)
-       {
-         if (c < '0' || c > 'f' || (c > '9' && c < 'a'))
-           _GLIBCXX_DEMANGLER_FAILURE;
-         output += c;
-         c = next();
-       }
-       output += ']';
-
-       _GLIBCXX_DEMANGLER_RETURN;
-      }
-
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_literal(string_type& output)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_literal");
-       eat_current();  // Eat the 'L'.
-       if (current() == '_')
-       {
-         if (next() != 'Z')
-           _GLIBCXX_DEMANGLER_FAILURE;
-         eat_current();
-         if ((M_pos += decode_encoding(output, M_str + M_pos,
-                 M_maxpos - M_pos + 1, M_implementation_details)) < 0)
-           _GLIBCXX_DEMANGLER_FAILURE;
-       }
-       else
-       {
-         // Special cases
-         if (current() == 'b')
-         {
-           if (next() == '0')
-             output += "false";
-           else
-             output += "true";
-           eat_current();
-           _GLIBCXX_DEMANGLER_RETURN;
-         }
-         char c = current();
-         if ((c == 'i' || c == 'j' || c == 'l' ||
-              c == 'm' || c == 'x' || c == 'y') &&
-              M_implementation_details.get_style_literal())
-           eat_current();
-         else if (c == 'i' &&
-             !M_implementation_details.get_style_literal_int())
-           eat_current();
-         else
-         {
-           output += '(';
-           if (!decode_type(output))
-             _GLIBCXX_DEMANGLER_FAILURE;
-           output += ')';
-         }
-         if (c >= 'd' && c <= 'g')
-         {
-           size_t size_of_real = (c == 'd') ? sizeof(double) :
-               ((c == 'f') ? sizeof(float) :
-               (c == 'e') ?  sizeof(long double) : 16);
-           if (!decode_real(output, size_of_real))
-               _GLIBCXX_DEMANGLER_FAILURE;
-         }
-         else if (!decode_number(output))
-           _GLIBCXX_DEMANGLER_FAILURE;
-          if (M_implementation_details.get_style_literal())
-         {
-           if (c == 'j' || c == 'm' || c == 'y')
-             output += 'u';
-           if (c == 'l' || c == 'm')
-             output += 'l';
-           if (c == 'x' || c == 'y')
-             output += "ll";
-         }
-       }
-       _GLIBCXX_DEMANGLER_RETURN;
-      }
-
-    // <operator-name> ::=
-    //   nw                            # new
-    //   na                            # new[]
-    //   dl                            # delete
-    //   da                            # delete[]
-    //   ps                            # + (unary)
-    //   ng                            # - (unary)
-    //   ad                            # & (unary)
-    //   de                            # * (unary)
-    //   co                            # ~
-    //   pl                            # +
-    //   mi                            # -
-    //   ml                            # *
-    //   dv                            # /
-    //   rm                            # %
-    //   an                            # &
-    //   or                            # |
-    //   eo                            # ^
-    //   aS                            # =
-    //   pL                            # +=
-    //   mI                            # -=
-    //   mL                            # *=
-    //   dV                            # /=
-    //   rM                            # %=
-    //   aN                            # &=
-    //   oR                            # |=
-    //   eO                            # ^=
-    //   ls                            # <<
-    //   rs                            # >>
-    //   lS                            # <<=
-    //   rS                            # >>=
-    //   eq                            # ==
-    //   ne                            # !=
-    //   lt                            # <
-    //   gt                            # >
-    //   le                            # <=
-    //   ge                            # >=
-    //   nt                            # !
-    //   aa                            # &&
-    //   oo                            # ||
-    //   pp                            # ++
-    //   mm                            # --
-    //   cm                            # ,
-    //   pm                            # ->*
-    //   pt                            # ->
-    //   cl                            # ()
-    //   ix                            # []
-    //   qu                            # ?
-    //   st                            # sizeof (a type)
-    //   sz                            # sizeof (an expression)
-    //   cv <type>                     # (cast)
-    //   v <digit> <source-name>       # vendor extended operator
-    //
-    // Symbol operator codes exist of two characters, we need to find a
-    // quick hash so that their names can be looked up in a table.
-    //
-    // The puzzle :)
-    // Shift the rows so that there is at most one character per column.
-    //
-    // A perfect solution (Oh no, it's THE MATRIX!):
-    //                                              horizontal
-    //    .......................................   offset + 'a'
-    // a, a||d|||||||||n||||s||||||||||||||||||||       0
-    // c,  || |||||||lm o||| ||||||||||||||||||||       0
-    // d,  || a|||e||    l|| ||||||v|||||||||||||       4
-    // e,  ||  ||| ||     || |||o|q |||||||||||||       8
-    // g,  ||  ||| ||     || e|| |  ||||||||t||||      15
-    // i,  ||  ||| ||     ||  || |  |||||||| |||x      15
-    // l,  |e  ||| ||     st  || |  |||||||| |||       -2
-    // m,  |   |i| lm         || |  |||||||| |||       -2
-    // n,  a   e g            t| w  |||||||| |||        1
-    // o,                      |    ||||o||r |||       16
-    // p,                      |    ||lm |p  st|       17
-    // q,                      |    u|   |     |        6
-    // r,                      m     s   |     |        9
-    // s,                                t     z       12
-    //    .......................................
-    // ^            ^__ second character
-    // |___ first character
-    //
-
-    // Putting that solution in tables:
-
-    char const offset_table_c [1 + CHAR_MAX - CHAR_MIN ] =
-    {
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-#if (CHAR_MIN < 0)
-      // Add -CHAR_MIN extra zeroes (128):
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-      //   a    b    c    d    e    f    g    h    i    j    k
-      0, -97,   0, -97, -93, -89,   0, -82,   0, -82,   0,   0,
-      //   l    m    n    o    p    q    r    s    t    u    v
-        -99, -99, -96, -81, -80, -91, -88, -85,   0,   0,   0,
-#else
-      //   a    b    c    d    e    f    g    h    i    j    k
-      0, 159,   0, 159, 163, 167,   0, 174,   0, 174,   0,   0,
-      //   l    m    n    o    p    q    r    s    t    u    v
-        157, 157, 160, 175, 176, 165, 168, 171,   0,   0,   0,
-#endif
-      // ... more zeros
-    };
-
-    enum xary_nt {
-      unary,
-      binary,
-      trinary
-    };
-
-    struct entry_st
-    {
-      char const* opcode;
-      char const* symbol_name;
-      xary_nt type;
-    };
-
-    entry_st const symbol_name_table_c[39] = {
-      { "aa",  "operator&&", binary },
-      { "na",  "operator new[]", unary },
-      { "le",  "operator<=", binary },
-      { "ad",  "operator&", unary },
-      { "da",  "operator delete[]", unary },
-      { "ne",  "operator!=", binary },
-      { "mi=", "operator-", binary },
-      { "ng",  "operator-", unary },
-      { "de",  "operator*", unary },
-      { "ml=", "operator*", binary },
-      { "mm",  "operator--", unary },
-      { "cl",  "operator()", unary },
-      { "cm",  "operator,", binary },
-      { "an=", "operator&", binary },
-      { "co",  "operator~", binary },
-      { "dl",  "operator delete", unary },
-      { "ls=", "operator<<", binary },
-      { "lt",  "operator<", binary },
-      { "as=", "operator", binary },
-      { "ge",  "operator>=", binary },
-      { "nt",  "operator!", unary },
-      { "rm=", "operator%", binary },
-      { "eo=", "operator^", binary },
-      { "nw",  "operator new", unary },
-      { "eq",  "operator==", binary },
-      { "dv=", "operator/", binary },
-      { "qu",  "operator?", trinary },
-      { "rs=", "operator>>", binary },
-      { "pl=", "operator+", binary },
-      { "pm",  "operator->*", binary },
-      { "oo",  "operator||", binary },
-      { "st",  "sizeof", unary },
-      { "pp",  "operator++", unary },
-      { "or=", "operator|", binary },
-      { "gt",  "operator>", binary },
-      { "ps",  "operator+", unary },
-      { "pt",  "operator->", binary },
-      { "sz",  "sizeof", unary },
-      { "ix",  "operator[]", unary }
-    };
-
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_operator_name(string_type& output)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_operator_name");
-
-       char opcode0 = current();
-       char opcode1 = tolower(next());
-
-       register char hash;
-       if ((hash = offset_table_c[opcode0 - CHAR_MIN]))
-       {
-         hash += opcode1;
-         if (
-#if (CHAR_MIN < 0)
-             hash >= 0 &&
-#endif
-             hash < 39)
-         {
-           int index = static_cast<int>(static_cast<unsigned char>(hash));
-           entry_st entry = symbol_name_table_c[index];
-           if (entry.opcode[0] == opcode0 && entry.opcode[1] == opcode1
-               && (opcode1 == current() || entry.opcode[2] == '='))
-           {
-             output += entry.symbol_name;
-             if (opcode1 != current())
-               output += '=';
-             eat_current();
-             if (hash == 16 || hash == 17)
-               M_template_args_need_space = true;
-             _GLIBCXX_DEMANGLER_RETURN;
-           }
-           else if (opcode0 == 'c' && opcode1 == 'v')  // casting operator
-           {
-             eat_current();
-             output += "operator ";
-             if (current() == 'T')
-             {
-               // This is a templated cast operator.
-               // It must be of the form "cvT_I...E".
-               // Let M_template_arg_pos already point
-               // to the template argument.
-               M_template_arg_pos_offset = M_template_arg_pos.size();
-               M_template_arg_pos.push_back(M_pos + 3);
-             }
-             if (!decode_type(output))
-               _GLIBCXX_DEMANGLER_FAILURE;
-             if (!M_inside_template_args)
-               M_name_is_conversion_operator = true;
-             _GLIBCXX_DEMANGLER_RETURN;
-           }
-         }
-       }
-       _GLIBCXX_DEMANGLER_FAILURE;
-      }
-
-    //
-    // <expression> ::= <unary operator-name> <expression>
-    //              ::= <binary operator-name> <expression> <expression>
-    //              ::= <trinary operator-name> <expression> <expression> <expression>
-    //              ::= st <type>
-    //              ::= <template-param>
-    //              ::= sr <type> <unqualified-name>                   # dependent name
-    //              ::= sr <type> <unqualified-name> <template-args>   # dependent template-id
-    //              ::= <expr-primary>
-    //
-    // <expr-primary> ::= L <type> <value number> E     # integer literal
-    //                ::= L <type> <value float> E     # floating literal
-    //                ::= L <mangled-name> E           # external name
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_expression(string_type& output)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_expression");
-       if (current() == 'T')
-       {
-         if (!decode_template_param(output))
-           _GLIBCXX_DEMANGLER_FAILURE;
-         _GLIBCXX_DEMANGLER_RETURN;
-       }
-       else if (current() == 'L')
-       {
-         if (!decode_literal(output))
-           _GLIBCXX_DEMANGLER_FAILURE;
-         if (current() != 'E')
-           _GLIBCXX_DEMANGLER_FAILURE;
-         eat_current();
-         _GLIBCXX_DEMANGLER_RETURN;
-       }
-       else if (current() == 's')
-       {
-         char opcode1 = next();
-         if (opcode1 == 't' || opcode1 == 'z')
-         {
-           eat_current();
-           if (M_implementation_details.get_style_compact_expr_ops())
-             output += "sizeof(";
-           else
-             output += "sizeof (";
-           if (opcode1 == 't')
-           {
-             // I cannot think of a mangled name that is valid for both cases
-             // when just replacing the 't' by a 'z' or vica versa, which
-             // indicates that there is no ambiguity that dictates the need
-             // for a seperate "st" case, except to be able catch invalid
-             // mangled names.  However there CAN be ambiguity in the demangled
-             // name when there are both a type and a symbol of the same name,
-             // which then leads to different encoding (of course) with
-             // sizeof (type) or sizeof (expression) respectively, but that
-             // ambiguity is not per se related to "sizeof" except that that
-             // is the only place where both a type AND an expression are valid
-             // in as part of a (template function) type.
-             //
-             // Example:
-             //
-             // struct B { typedef int t; };
-             // struct A : public B { static int t[2]; };
-             // template<int i, int j> struct C { typedef int q; };
-             // template<int i, typename T>
-             //   void f(typename C<sizeof (typename T::t),
-             //                     sizeof (T::t)>::q) { }
-             // void instantiate() { f<5, A>(0); }
-             //
-             // Leads to _Z1fILi5E1AEvN1CIXstN1T1tEEXszsrS2_1tEE1qE which
-             // demangles as
-             // void f<5, A>(C<sizeof (T::t), sizeof (T::t)>::q)
-             //
-             // This is ambiguity is very unlikely to happen and it is kind
-             // of fuzzy to detect when adding a 'typename' makes sense.
-             //
-             if (M_implementation_details.get_style_sizeof_typename())
-             {
-               // We can only get here inside a template parameter,
-               // so this is syntactically correct if the given type is
-               // a typedef.  The only disadvantage is that it is inconsistent
-               // with all other places where the 'typename' keyword should be
-               // used and we don't.
-               // With this, the above example will demangle as
-               // void f<5, A>(C<sizeof (typename T::t), sizeof (T::t)>::q)
-               if (current() == 'N' || // <nested-name>
-                                         // This should be a safe bet.
-                   (current() == 'S' &&
-                    next_peek() == 't'))       // std::something, guess that
-                                         // this involves a typedef.
-                 output += "typename ";
-             }
-             if (!decode_type(output))
-               _GLIBCXX_DEMANGLER_FAILURE;
-           }
-           else
-           {
-             if (!decode_expression(output))
-               _GLIBCXX_DEMANGLER_FAILURE;
-           }
-           output += ')';
-           _GLIBCXX_DEMANGLER_RETURN;
-         }
-         else if (current() == 'r')
-         {
-           eat_current();
-           if (!decode_type(output))
-             _GLIBCXX_DEMANGLER_FAILURE;
-           output += "::";
-           if (!decode_unqualified_name(output))
-             _GLIBCXX_DEMANGLER_FAILURE;
-           if (current() != 'I' || decode_template_args(output))
-             _GLIBCXX_DEMANGLER_RETURN;
-         }
-       }
-       else
-       {
-         char opcode0 = current();
-         char opcode1 = tolower(next());
-
-         register char hash;
-         if ((hash = offset_table_c[opcode0 - CHAR_MIN]))
-         {
-           hash += opcode1;
-           if (
-#if (CHAR_MIN < 0)
-               hash >= 0 &&
-#endif
-               hash < 39)
-           {
-             int index = static_cast<int>(static_cast<unsigned char>(hash));
-             entry_st entry = symbol_name_table_c[index];
-             if (entry.opcode[0] == opcode0 && entry.opcode[1] == opcode1
-                 && (opcode1 == current() || entry.opcode[2] == '='))
-             {
-               char const* op = entry.symbol_name + 8; // Skip "operator".
-               if (*op == ' ')                         // operator new and delete.
-                 ++op;
-               if (entry.type == unary)
-                 output += op;
-               bool is_eq = (opcode1 != current());
-               eat_current();
-               if (index == 34 && M_inside_template_args)      // operator>
-                 output += '(';
-               output += '(';
-               if (!decode_expression(output))
-                 _GLIBCXX_DEMANGLER_FAILURE;
-               output += ')';
-               if (entry.type != unary)
-               {
-                 if (!M_implementation_details.get_style_compact_expr_ops())
-                   output += ' ';
-                 output += op;
-                 if (is_eq)
-                   output += '=';
-                 if (!M_implementation_details.get_style_compact_expr_ops())
-                   output += ' ';
-                 output += '(';
-                 if (!decode_expression(output))
-                   _GLIBCXX_DEMANGLER_FAILURE;
-                 output += ')';
-                 if (index == 34 && M_inside_template_args)
-                   output += ')';
-                 if (entry.type == trinary)
-                 {
-                   if (M_implementation_details.get_style_compact_expr_ops())
-                     output += ":(";
-                   else
-                     output += " : (";
-                   if (!decode_expression(output))
-                     _GLIBCXX_DEMANGLER_FAILURE;
-                   output += ')';
-                 }
-               }
-               _GLIBCXX_DEMANGLER_RETURN;
-             }
-             else if (opcode0 == 'c' &&
-                      opcode1 == 'v')          // casting operator.
-             {
-               eat_current();
-               output += '(';
-               if (!decode_type(output))
-                 _GLIBCXX_DEMANGLER_FAILURE;
-               output += ")(";
-               if (!decode_expression(output))
-                 _GLIBCXX_DEMANGLER_FAILURE;
-               output += ')';
-               _GLIBCXX_DEMANGLER_RETURN;
-             }
-           }
-         }
-       }
-       _GLIBCXX_DEMANGLER_FAILURE;
-      }
-
-    //
-    // <template-args> ::= I <template-arg>+ E
-    // <template-arg> ::= <type>                       # type or template
-    //                ::= L <type> <value number> E    # integer literal
-    //                ::= L <type> <value float> E     # floating literal
-    //                ::= L <mangled-name> E           # external name
-    //                ::= X <expression> E             # expression
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_template_args(string_type& output)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_template_args");
-       if (eat_current() != 'I')
-         _GLIBCXX_DEMANGLER_FAILURE;
-       int prev_size = M_template_arg_pos.size();
-       ++M_inside_template_args;
-       if (M_template_args_need_space)
-       {
-         output += ' ';
-         M_template_args_need_space = false;
-       }
-       output += '<';
-       for(;;)
-       {
-         if (M_inside_template_args == 1 && !M_inside_type)
-           M_template_arg_pos.push_back(M_pos);
-         if (current() == 'X')
-         {
-           eat_current();
-           if (!decode_expression(output))
-             _GLIBCXX_DEMANGLER_FAILURE;
-           if (current() != 'E')
-             _GLIBCXX_DEMANGLER_FAILURE;
-           eat_current();
-         }
-         else if (current() == 'L')
-         {
-           if (!decode_literal(output))
-             _GLIBCXX_DEMANGLER_FAILURE;
-           if (current() != 'E')
-             _GLIBCXX_DEMANGLER_FAILURE;
-           eat_current();
-         }
-         else if (!decode_type(output))
-           _GLIBCXX_DEMANGLER_FAILURE;
-         if (current() == 'E')
-           break;
-         output += ", ";
-       }
-       eat_current();
-       if (*(output.rbegin()) == '>')
-         output += ' ';
-       output += '>';
-       --M_inside_template_args;
-       if (!M_inside_template_args && !M_inside_type)
-       {
-         M_name_is_template = true;
-         M_template_arg_pos_offset = prev_size;
-       }
-       _GLIBCXX_DEMANGLER_RETURN;
-      }
-
-    // <bare-function-type> ::=
-    //   <signature type>+             # Types are parameter types.
-    //
-    // Note that the possible return type of the <bare-function-type>
-    // has already been eaten before we call this function.  This makes
-    // our <bare-function-type> slightly different from the one in
-    // the C++-ABI description.
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_bare_function_type(string_type& output)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_bare_function_type");
-       if (M_saw_destructor)
-       {
-         if (eat_current() != 'v' || (current() != 'E' && current() != 0))
-           _GLIBCXX_DEMANGLER_FAILURE;
-         output += "()";
-         M_saw_destructor = false;
-         _GLIBCXX_DEMANGLER_RETURN;
-       }
-       if (current() == 'v' && !M_implementation_details.get_style_void())
-       {
-         eat_current();
-         if (current() != 'E' && current() != 0)
-           _GLIBCXX_DEMANGLER_FAILURE;
-         output += "()";
-         M_saw_destructor = false;
-         _GLIBCXX_DEMANGLER_RETURN;
-       }
-       output += '(';
-       M_template_args_need_space = false;
-       if (!decode_type(output))       // Must have at least one parameter.
-         _GLIBCXX_DEMANGLER_FAILURE;
-       while (current() != 'E' && current() != 0)
-       {
-         output += ", ";
-         if (!decode_type(output))
-           _GLIBCXX_DEMANGLER_FAILURE;
-       }
-       output += ')';
-       _GLIBCXX_DEMANGLER_RETURN;
-      }
-
-    // <type> ::=
-    //   <builtin-type>                # Starts with a lower case character != r.
-    //   <function-type>       # Starts with F
-    //   <class-enum-type>     # Starts with N, S, C, D, Z, a digit or a lower
-    //                         # case character.  Since a lower case character
-    //                         # would be an operator name, that would be an
-    //                         # error.  The S is a substitution or St
-    //                         # (::std::).  A 'C' would be a constructor and
-    //                         # thus also an error.
-    //   <template-param>      # Starts with T
-    //   <substitution>         # Starts with S
-    //   <template-template-param> <template-args>  # Starts with T or S,
-    //                                             # equivalent with the above.
-    //
-    //   <array-type>                  # Starts with A
-    //   <pointer-to-member-type>      # Starts with M
-    //   <CV-qualifiers> <type>                # Starts with r, V or K
-    //   P <type>   # pointer-to       # Starts with P
-    //   R <type>   # reference-to     # Starts with R
-    //   C <type>   # complex (C 2000) # Starts with C
-    //   G <type>   # imaginary (C 2000)# Starts with G
-    //   U <source-name> <type>                # vendor extended type qualifier,
-    //                                 # starts with U
-    //
-    // <template-template-param> ::= <template-param>
-    //                           ::= <substitution>
-
-    // My own analysis of how to decode qualifiers:
-    //
-    // F is a <function-type>, <T> is a <builtin-type>, <class-enum-type>,
-    //   <template-param> or <template-template-param> <template-args>.
-    // <Q> represents a series of qualifiers (not G or C).
-    // <C> is an unqualified type.
-    // <R> is a qualified type.
-    // <B> is the bare-function-type without return type.
-    // <I> is the array index.
-    //                                         Substitutions:
-    // <Q>M<C><Q2>F<R><B>E  ==> R (C::*Q)B Q2  "<C>", "F<R><B>E"
-    //                                             (<R> and <B> recursive),
-    //                                             "M<C><Q2>F<R><B>E".
-    // <Q>F<R><B>E         ==> R (Q)B          "<R>", "<B>" (<B> recursive)
-    //                                              and "F<R><B>E".
-    //
-    // Note that if <R> has postfix qualifiers (an array or function), then
-    // those are added AFTER the (member) function type.  For example:
-    // <Q>FPA<R><B>E ==> R (*(Q)B) [], where the PA added the prefix
-    // "(*" and the postfix ") []".
-    //
-    // <Q>G<T>             ==> imaginary T Q   "<T>", "G<T>" (<T> recursive).
-    // <Q>C<T>             ==> complex T Q     "<T>", "C<T>" (<T> recursive).
-    // <Q><T>              ==> T Q             "<T>" (<T> recursive).
-    //
-    // where <Q> is any of:
-    //
-    // <Q>P            ==> *Q                          "P..."
-    // <Q>R            ==> &Q                          "R..."
-    // <Q>[K|V|r]+     ==> [ const| volatile| restrict]+Q      "KVr..."
-    // <Q>U<S>         ==>  SQ                         "U<S>..."
-    // <Q>M<C>         ==> C::*Q                       "M<C>..." (<C> recurs.)
-    // A<I>            ==>  [I]                        "A<I>..." (<I> recurs.)
-    // <Q>A<I>         ==>  (Q) [I]                    "A<I>..." (<I> recurs.)
-    //   Note that when <Q> ends on an A<I2> then the brackets are omitted
-    //   and no space is written between the two:
-    //   A<I2>A<I>     ==>  [I2][I]
-    //   If <Q> ends on [KVr]+, which can happen in combination with
-    //   substitutions only, then special handling is required, see below.
-    //
-    // A <substitution> is handled with an input position switch during which
-    // new substitutions are turned off.  Because recursive handling of types
-    // (and therefore the order in which substitutions must be generated) must
-    // be done left to right, but the generation of Q needs processing right to
-    // left, substitutions per <type> are generated by reading the input left
-    // to right and marking the starts of all substitutions only - implicitly
-    // finishing them at the end of the type.  Then the output and real
-    // substitutions are generated.
-    //
-    // The following comment was for the demangling of g++ version 3.0.x.  The
-    // mangling (and I believe even the ABI description) have been fixed now
-    // (as of g++ version 3.1).
-    //
-    // g++ 3.0.x only:
-    // The ABI specifies for pointer-to-member function types the format
-    // <Q>M<T>F<R><B>E.  In other words, the qualifier <Q2> (see above) is
-    // implicitely contained in <T> instead of explicitly part of the M format.
-    // I am convinced that this is a bug in the ABI.  Unfortunately, this is
-    // how we have to demangle things as it has a direct impact on the order
-    // in which substitutions are stored.  This ill-formed design results in
-    // rather ill-formed demangler code too however :/
-    //
-    // <Q2> is now explicitely part of the M format.
-    // For some weird reason, g++ (3.2.1) does not add substitutions for
-    // qualified member function pointers.  I think that is another bug.
-    //
-
-    // In the case of
-    // <Q>A<I>
-    // where <Q> ends on [K|V|r]+ then that part should be processed as
-    // if it was behind the A<I> instead of in front of it.  This is
-    // because a constant array of ints is normally always mangled as
-    // an array of constant ints.  KVr qualifiers can end up in front
-    // of an array when the array is part of a substitution or template
-    // parameter, but the demangling should still result in the same
-    // syntax; thus KA2_i (const array of ints) must result in the same
-    // demangling as A2_Ki (array of const ints).  As a result we must
-    // demangle ...[...[[KVr]+A<I0>][KVr]+A<I1>]...[KVr]+A<In>[KVr]+
-    // as A<I0>A<I1>...A<In>[KVr]+ where each K, V and r in the series
-    // collapses to a single character at the right of the string.
-    // For example:
-    // VA9_KrA6_KVi --> A9_A6_KVri --> int volatile const restrict [9][6]
-    // Note that substitutions are still added as usual (the translation
-    // to A9_A6_KVri does not really happen).
-    //
-    // This decoding is achieved by delaying the decoding of any sequence
-    // of [KVrA]'s and processing them together in the order: first the
-    // short-circuited KVr part and then the arrays.
-    static int const cvq_K = 1;                // Saw at least one K
-    static int const cvq_V = 2;                // Saw at least one V
-    static int const cvq_r = 4;                // Saw at least one r
-    static int const cvq_A = 8;                // Saw at least one A
-    static int const cvq_last = 16;    // No remaining qualifiers.
-    static int const cvq_A_cnt = 32;   // Bit 5 and higher represent the
-                                       //   number of A's in the series.
-    // In the function below, iter_array points to the first (right most)
-    // A in the series, if any.
-    template<typename Tp, typename Allocator>
-      void
-      qualifier_list<Tp, Allocator>::decode_KVrA(
-          string_type& prefix, string_type& postfix, int cvq,
-          typename qual_vector::const_reverse_iterator const& iter_array) const
-       {
-         _GLIBCXX_DEMANGLER_DOUT_ENTERING3("decode_KVrA");
-         if ((cvq & cvq_K))
-           prefix += " const";
-         if ((cvq & cvq_V))
-           prefix += " volatile";
-         if ((cvq & cvq_r))
-           prefix += " restrict";
-         if ((cvq & cvq_A))
-         {
-           int n = cvq >> 5;
-           for (typename qual_vector::
-               const_reverse_iterator iter = iter_array;
-               iter != M_qualifier_starts.rend(); ++iter)
-           {
-             switch((*iter).first_qualifier())
-             {
-               case 'K':
-               case 'V':
-               case 'r':
-                 break;
-               case 'A':
-               {
-                 string_type index = (*iter).get_optional_type();
-                 if (--n == 0 && (cvq & cvq_last))
-                   postfix = " [" + index + "]" + postfix;
-                 else if (n > 0)
-                   postfix = "[" + index + "]" + postfix;
-                 else
-                 {
-                   prefix += " (";
-                   postfix = ") [" + index + "]" + postfix;
-                 }
-                 break;
-               }
-               default:
-                 _GLIBCXX_DEMANGLER_RETURN3;
-             }
-           }
-         }
-         _GLIBCXX_DEMANGLER_RETURN3;
-       }
-
-    template<typename Tp, typename Allocator>
-      void
-      qualifier_list<Tp, Allocator>::decode_qualifiers(
-         string_type& prefix,
-         string_type& postfix,
-         bool member_function_pointer_qualifiers = false) const
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING3("decode_qualifiers");
-       int cvq = 0;
-       typename qual_vector::const_reverse_iterator iter_array;
-       for(typename qual_vector::
-           const_reverse_iterator iter = M_qualifier_starts.rbegin();
-           iter != M_qualifier_starts.rend(); ++iter)
-       {
-         if (!member_function_pointer_qualifiers
-             && !(*iter).part_of_substitution())
-         {
-           int saved_inside_substitution = M_demangler.M_inside_substitution;
-           M_demangler.M_inside_substitution = 0;
-           M_demangler.add_substitution((*iter).get_start_pos(), type);
-           M_demangler.M_inside_substitution = saved_inside_substitution;
-         }
-         char qualifier_char = (*iter).first_qualifier();
-         for(; qualifier_char; qualifier_char = (*iter).next_qualifier())
-         {
-           switch(qualifier_char)
-           {
-             case 'P':
-               if (cvq)
-               {
-                 decode_KVrA(prefix, postfix, cvq, iter_array);
-                 cvq = 0;
-               }
-               prefix += "*";
-               break;
-             case 'R':
-               if (cvq)
-               {
-                 decode_KVrA(prefix, postfix, cvq, iter_array);
-                 cvq = 0;
-               }
-               prefix += "&";
-               break;
-             case 'K':
-               cvq |= cvq_K;
-               continue;
-             case 'V':
-               cvq |= cvq_V;
-               continue;
-             case 'r':
-               cvq |= cvq_r;
-               continue;
-             case 'A':
-               if (!(cvq & cvq_A))
-               {
-                 cvq |= cvq_A;
-                 iter_array = iter;
-               }
-               cvq += cvq_A_cnt;
-               break;
-             case 'M':
-               if (cvq)
-               {
-                 decode_KVrA(prefix, postfix, cvq, iter_array);
-                 cvq = 0;
-               }
-               prefix += " ";
-               prefix += (*iter).get_optional_type();
-               prefix += "::*";
-               break;
-             case 'U':
-               if (cvq)
-               {
-                 decode_KVrA(prefix, postfix, cvq, iter_array);
-                 cvq = 0;
-               }
-               prefix += " ";
-               prefix += (*iter).get_optional_type();
-               break;
-             case 'G': // Only here so we added a substitution.
-               break;
-           }
-           break;
-         }
-       }
-       if (cvq)
-         decode_KVrA(prefix, postfix, cvq|cvq_last, iter_array);
-       M_printing_suppressed = false;
-       _GLIBCXX_DEMANGLER_RETURN3;
-      }
-
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_type_with_postfix(
-         string_type& prefix, string_type& postfix,
-         qualifier_list<Tp, Allocator>* qualifiers)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING2("decode_type");
-       ++M_inside_type;
-       bool recursive_template_param_or_substitution_call;
-       if (!(recursive_template_param_or_substitution_call = qualifiers))
-       {
-          qualifier_list<Allocator>* raw_qualifiers = M_qualifier_list_alloc.allocate(1);
-         qualifiers = new (raw_qualifiers) qualifier_list<Allocator>(*this);
-       }
-       // First eat all qualifiers.
-       bool failure = false;
-       for(;;)         // So we can use 'continue' to eat the next qualifier.
-       {
-         int start_pos = M_pos;
-         switch(current())
-         {
-           case 'P':
-             qualifiers->add_qualifier_start(pointer, start_pos,
-                 M_inside_substitution);
-             eat_current();
-             continue;
-           case 'R':
-             qualifiers->add_qualifier_start(reference, start_pos,
-                 M_inside_substitution);
-             eat_current();
-             continue;
-           case 'K':
-           case 'V':
-           case 'r':
-           {
-             char c;
-             int count = 0;
-             do
-             {
-               ++count;
-               c = next();
-             }
-             while(c == 'K' || c == 'V' || c == 'r');
-             qualifiers->add_qualifier_start(cv_qualifier, start_pos, count,
-                 M_inside_substitution);
-             continue;
-           }
-           case 'U':
-           {
-             eat_current();
-             string_type source_name;
-             if (!decode_source_name(source_name))
-             {
-               failure = true;
-               break;
-             }
-             qualifiers->add_qualifier_start(vendor_extension, start_pos,
-                 source_name, M_inside_substitution);
-             continue;
-           }
-           case 'A':
-           {
-             // <array-type> ::= A <positive dimension number> _ <element type>
-             //              ::= A [<dimension expression>] _ <element type>
-             //
-             string_type index;
-             int saved_pos;
-             store(saved_pos);
-             if (next() == 'n' || !decode_number(index))
-             {
-               restore(saved_pos);
-               if (next() != '_' && !decode_expression(index))
-               {
-                 failure = true;
-                 break;
-               }
-             }
-             if (eat_current() != '_')
-             {
-               failure = true;
-               break;
-             }
-             qualifiers->add_qualifier_start(array, start_pos, index,
-                 M_inside_substitution);
-             continue;
-           }
-           case 'M':
-           {
-             // <pointer-to-member-type> ::= M <class type> <member type>
-             // <Q>M<C> or <Q>M<C><Q2>F<R><B>E
-             eat_current();
-             string_type class_type;
-             if (!decode_type(class_type))             // Substitution: "<C>".
-             {
-               failure = true;
-               break;
-             }
-             char c = current();
-             if (c == 'F' || c == 'K' || c == 'V' || c == 'r')
-                 // Must be CV-qualifiers and a member function pointer.
-             {
-               // <Q>M<C><Q2>F<R><B>E  ==> R (C::*Q)B Q2
-               //     substitutions: "<C>", "F<R><B>E" (<R> and <B>
-               //                    recursive), "M<C><Q2>F<R><B>E".
-               int count = 0;
-               int Q2_start_pos = M_pos;
-               while(c == 'K' || c == 'V' || c == 'r')         // Decode <Q2>.
-               {
-                 ++count;
-                 c = next();
-               }
-               qualifier_list<Tp, Allocator> class_type_qualifiers(*this);
-               if (count)
-                 class_type_qualifiers.
-                     add_qualifier_start(cv_qualifier, Q2_start_pos,
-                         count, M_inside_substitution);
-               string_type member_function_qualifiers;
-               // It is unclear why g++ doesn't add a substitution for
-               // "<Q2>F<R><B>E" as it should I think.
-               string_type member_function_qualifiers_postfix;
-               class_type_qualifiers.
-                   decode_qualifiers(member_function_qualifiers,
-                       member_function_qualifiers_postfix, true);
-               member_function_qualifiers +=
-                   member_function_qualifiers_postfix;
-               // I don't think this substitution is actually ever used.
-               int function_pos = M_pos;
-               if (eat_current() != 'F')
-               {
-                 failure = true;
-                 break;
-               }
-               // Return type.
-               // Constructors, destructors and conversion operators don't
-               // have a return type, but seem to never get here.
-               string_type return_type_postfix;
-               if (!decode_type_with_postfix(prefix, return_type_postfix))
-                   // substitution: <R> recursive
-               {
-                 failure = true;
-                 break;
-               }
-               prefix += " (";
-               prefix += class_type;
-               prefix += "::*";
-               string_type bare_function_type;
-               if (!decode_bare_function_type(bare_function_type)
-                   || eat_current() != 'E')    // Substitution: <B> recursive.
-               {
-                 failure = true;
-                 break;
-               }
-               // substitution: "F<R><B>E".
-               add_substitution(function_pos, type);
-               // substitution: "M<C><Q2>F<R><B>E".
-               add_substitution(start_pos, type);
-               // substitution: all qualified types if any.
-               qualifiers->decode_qualifiers(prefix, postfix);
-               postfix += ")";
-               postfix += bare_function_type;
-               postfix += member_function_qualifiers;
-               postfix += return_type_postfix;
-               goto decode_type_exit;
-             }
-             qualifiers->add_qualifier_start(pointer_to_member, start_pos,
-                 class_type, M_inside_substitution);
-             continue;
-           }
-           default:
-             break;
-         }
-         break;
-       }
-       if (!failure)
-       {
-         // <Q>G<T>                    ==> imaginary T Q
-         //     substitutions: "<T>", "G<T>" (<T> recursive).
-         // <Q>C<T>                    ==> complex T Q
-         //     substitutions: "<T>", "C<T>" (<T> recursive).
-         if (current() == 'C' || current() == 'G')
-         {
-           prefix += current() == 'C' ? "complex " : "imaginary ";
-           qualifiers->add_qualifier_start(complex_or_imaginary, M_pos,
-               M_inside_substitution);
-           eat_current();
-         }
-         int start_pos = M_pos;
-         switch(current())
-         {
-           case 'F':
-           {
-             // <function-type> ::= F [Y] <bare-function-type> E
-             //
-             // Note that g++ never generates the 'Y', but we try to
-             // demangle it anyway.
-             bool extern_C = (next() == 'Y');
-             if (extern_C)
-               eat_current();
-
-             // <Q>F<R><B>E            ==> R (Q)B
-             //     substitution: "<R>", "<B>" (<B> recursive) and "F<R><B>E".
-
-             // Return type.
-             string_type return_type_postfix;
-             if (!decode_type_with_postfix(prefix, return_type_postfix))
-                 // Substitution: "<R>".
-             {
-               failure = true;
-               break;
-             }
-             // Only array and function (pointer) types have a postfix.
-             // In that case we don't want the space but expect something
-             // like prefix is "int (*" and postfix is ") [1]".
-             // We do want the space if this pointer is qualified.
-             if (return_type_postfix.size() == 0 ||
-                 (prefix.size() > 0 && *prefix.rbegin() != '*'))
-               prefix += ' ';
-             prefix += '(';
-             string_type bare_function_type;
-             if (!decode_bare_function_type(bare_function_type)
-                 // substitution: "<B>" (<B> recursive).
-                 || eat_current() != 'E')
-             {
-               failure = true;
-               break;
-             }
-             add_substitution(start_pos, type);  // Substitution: "F<R><B>E".
-             qualifiers->decode_qualifiers(prefix, postfix);
-                 // substitution: all qualified types, if any.
-             postfix += ")";
-             if (extern_C)
-               postfix += " [extern \"C\"] ";
-             postfix += bare_function_type;
-             postfix += return_type_postfix;
-             break;
-           }
-           case 'T':
-             if (!decode_template_param(prefix, qualifiers))
-             {
-               failure = true;
-               break;
-             }
-             if (current() == 'I')
-             {
-               add_substitution(start_pos, template_template_param);
-                   // substitution: "<template-template-param>".
-               if (!decode_template_args(prefix))
-               {
-                 failure = true;
-                 break;
-               }
-             }
-             if (!recursive_template_param_or_substitution_call
-                 && qualifiers->suppressed())
-             {
-               add_substitution(start_pos, type);
-                   // substitution: "<template-param>" or
-                   // "<template-template-param> <template-args>".
-               qualifiers->decode_qualifiers(prefix, postfix);
-                   // substitution: all qualified types, if any.
-             }
-             break;
-           case 'S':
-             if (M_pos >= M_maxpos)
-             {
-               failure = true;
-               break;
-             }
-             if (M_str[M_pos + 1] != 't')
-             {
-               if (!decode_substitution(prefix, qualifiers))
-               {
-                 failure = true;
-                 break;
-               }
-               if (current() == 'I')
-               {
-                 if (!decode_template_args(prefix))
-                 {
-                   failure = true;
-                   break;
-                 }
-                 if (!recursive_template_param_or_substitution_call
-                     && qualifiers->suppressed())
-                   add_substitution(start_pos, type);
-                       // Substitution:
-                       //   "<template-template-param> <template-args>".
-               }
-               if (!recursive_template_param_or_substitution_call
-                   && qualifiers->suppressed())
-                 qualifiers->decode_qualifiers(prefix, postfix);
-                     // Substitution: all qualified types, if any.
-               break;
-             }
-             /* Fall-through for St */
-           case 'N':
-           case 'Z':
-           case '0':
-           case '1':
-           case '2':
-           case '3':
-           case '4':
-           case '5':
-           case '6':
-           case '7':
-           case '8':
-           case '9':
-             // <Q><T>                 ==> T Q
-             //     substitutions: "<T>" (<T> recursive).
-             if (!decode_class_enum_type(prefix))
-             {
-               failure = true;
-               break;
-             }
-             if (!recursive_template_param_or_substitution_call)
-             {
-               add_substitution(start_pos, type);
-                   // substitution: "<class-enum-type>".
-               qualifiers->decode_qualifiers(prefix, postfix);
-                   // substitution: all qualified types, if any.
-             }
-             else
-               qualifiers->printing_suppressed();
-             break;
-           default:
-             // <Q><T>                 ==> T Q
-             //     substitutions: "<T>" (<T> recursive).
-             if (!decode_builtin_type(prefix))
-             {
-               failure = true;
-               break;
-             }
-             // If decode_type was called from decode_template_param then we
-             // need to suppress calling qualifiers here in order to get a
-             // substitution added anyway (for the <template-param>).
-             if (!recursive_template_param_or_substitution_call)
-               qualifiers->decode_qualifiers(prefix, postfix);
-             else
-               qualifiers->printing_suppressed();
-             break;
-         }
-       }
-    decode_type_exit:
-       --M_inside_type;
-       if (!recursive_template_param_or_substitution_call)
-       {
-         qualifiers->~qualifier_list<Allocator>();
-         M_qualifier_list_alloc.deallocate(qualifiers, 1);
-       }
-       if (failure)
-         _GLIBCXX_DEMANGLER_FAILURE;
-       _GLIBCXX_DEMANGLER_RETURN2;
-      }
-
-    // <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
-    //               ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
-    //
-    // <prefix> ::= <prefix> <unqualified-name>
-    //          ::= <template-prefix> <template-args>
-    //          ::= <template-param>
-    //          ::= # empty
-    //          ::= <substitution>
-    //
-    // <template-prefix> ::= <prefix> <template unqualified-name>
-    //                   ::= <template-param>
-    //                   ::= <substitution>
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_nested_name(string_type& output,
-                                            string_type& qualifiers)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_nested_name");
-
-       if (current() != 'N' || M_pos >= M_maxpos)
-         _GLIBCXX_DEMANGLER_FAILURE;
-
-       // <CV-qualifiers> ::= [r] [V] [K]  # restrict (C99), volatile, const
-       char const* qualifiers_start = &M_str[M_pos + 1];
-       for (char c = next(); c == 'K' || c == 'V' || c == 'r'; c = next());
-       for (char const* qualifier_ptr = &M_str[M_pos - 1];
-            qualifier_ptr >= qualifiers_start; --qualifier_ptr)
-         switch(*qualifier_ptr)
-         {
-           case 'K':
-             qualifiers += " const";
-             break;
-           case 'V':
-             qualifiers += " volatile";
-             break;
-           case 'r':
-             qualifiers += " restrict";
-             break;
-         }
-
-       int number_of_prefixes = 0;
-       int substitution_start = M_pos;
-       for(;;)
-       {
-         ++number_of_prefixes;
-         if (current() == 'S')
-         {
-           if (!decode_substitution(output))
-             _GLIBCXX_DEMANGLER_FAILURE;
-         }
-         else if (current() == 'I')
-         {
-           if (!decode_template_args(output))
-             _GLIBCXX_DEMANGLER_FAILURE;
-           if (current() != 'E')
-           {
-             // substitution: "<template-prefix> <template-args>".
-             add_substitution(substitution_start, nested_name_prefix,
-                              number_of_prefixes);
-           }
-         }
-         else
-         {
-           if (current() == 'T')
-           {
-             if (!decode_template_param(output))
-               _GLIBCXX_DEMANGLER_FAILURE;
-           }
-           else if (!decode_unqualified_name(output))
-             _GLIBCXX_DEMANGLER_FAILURE;
-           if (current() != 'E')
-           {
-             // substitution: "<prefix> <unqualified-name>" or
-             // "<prefix> <template unqualified-name>".
-             add_substitution(substitution_start,
-                 (current() == 'I') ?  nested_name_template_prefix
-                                    : nested_name_prefix,
-                 number_of_prefixes);
-           }
-         }
-         if (current() == 'E')
-         {
-           eat_current();
-           _GLIBCXX_DEMANGLER_RETURN;
-         }
-         if (current() != 'I')
-           output += "::";
-         else if (M_template_args_need_space)
-           output += ' ';
-         M_template_args_need_space = false;
-       }
-       _GLIBCXX_DEMANGLER_FAILURE;
-      }
-
-    // <local-name> := Z <function encoding> E <entity name> [<discriminator>]
-    //              := Z <function encoding> E s [<discriminator>]
-    // <discriminator> := _ <non-negative number>
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_local_name(string_type& output)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_local_name");
-       if (current() != 'Z' || M_pos >= M_maxpos)
-         _GLIBCXX_DEMANGLER_FAILURE;
-       if ((M_pos += decode_encoding(output, M_str + M_pos + 1,
-               M_maxpos - M_pos, M_implementation_details) + 1) < 0 ||
-               eat_current() != 'E')
-         _GLIBCXX_DEMANGLER_FAILURE;
-       output += "::";
-       if (current() == 's')
-       {
-         eat_current();
-         output += "string literal";
-       }
-       else
-       {
-         string_type nested_name_qualifiers;
-         if (!decode_name(output, nested_name_qualifiers))
-           _GLIBCXX_DEMANGLER_FAILURE;
-         output += nested_name_qualifiers;
-       }
-       string_type discriminator;
-       if (current() == '_' && next() != 'n' && !decode_number(discriminator))
-         _GLIBCXX_DEMANGLER_FAILURE;
-       _GLIBCXX_DEMANGLER_RETURN;
-      }
-
-    // <source-name> ::= <positive length number> <identifier>
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_source_name(string_type& output)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_source_name");
-       int length = current() - '0';
-       if (length < 1 || length > 9)
-         _GLIBCXX_DEMANGLER_FAILURE;
-       while(isdigit(next()))
-         length = 10 * length + current() - '0';
-       char const* ptr = &M_str[M_pos];
-       if (length > 11 && !strncmp(ptr, "_GLOBAL_", 8) && ptr[9] == 'N'
-           && ptr[8] == ptr[10])
-       {
-         output += "(anonymous namespace)";
-         if ((M_pos += length) > M_maxpos + 1)
-           _GLIBCXX_DEMANGLER_FAILURE;
-       }
-       else
-         while(length--)
-         {
-           if (current() == 0)
-             _GLIBCXX_DEMANGLER_FAILURE;
-           output += eat_current();
-         }
-       _GLIBCXX_DEMANGLER_RETURN;
-      }
-
-    // <unqualified-name> ::= <operator-name>  # Starts with lower case.
-    //                    ::= <ctor-dtor-name>  # Starts with 'C' or 'D'.
-    //                    ::= <source-name>    # Starts with a digit.
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_unqualified_name(string_type& output)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_unqualified_name");
-       if (M_inside_template_args)
-       {
-         if (!decode_source_name(output))
-           _GLIBCXX_DEMANGLER_FAILURE;
-       }
-       else if (isdigit(current()))
-       {
-         bool recursive_unqualified_name = (&M_function_name == &output);
-         // This can be a recursive call when we are decoding
-         // an <operator-name> that is a cast operator for a some
-         // <unqualified-name>; for example "operator Foo()".
-         // In that case this is thus not a ctor or dtor and we
-         // are not interested in updating M_function_name.
-         if (!recursive_unqualified_name)
-           M_function_name.clear();
-         M_name_is_template = false;
-         M_name_is_cdtor = false;
-         M_name_is_conversion_operator = false;
-         if (!decode_source_name(M_function_name))
-           _GLIBCXX_DEMANGLER_FAILURE;
-         if (!recursive_unqualified_name)
-           output += M_function_name;
-       }
-       else if (islower(current()))
-       {
-         M_function_name.clear();
-         M_name_is_template = false;
-         M_name_is_cdtor = false;
-         M_name_is_conversion_operator = false;
-         if (!decode_operator_name(M_function_name))
-           _GLIBCXX_DEMANGLER_FAILURE;
-         output += M_function_name;
-       }
-       else if (current() == 'C' || current() == 'D')
-       {
-         // <ctor-dtor-name> ::=
-         //   C1       # complete object (in-charge) constructor
-         //   C2       # base object (not-in-charge) constructor
-         //   C3       # complete object (in-charge) allocating constructor
-         //   D0       # deleting (in-charge) destructor
-         //   D1       # complete object (in-charge) destructor
-         //   D2       # base object (not-in-charge) destructor
-         //
-         if (current() == 'C')
-         {
-           char c = next();
-           if (c < '1' || c > '3')
-             _GLIBCXX_DEMANGLER_FAILURE;
-         }
-         else
-         {
-           char c = next();
-           if (c < '0' || c > '2')
-             _GLIBCXX_DEMANGLER_FAILURE;
-           output += '~';
-           M_saw_destructor = true;
-         }
-         M_name_is_cdtor = true;
-         eat_current();
-         output += M_function_name;
-       }
-       else
-         _GLIBCXX_DEMANGLER_FAILURE;
-       _GLIBCXX_DEMANGLER_RETURN;
-      }
-
-    // <unscoped-name> ::=
-    //   <unqualified-name>            # Starts not with an 'S'
-    //   St <unqualified-name>         # ::std::
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_unscoped_name(string_type& output)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_unscoped_name");
-       if (current() == 'S')
-       {
-         if (next() != 't')
-           _GLIBCXX_DEMANGLER_FAILURE;
-         eat_current();
-         output += "std::";
-       }
-       decode_unqualified_name(output);
-       _GLIBCXX_DEMANGLER_RETURN;
-      }
-
-    // <name> ::=
-    //   <nested-name>                         # Starts with 'N'
-    //   <unscoped-template-name> <template-args> # idem
-    //   <local-name>                          # Starts with 'Z'
-    //   <unscoped-name>                       # Starts with 'S', 'C', 'D',
-    //                                         # a digit or a lower case
-    //                                         # character.
-    //
-    // <unscoped-template-name> ::= <unscoped-name>
-    //                          ::= <substitution>
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_name(string_type& output,
-                                     string_type& nested_name_qualifiers)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_name");
-       int substitution_start = M_pos;
-       if (current() == 'S' && (M_pos >= M_maxpos || M_str[M_pos + 1] != 't'))
-       {
-         if (!decode_substitution(output))
-           _GLIBCXX_DEMANGLER_FAILURE;
-       }
-       else if (current() == 'N')
-       {
-         decode_nested_name(output, nested_name_qualifiers);
-         _GLIBCXX_DEMANGLER_RETURN;
-       }
-       else if (current() == 'Z')
-       {
-         decode_local_name(output);
-         _GLIBCXX_DEMANGLER_RETURN;
-       }
-       else if (!decode_unscoped_name(output))
-         _GLIBCXX_DEMANGLER_FAILURE;
-       if (current() == 'I')
-       {
-         // Must have been an <unscoped-template-name>.
-         add_substitution(substitution_start, unscoped_template_name);
-         if (!decode_template_args(output))
-           _GLIBCXX_DEMANGLER_FAILURE;
-       }
-       M_template_args_need_space = false;
-       _GLIBCXX_DEMANGLER_RETURN;
-      }
-
-    // <call-offset> ::= h <nv-offset> _
-    //               ::= v <v-offset> _
-    // <nv-offset>   ::= <offset number>
-    //     non-virtual base override
-    //
-    // <v-offset>    ::= <offset number> _ <virtual offset number>
-    //     virtual base override, with vcall offset
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_call_offset(string_type&
-#if _GLIBCXX_DEMANGLER_CWDEBUG
-         output
-#endif
-         )
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_call_offset");
-       if (current() == 'h')
-       {
-         string_type dummy;
-         eat_current();
-         if (decode_number(dummy) && current() == '_')
-         {
-           eat_current();
-           _GLIBCXX_DEMANGLER_RETURN;
-         }
-       }
-       else if (current() == 'v')
-       {
-         string_type dummy;
-         eat_current();
-         if (decode_number(dummy) && current() == '_')
-         {
-           eat_current();
-           if (decode_number(dummy) && current() == '_')
-           {
-             eat_current();
-             _GLIBCXX_DEMANGLER_RETURN;
-           }
-         }
-       }
-       _GLIBCXX_DEMANGLER_FAILURE;
-      }
-
-    //
-    // <special-name> ::=
-    //   TV <type>                     # virtual table
-    //   TT <type>                     # VTT structure (construction
-    //                                    vtable index).
-    //   TI <type>                     # typeinfo structure
-    //   TS <type>                     # typeinfo name (null-terminated
-    //                                    byte string).
-    //   GV <object name>              # Guard variable for one-time
-    //                                   initialization of static objects in
-    //                                   a local scope.
-    //   T <call-offset> <base encoding># base is the nominal target function
-    //                                   of thunk.
-    //   Tc <call-offset> <call-offset> <base encoding> # base is the nominal
-    //                                    target function of thunk; first
-    //                                    call-offset is 'this' adjustment;
-    //                                   second call-offset is result
-    //                                   adjustment
-    //
-    template<typename Tp, typename Allocator>
-      bool
-      session<Tp, Allocator>::decode_special_name(string_type& output)
-      {
-       _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_special_name");
-       if (current() == 'G')
-       {
-         if (next() != 'V')
-           _GLIBCXX_DEMANGLER_FAILURE;
-         output += "guard variable for ";
-         string_type nested_name_qualifiers;
-         eat_current();
-         if (!decode_name(output, nested_name_qualifiers))
-           _GLIBCXX_DEMANGLER_FAILURE;
-         output += nested_name_qualifiers;
-         _GLIBCXX_DEMANGLER_RETURN;
-       }
-       else if (current() != 'T')
-         _GLIBCXX_DEMANGLER_FAILURE;
-       switch(next())
-       {
-         case 'V':
-           output += "vtable for ";
-           eat_current();
-           decode_type(output);
-           _GLIBCXX_DEMANGLER_RETURN;
-         case 'T':
-           output += "VTT for ";
-           eat_current();
-           decode_type(output);
-           _GLIBCXX_DEMANGLER_RETURN;
-         case 'I':
-           output += "typeinfo for ";
-           eat_current();
-           decode_type(output);
-           _GLIBCXX_DEMANGLER_RETURN;
-         case 'S':
-           output += "typeinfo name for ";
-           eat_current();
-           decode_type(output);
-           _GLIBCXX_DEMANGLER_RETURN;
-         case 'c':
-           output += "covariant return thunk to ";
-           if (!decode_call_offset(output)
-               || !decode_call_offset(output)
-               || (M_pos += decode_encoding(output, M_str + M_pos,
-                   M_maxpos - M_pos + 1, M_implementation_details)) < 0)
-             _GLIBCXX_DEMANGLER_FAILURE;
-           _GLIBCXX_DEMANGLER_RETURN;
-         case 'C':             // GNU extension?
-         {
-           string_type first;
-           output += "construction vtable for ";
-           eat_current();
-           if (!decode_type(first))
-             _GLIBCXX_DEMANGLER_FAILURE;
-           while(isdigit(current()))
-             eat_current();
-           if (eat_current() != '_')
-             _GLIBCXX_DEMANGLER_FAILURE;
-           if (!decode_type(output))
-             _GLIBCXX_DEMANGLER_FAILURE;
-           output += "-in-";
-           output += first;
-           _GLIBCXX_DEMANGLER_RETURN;
-         }
-         default:
-           if (current() == 'v')
-             output += "virtual thunk to ";
-           else
-             output += "non-virtual thunk to ";
-           if (!decode_call_offset(output)
-               || (M_pos += decode_encoding(output, M_str + M_pos,
-                   M_maxpos - M_pos + 1, M_implementation_details)) < 0)
-             _GLIBCXX_DEMANGLER_FAILURE;
-           _GLIBCXX_DEMANGLER_RETURN;
-       }
-      }
-
-    // <encoding> ::=
-    //   <function name> <bare-function-type>  # Starts with 'C', 'D', 'N',
-    //                                           'S', a digit or a lower case
-    //                                           character.
-    //   <data name>                           # Idem.
-    //   <special-name>                                # Starts with 'T' or 'G'.
-    template<typename Tp, typename Allocator>
-      int
-      session<Tp, Allocator>::decode_encoding(string_type& output,
-          char const* in, int len, implementation_details const& id)
-      {
-#if _GLIBCXX_DEMANGLER_CWDEBUG
-       _GLIBCXX_DEMANGLER_DOUT(dc::demangler,
-           "Output thus far: \"" << output << '"');
-       string_type input(in, len > 0x40000000 ? strlen(in) : len);
-       _GLIBCXX_DEMANGLER_DOUT(
-           dc::demangler, "Entering decode_encoding(\"" << input << "\")");
-#endif
-       if (len <= 0)
-         return INT_MIN;
-       session<Tp, Allocator> demangler_session(in, len, id);
-       string_type nested_name_qualifiers;
-       int saved_pos;
-       demangler_session.store(saved_pos);
-       if (demangler_session.decode_special_name(output))
-         return demangler_session.M_pos;
-       demangler_session.restore(saved_pos);
-       string_type name;
-       if (!demangler_session.decode_name(name, nested_name_qualifiers))
-         return INT_MIN;
-       if (demangler_session.current() == 0
-           || demangler_session.current() == 'E')
-       {
-         output += name;
-         output += nested_name_qualifiers;
-         return demangler_session.M_pos;
-       }
-       // Must have been a <function name>.
-       string_type return_type_postfix;
-       if (demangler_session.M_name_is_template
-           && !(demangler_session.M_name_is_cdtor
-                || demangler_session.M_name_is_conversion_operator))
-       {
-         // Return type of function
-         if (!demangler_session.decode_type_with_postfix(output,
-             return_type_postfix))
-           return INT_MIN;
-         output += ' ';
-       }
-       output += name;
-       if (!demangler_session.decode_bare_function_type(output))
-         return INT_MIN;
-       output += nested_name_qualifiers;
-       output += return_type_postfix;
-       return demangler_session.M_pos;
-      }
-
-    } // namespace demangler
-
-  // Public interface
-  template<typename Tp, typename Allocator>
-    struct demangle
-    {
-      typedef typename Allocator::template rebind<char>::other char_Allocator;
-      typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
-         string_type;
-      static string_type symbol(char const* in,
-                                demangler::implementation_details const& id);
-      static string_type type(char const* in,
-                              demangler::implementation_details const& id);
-    };
-
-  // demangle::symbol()
-  //
-  // Demangle `input' which should be a mangled function name as for
-  // instance returned by nm(1).
-  template<typename Tp, typename Allocator>
-    typename demangle<Tp, Allocator>::string_type
-    demangle<Tp, Allocator>::symbol(char const* input,
-                                demangler::implementation_details const& id)
-    {
-      // <mangled-name> ::= _Z <encoding>
-      // <mangled-name> ::= _GLOBAL_ _<type>_ <disambiguation part>
-      //                    <type> can be I or D (GNU extension)
-      typedef demangler::session<Tp, Allocator> demangler_type;
-      string_type result;
-      bool failure = (input[0] != '_');
-
-      if (!failure)
-      {
-       if (input[1] == 'G')
-       {
-         if (!strncmp(input, "_GLOBAL__", 9)
-             && (input[9] == 'D' || input[9] == 'I')
-             && input[10] == '_')
-         {
-           if (input[9] == 'D')
-             result.assign("global destructors keyed to ", 28);
-           else
-             result.assign("global constructors keyed to ", 29);
-           // Output the disambiguation part as-is.
-           result += input + 11;
-         }
-         else
-           failure = true;
-       }
-       else if (input[1] == 'Z')
-       {
-         int cnt =
-             demangler_type::decode_encoding(result, input + 2, INT_MAX, id);
-         if (cnt < 0 || input[cnt + 2] != 0)
-           failure = true;
-       }
-       else
-         failure = true;
-      }
-
-      // Failure to demangle, return the mangled name.
-      if (failure)
-       result.assign(input, strlen(input));
-
-      return result;
-    }
-
-  // demangle::type()
-  // Demangle `input' which must be a zero terminated mangled type
-  // name as for instance returned by std::type_info::name().
-  template<typename Tp, typename Allocator>
-    typename demangle<Tp, Allocator>::string_type
-    demangle<Tp, Allocator>::type(char const* input,
-                              demangler::implementation_details const& id)
-    {
-      std::basic_string<char, std::char_traits<char>, Allocator> result;
-      if (input == NULL)
-       result = "(null)";
-      else
-      {
-       demangler::session<Tp, Allocator> demangler_session(input, INT_MAX, id);
-       if (!demangler_session.decode_type(result)
-           || demangler_session.remaining_input_characters())
-       {
-         // Failure to demangle, return the mangled name.
-         result = input;
-       }
-      }
-      return result;
-    }
-} // namespace __gnu_cxx
-
-#endif // __DEMANGLE_H
index 1ddc30b..9962ca7 100644 (file)
@@ -1,4 +1,4 @@
-# $DragonFly: src/gnu/lib/gcc34/libstdc++/Makefile,v 1.3 2005/04/21 16:36:34 joerg Exp $
+# $DragonFly: src/gnu/lib/gcc34/libstdc++/Makefile,v 1.4 2005/05/24 06:29:33 joerg Exp $
 
 .include "../Makefile.inc"
 
@@ -118,7 +118,7 @@ DEBUGHDRS+= safe_iterator.tcc safe_sequence.h set set.h string vector
 DEBUGHDRS:=    ${DEBUGHDRS:S;^;${SRCDIR}/include/debug/;}
 DEBUGHDRSDIR=  ${INCLUDEDIR}/c++/3.4/debug
 
-EXTHDRS=       algorithm bitmap_allocator.h debug_allocator.h demangle.h
+EXTHDRS=       algorithm bitmap_allocator.h debug_allocator.h
 EXTHDRS+=      enc_filebuf.h functional hash_fun.h hash_map hash_set
 EXTHDRS+=      hashtable.h iterator malloc_allocator.h memory mt_allocator.h
 EXTHDRS+=      new_allocator.h numeric pod_char_traits.h pool_allocator.h
index 73b235b..39cad7b 100644 (file)
@@ -1,4 +1,4 @@
-# $DragonFly: src/gnu/usr.bin/cc34/Makefile.langs,v 1.4 2004/12/21 15:13:56 joerg Exp $
+# $DragonFly: src/gnu/usr.bin/cc34/Makefile.langs,v 1.5 2005/05/24 06:29:33 joerg Exp $
 
 .if !defined(NO_CXX)
 gencheck_defs= cp/cp-tree.def
@@ -57,6 +57,7 @@ GTFILES = $(srcdir)/input.h $(srcdir)/coretypes.h $(srcdir)/cpplib.h \
   $(srcdir)/c-common.h $(srcdir)/c-tree.h \
   $(srcdir)/alias.c $(srcdir)/bitmap.c $(srcdir)/cselib.c $(srcdir)/cgraph.c \
   $(srcdir)/dbxout.c $(srcdir)/dwarf2out.c $(srcdir)/dwarf2asm.c \
+  $(srcdir)/dojump.c \
   $(srcdir)/emit-rtl.c $(srcdir)/except.c $(srcdir)/explow.c $(srcdir)/expr.c \
   $(srcdir)/fold-const.c $(srcdir)/function.c \
   $(srcdir)/gcse.c $(srcdir)/integrate.c $(srcdir)/lists.c $(srcdir)/optabs.c \
index b3180c4..f792114 100644 (file)
@@ -1,11 +1,11 @@
-$DragonFly: src/gnu/usr.bin/cc34/cc_prep/patches/function.c.patch,v 1.3 2004/12/21 13:10:48 joerg Exp $
+$DragonFly: src/gnu/usr.bin/cc34/cc_prep/patches/function.c.patch,v 1.4 2005/05/24 06:29:33 joerg Exp $
 
 ===================================================================
 RCS file: /home/joerg/wd/repository/dragonflybsd/src/contrib/gcc-3.4/gcc/function.c,v
 retrieving revision 1.2
 diff -u -r1.2 function.c
 --- function.c 20 Dec 2004 19:23:24 -0000      1.2
-+++ function.c 20 Dec 2004 20:48:10 -0000
++++ function.c 11 May 2005 16:36:11 -0000
 @@ -63,6 +63,7 @@
  #include "integrate.h"
  #include "langhooks.h"
@@ -34,7 +34,7 @@ diff -u -r1.2 function.c
  };
  \f
  /* This structure is used to record MEMs or pseudos used to replace VAR, any
-@@ -638,6 +645,7 @@
+@@ -641,6 +648,7 @@
     whose lifetime is controlled by CLEANUP_POINT_EXPRs.  KEEP is 3
     if we are to allocate something at an inner level to be treated as
     a variable in the block (e.g., a SAVE_EXPR).
@@ -42,7 +42,7 @@ diff -u -r1.2 function.c
  
     TYPE is the type that will be used for the stack slot.  */
  
-@@ -648,6 +656,8 @@
+@@ -651,6 +659,8 @@
    unsigned int align;
    struct temp_slot *p, *best_p = 0;
    rtx slot;
@@ -51,7 +51,7 @@ diff -u -r1.2 function.c
  
    /* If SIZE is -1 it means that somebody tried to allocate a temporary
       of a variable size.  */
-@@ -673,7 +683,8 @@
+@@ -676,7 +686,8 @@
        && ! p->in_use
        && objects_must_conflict_p (p->type, type)
        && (best_p == 0 || best_p->size > p->size
@@ -61,7 +61,7 @@ diff -u -r1.2 function.c
        {
        if (p->align == align && p->size == size)
          {
-@@ -708,6 +719,7 @@
+@@ -711,6 +722,7 @@
              p->address = 0;
              p->rtl_expr = 0;
              p->type = best_p->type;
@@ -69,7 +69,7 @@ diff -u -r1.2 function.c
              p->next = temp_slots;
              temp_slots = p;
  
-@@ -768,6 +780,7 @@
+@@ -771,6 +783,7 @@
        p->full_size = frame_offset - frame_offset_old;
  #endif
        p->address = 0;
@@ -77,7 +77,7 @@ diff -u -r1.2 function.c
        p->next = temp_slots;
        temp_slots = p;
      }
-@@ -932,14 +945,16 @@
+@@ -935,14 +948,16 @@
            int delete_q = 0;
            if (! q->in_use && GET_MODE (q->slot) == BLKmode)
              {
@@ -96,18 +96,7 @@ diff -u -r1.2 function.c
                  {
                    /* P comes after Q; combine P into Q.  */
                    q->size += p->size;
-@@ -1449,7 +1464,9 @@
-     }
-   if (new == 0)
--    new = assign_stack_local_1 (decl_mode, GET_MODE_SIZE (decl_mode), 0, func);
-+    new = function ?
-+      assign_stack_local_1 (decl_mode, GET_MODE_SIZE (decl_mode), 0, func)
-+      :       assign_stack_local_for_pseudo_reg (decl_mode, GET_MODE_SIZE (decl_mode), 0);
-   PUT_CODE (reg, MEM);
-   PUT_MODE (reg, decl_mode);
-@@ -3940,7 +3957,8 @@
+@@ -3955,7 +3973,8 @@
                 constant with that register.  */
              temp = gen_reg_rtx (Pmode);
              XEXP (x, 0) = new;
index c67b42b..32f3328 100644 (file)
@@ -1,4 +1,4 @@
-# $DragonFly: src/gnu/usr.bin/cc34/cc_tools/Makefile.tools,v 1.4 2004/06/21 21:49:13 dillon Exp $
+# $DragonFly: src/gnu/usr.bin/cc34/cc_tools/Makefile.tools,v 1.5 2005/05/24 06:29:33 joerg Exp $
 
 .ORDER: options.c options.h
 
@@ -83,7 +83,7 @@ CLEANFILES+=  gt-c-pragma.h gt-cfglayout.h gt-cgraph.h gt-coverage.h
 CLEANFILES+=   gt-cp-call.h gt-cp-decl.h gt-cp-decl2.h gt-cp-mangle.h
 CLEANFILES+=   gt-cp-method.h gt-cp-name-lookup.h gt-cp-parser.h gt-cp-pt.h
 CLEANFILES+=   gt-cp-repo.h gt-cp-semantics.h gt-cp-tree.h gt-cselib.h
-CLEANFILES+=   gt-dbxout.h gt-dwarf2asm.h gt-dwarf2out.h gt-emit-rtl.h
+CLEANFILES+=   gt-dbxout.h gt-dojump.h gt-dwarf2asm.h gt-dwarf2out.h gt-emit-rtl.h
 CLEANFILES+=   gt-except.h gt-explow.h gt-expr.h gt-fold-const.h gt-function.h
 CLEANFILES+=   gt-gcse.h gt-i386.h gt-integrate.h gt-langhooks.h gt-lists.h
 CLEANFILES+=   gt-optabs.h gt-ra-build.h gt-reg-stack.h gt-regclass.h