* target.h (globalize_decl_name): New.

[pf3gnuchains/gcc-fork.git] / libiberty / cp-demangle.c

diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c
index 8f1cfb1..ac1dfe5 100644 (file)
--- a/libiberty/cp-demangle.c
+++ b/libiberty/cp-demangle.c
@@ -913,9 +913,9 @@ CP_STATIC_IF_GLIBCPP_V3
 struct demangle_component *
 cplus_demangle_mangled_name (struct d_info *di, int top_level)
 {
-  if (d_next_char (di) != '_')
+  if (! d_check_char (di, '_'))
     return NULL;
-  if (d_next_char (di) != 'Z')
+  if (! d_check_char (di, 'Z'))
     return NULL;
   return d_encoding (di, top_level);
 }
@@ -1123,7 +1123,7 @@ d_nested_name (struct d_info *di)
   struct demangle_component *ret;
   struct demangle_component **pret;
 
-  if (d_next_char (di) != 'N')
+  if (! d_check_char (di, 'N'))
     return NULL;
 
   pret = d_cv_qualifiers (di, &ret, 1);
@@ -1134,7 +1134,7 @@ d_nested_name (struct d_info *di)
   if (*pret == NULL)
     return NULL;
 
-  if (d_next_char (di) != 'E')
+  if (! d_check_char (di, 'E'))
     return NULL;
 
   return ret;
@@ -1449,11 +1449,8 @@ d_operator_name (struct d_info *di)
 static struct demangle_component *
 d_special_name (struct d_info *di)
 {
-  char c;
-
   di->expansion += 20;
-  c = d_next_char (di);
-  if (c == 'T')
+  if (d_check_char (di, 'T'))
     {
       switch (d_next_char (di))
        {
@@ -1502,7 +1499,7 @@ d_special_name (struct d_info *di)
            offset = d_number (di);
            if (offset < 0)
              return NULL;
-           if (d_next_char (di) != '_')
+           if (! d_check_char (di, '_'))
              return NULL;
            base_type = cplus_demangle_type (di);
            /* We don't display the offset.  FIXME: We should display
@@ -1523,7 +1520,7 @@ d_special_name (struct d_info *di)
          return NULL;
        }
     }
-  else if (c == 'G')
+  else if (d_check_char (di, 'G'))
     {
       switch (d_next_char (di))
        {
@@ -1570,14 +1567,14 @@ d_call_offset (struct d_info *di, int c)
   else if (c == 'v')
     {
       d_number (di);
-      if (d_next_char (di) != '_')
+      if (! d_check_char (di, '_'))
        return 0;
       d_number (di);
     }
   else
     return 0;
 
-  if (d_next_char (di) != '_')
+  if (! d_check_char (di, '_'))
     return 0;
 
   return 1;
@@ -1601,13 +1598,13 @@ d_ctor_dtor_name (struct d_info *di)
       else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
        di->expansion += di->last_name->u.s_string.len;
     }
-  switch (d_next_char (di))
+  switch (d_peek_char (di))
     {
     case 'C':
       {
        enum gnu_v3_ctor_kinds kind;
 
-       switch (d_next_char (di))
+       switch (d_peek_next_char (di))
          {
          case '1':
            kind = gnu_v3_complete_object_ctor;
@@ -1621,6 +1618,7 @@ d_ctor_dtor_name (struct d_info *di)
          default:
            return NULL;
          }
+       d_advance (di, 2);
        return d_make_ctor (di, kind, di->last_name);
       }
 
@@ -1628,7 +1626,7 @@ d_ctor_dtor_name (struct d_info *di)
       {
        enum gnu_v3_dtor_kinds kind;
 
-       switch (d_next_char (di))
+       switch (d_peek_next_char (di))
          {
          case '0':
            kind = gnu_v3_deleting_dtor;
@@ -1642,6 +1640,7 @@ d_ctor_dtor_name (struct d_info *di)
          default:
            return NULL;
          }
+       d_advance (di, 2);
        return d_make_dtor (di, kind, di->last_name);
       }
 
@@ -1925,7 +1924,7 @@ d_function_type (struct d_info *di)
 {
   struct demangle_component *ret;
 
-  if (d_next_char (di) != 'F')
+  if (! d_check_char (di, 'F'))
     return NULL;
   if (d_peek_char (di) == 'Y')
     {
@@ -1934,12 +1933,12 @@ d_function_type (struct d_info *di)
       d_advance (di, 1);
     }
   ret = d_bare_function_type (di, 1);
-  if (d_next_char (di) != 'E')
+  if (! d_check_char (di, 'E'))
     return NULL;
   return ret;
 }
 
-/* <bare-function-type> ::= <type>+  */
+/* <bare-function-type> ::= [J]<type>+  */
 
 static struct demangle_component *
 d_bare_function_type (struct d_info *di, int has_return_type)
@@ -1947,13 +1946,22 @@ d_bare_function_type (struct d_info *di, int has_return_type)
   struct demangle_component *return_type;
   struct demangle_component *tl;
   struct demangle_component **ptl;
+  char peek;
+
+  /* Detect special qualifier indicating that the first argument
+     is the return type.  */
+  peek = d_peek_char (di);
+  if (peek == 'J')
+    {
+      d_advance (di, 1);
+      has_return_type = 1;
+    }
 
   return_type = NULL;
   tl = NULL;
   ptl = &tl;
   while (1)
     {
-      char peek;
       struct demangle_component *type;
 
       peek = d_peek_char (di);
@@ -2012,7 +2020,7 @@ d_array_type (struct d_info *di)
   char peek;
   struct demangle_component *dim;
 
-  if (d_next_char (di) != 'A')
+  if (! d_check_char (di, 'A'))
     return NULL;
 
   peek = d_peek_char (di);
@@ -2040,7 +2048,7 @@ d_array_type (struct d_info *di)
        return NULL;
     }
 
-  if (d_next_char (di) != '_')
+  if (! d_check_char (di, '_'))
     return NULL;
 
   return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
@@ -2056,7 +2064,7 @@ d_pointer_to_member_type (struct d_info *di)
   struct demangle_component *mem;
   struct demangle_component **pmem;
 
-  if (d_next_char (di) != 'M')
+  if (! d_check_char (di, 'M'))
     return NULL;
 
   cl = cplus_demangle_type (di);
@@ -2072,13 +2080,22 @@ d_pointer_to_member_type (struct d_info *di)
      g++ does not work that way.  g++ treats only the CV-qualified
      member function as a substitution source.  FIXME.  So to work
      with g++, we need to pull off the CV-qualifiers here, in order to
-     avoid calling add_substitution() in cplus_demangle_type().  */
+     avoid calling add_substitution() in cplus_demangle_type().  But
+     for a CV-qualified member which is not a function, g++ does
+     follow the ABI, so we need to handle that case here by calling
+     d_add_substitution ourselves.  */
 
   pmem = d_cv_qualifiers (di, &mem, 1);
   if (pmem == NULL)
     return NULL;
   *pmem = cplus_demangle_type (di);
 
+  if (pmem != &mem && (*pmem)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
+    {
+      if (! d_add_substitution (di, mem))
+       return NULL;
+    }
+
   return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
 }
 
@@ -2091,7 +2108,7 @@ d_template_param (struct d_info *di)
 {
   long param;
 
-  if (d_next_char (di) != 'T')
+  if (! d_check_char (di, 'T'))
     return NULL;
 
   if (d_peek_char (di) == '_')
@@ -2104,7 +2121,7 @@ d_template_param (struct d_info *di)
       param += 1;
     }
 
-  if (d_next_char (di) != '_')
+  if (! d_check_char (di, '_'))
     return NULL;
 
   ++di->did_subs;
@@ -2126,7 +2143,7 @@ d_template_args (struct d_info *di)
      constructor or destructor.  */
   hold_last_name = di->last_name;
 
-  if (d_next_char (di) != 'I')
+  if (! d_check_char (di, 'I'))
     return NULL;
 
   al = NULL;
@@ -2171,7 +2188,7 @@ d_template_arg (struct d_info *di)
     case 'X':
       d_advance (di, 1);
       ret = d_expression (di);
-      if (d_next_char (di) != 'E')
+      if (! d_check_char (di, 'E'))
        return NULL;
       return ret;
 
@@ -2298,7 +2315,7 @@ d_expr_primary (struct d_info *di)
 {
   struct demangle_component *ret;
 
-  if (d_next_char (di) != 'L')
+  if (! d_check_char (di, 'L'))
     return NULL;
   if (d_peek_char (di) == '_')
     ret = cplus_demangle_mangled_name (di, 0);
@@ -2344,7 +2361,7 @@ d_expr_primary (struct d_info *di)
        }
       ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
     }
-  if (d_next_char (di) != 'E')
+  if (! d_check_char (di, 'E'))
     return NULL;
   return ret;
 }
@@ -2358,12 +2375,12 @@ d_local_name (struct d_info *di)
 {
   struct demangle_component *function;
 
-  if (d_next_char (di) != 'Z')
+  if (! d_check_char (di, 'Z'))
     return NULL;
 
   function = d_encoding (di, 0);
 
-  if (d_next_char (di) != 'E')
+  if (! d_check_char (di, 'E'))
     return NULL;
 
   if (d_peek_char (di) == 's')
@@ -2468,7 +2485,7 @@ d_substitution (struct d_info *di, int prefix)
 {
   char c;
 
-  if (d_next_char (di) != 'S')
+  if (! d_check_char (di, 'S'))
     return NULL;
 
   c = d_next_char (di);
@@ -2487,6 +2504,8 @@ d_substitution (struct d_info *di, int prefix)
                id = id * 36 + c - 'A' + 10;
              else
                return NULL;
+             if (id < 0)
+               return NULL;
              c = d_next_char (di);
            }
          while (c != '_');
@@ -3025,13 +3044,16 @@ d_print_comp (struct d_print_info *dpi,
 
     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
       {
+       if ((dpi->options & DMGL_RET_POSTFIX) != 0)
+         d_print_function_type (dpi, dc, dpi->modifiers);
+
+       /* Print return type if present */
        if (d_left (dc) != NULL)
          {
            struct d_print_mod dpm;
 
            /* We must pass this type down as a modifier in order to
               print it in the right location.  */
-
            dpm.next = dpi->modifiers;
            dpi->modifiers = &dpm;
            dpm.mod = dc;
@@ -3045,10 +3067,14 @@ d_print_comp (struct d_print_info *dpi,
            if (dpm.printed)
              return;
 
-           d_append_char (dpi, ' ');
+           /* In standard prefix notation, there is a space between the
+              return type and the function signature.  */
+           if ((dpi->options & DMGL_RET_POSTFIX) == 0)
+             d_append_char (dpi, ' ');
          }
 
-       d_print_function_type (dpi, dc, dpi->modifiers);
+       if ((dpi->options & DMGL_RET_POSTFIX) == 0) 
+         d_print_function_type (dpi, dc, dpi->modifiers);
 
        return;
       }
@@ -4003,7 +4029,8 @@ java_demangle_v3 (const char* mangled)
   char *from;
   char *to;
 
-  demangled = d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS, &alc);
+  demangled = d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, 
+                         &alc);
 
   if (demangled == NULL)
     return NULL;