Merge GDB 7.5.1

libiberty/cp-demangle.c

 /* Demangler for g++ V3 ABI.
    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
    Free Software Foundation, Inc.
    Written by Ian Lance Taylor <ian@wasabisystems.com>.
 
    This file is part of the libiberty library, which is part of GCC.
 
    This file 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 of the License, or
@@ skipping 630 matching lines @@
       break;
     case DEMANGLE_COMPONENT_FIXED_TYPE:
       printf ("fixed-point type\n");
       break;
     case DEMANGLE_COMPONENT_ARGLIST:
       printf ("argument list\n");
       break;
     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
       printf ("template argument list\n");
       break;
+    case DEMANGLE_COMPONENT_INITIALIZER_LIST:
+      printf ("initializer list\n");
+      break;
     case DEMANGLE_COMPONENT_CAST:
       printf ("cast\n");
       break;
+    case DEMANGLE_COMPONENT_NULLARY:
+      printf ("nullary operator\n");
+      break;
     case DEMANGLE_COMPONENT_UNARY:
       printf ("unary operator\n");
       break;
     case DEMANGLE_COMPONENT_BINARY:
       printf ("binary operator\n");
       break;
     case DEMANGLE_COMPONENT_BINARY_ARGS:
       printf ("binary operator arguments\n");
       break;
     case DEMANGLE_COMPONENT_TRINARY:
@@ skipping 135 matching lines @@
     case DEMANGLE_COMPONENT_TYPED_NAME:
     case DEMANGLE_COMPONENT_TEMPLATE:
     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
     case DEMANGLE_COMPONENT_UNARY:
     case DEMANGLE_COMPONENT_BINARY:
     case DEMANGLE_COMPONENT_BINARY_ARGS:
     case DEMANGLE_COMPONENT_TRINARY:
     case DEMANGLE_COMPONENT_TRINARY_ARG1:
-    case DEMANGLE_COMPONENT_TRINARY_ARG2:
     case DEMANGLE_COMPONENT_LITERAL:
     case DEMANGLE_COMPONENT_LITERAL_NEG:
     case DEMANGLE_COMPONENT_COMPOUND_NAME:
     case DEMANGLE_COMPONENT_VECTOR_TYPE:
     case DEMANGLE_COMPONENT_CLONE:
       if (left == NULL || right == NULL)
         return NULL;
       break;
 
       /* These types only require one parameter.  */
@@ skipping 16 matching lines @@
     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
     case DEMANGLE_COMPONENT_COMPLEX:
     case DEMANGLE_COMPONENT_IMAGINARY:
     case DEMANGLE_COMPONENT_VENDOR_TYPE:
     case DEMANGLE_COMPONENT_CAST:
     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
     case DEMANGLE_COMPONENT_DECLTYPE:
     case DEMANGLE_COMPONENT_PACK_EXPANSION:
     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
+    case DEMANGLE_COMPONENT_NULLARY:
+    case DEMANGLE_COMPONENT_TRINARY_ARG2:
       if (left == NULL)
         return NULL;
       break;
 
       /* This needs a right parameter, but the left parameter can be
          empty.  */
     case DEMANGLE_COMPONENT_ARRAY_TYPE:
+    case DEMANGLE_COMPONENT_INITIALIZER_LIST:
       if (right == NULL)
         return NULL;
       break;
 
       /* These are allowed to have no parameters--in some cases they
          will be filled in later.  */
     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
     case DEMANGLE_COMPONENT_RESTRICT:
     case DEMANGLE_COMPONENT_VOLATILE:
     case DEMANGLE_COMPONENT_CONST:
@@ skipping 541 matching lines @@
 
   peek = d_peek_char (di);
   if (IS_DIGIT (peek))
     return d_source_name (di);
   else if (IS_LOWER (peek))
     {
       struct demangle_component *ret;
 
       ret = d_operator_name (di);
       if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
-        di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
+        {
+          di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
+          if (!strcmp (ret->u.s_operator.op->code, "li"))
+            ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret,
+                               d_source_name (di));
+        }
       return ret;
     }
   else if (peek == 'C' || peek == 'D')
     return d_ctor_dtor_name (di);
   else if (peek == 'L')
     {
       struct demangle_component * ret;
 
       d_advance (di, 1);
 
@@ skipping 122 matching lines @@
                               sizeof "(anonymous namespace)" - 1);
         }
     }
 
   return d_make_name (di, name, len);
 }
 
 /* operator_name ::= many different two character encodings.
                  ::= cv <type>
                  ::= v <digit> <source-name>
-*/
+
+   This list is sorted for binary search.  */
 
 #define NL(s) s, (sizeof s) - 1
 
 CP_STATIC_IF_GLIBCPP_V3
 const struct demangle_operator_info cplus_demangle_operators[] =
 {
   { "aN", NL ("&="),        2 },
   { "aS", NL ("="),         2 },
   { "aa", NL ("&&"),        2 },
   { "ad", NL ("&"),         1 },
   { "an", NL ("&"),         2 },
+  { "at", NL ("alignof "),   1 },
+  { "az", NL ("alignof "),   1 },
   { "cl", NL ("()"),        2 },
   { "cm", NL (","),         2 },
   { "co", NL ("~"),         1 },
   { "dV", NL ("/="),        2 },
-  { "da", NL ("delete[]"),  1 },
+  { "da", NL ("delete[] "), 1 },
   { "de", NL ("*"),         1 },
-  { "dl", NL ("delete"),    1 },
+  { "dl", NL ("delete "),   1 },
+  { "ds", NL (".*"),        2 },
   { "dt", NL ("."),         2 },
   { "dv", NL ("/"),         2 },
   { "eO", NL ("^="),        2 },
   { "eo", NL ("^"),         2 },
   { "eq", NL ("=="),        2 },
   { "ge", NL (">="),        2 },
+  { "gs", NL ("::"),        1 },
   { "gt", NL (">"),         2 },
   { "ix", NL ("[]"),        2 },
   { "lS", NL ("<<="),       2 },
   { "le", NL ("<="),        2 },
+  { "li", NL ("operator\"\" "), 1 },
   { "ls", NL ("<<"),        2 },
   { "lt", NL ("<"),         2 },
   { "mI", NL ("-="),        2 },
   { "mL", NL ("*="),        2 },
   { "mi", NL ("-"),         2 },
   { "ml", NL ("*"),         2 },
   { "mm", NL ("--"),        1 },
-  { "na", NL ("new[]"),     1 },
+  { "na", NL ("new[]"),     3 },
   { "ne", NL ("!="),        2 },
   { "ng", NL ("-"),         1 },
   { "nt", NL ("!"),         1 },
-  { "nw", NL ("new"),       1 },
+  { "nw", NL ("new"),       3 },
   { "oR", NL ("|="),        2 },
   { "oo", NL ("||"),        2 },
   { "or", NL ("|"),         2 },
   { "pL", NL ("+="),        2 },
   { "pl", NL ("+"),         2 },
   { "pm", NL ("->*"),       2 },
   { "pp", NL ("++"),        1 },
   { "ps", NL ("+"),         1 },
   { "pt", NL ("->"),        2 },
   { "qu", NL ("?"),         3 },
   { "rM", NL ("%="),        2 },
   { "rS", NL (">>="),       2 },
   { "rm", NL ("%"),         2 },
   { "rs", NL (">>"),        2 },
   { "st", NL ("sizeof "),   1 },
   { "sz", NL ("sizeof "),   1 },
-  { "at", NL ("alignof "),   1 },
-  { "az", NL ("alignof "),   1 },
+  { "tr", NL ("throw"),     0 },
+  { "tw", NL ("throw "),    1 },
   { NULL, NULL, 0,          0 }
 };
 
 static struct demangle_component *
 d_operator_name (struct d_info *di)
 {
   char c1;
   char c2;
 
   c1 = d_next_char (di);
@@ skipping 609 matching lines @@
       peek = d_next_char (di);
       switch (peek)
         {
         case 'T':
         case 't':
           /* decltype (expression) */
           ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
                              d_expression (di), NULL);
           if (ret && d_next_char (di) != 'E')
             ret = NULL;
+          can_subst = 1;
           break;
           
         case 'p':
           /* Pack expansion.  */
           ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
                              cplus_demangle_type (di), NULL);
+          can_subst = 1;
+          break;
+
+        case 'a':
+          /* auto */
+          ret = d_make_name (di, "auto", 4);
           break;
           
         case 'f':
           /* 32-bit decimal floating point */
           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
           di->expansion += ret->u.s_builtin.type->len;
           break;
         case 'd':
           /* 64-bit DFP */
           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
@@ skipping 30 matching lines @@
           ret->u.s_fixed.length = cplus_demangle_type (di);
           if (ret->u.s_fixed.length == NULL)
             return NULL;
           d_number (di);
           peek = d_next_char (di);
           ret->u.s_fixed.sat = (peek == 's');
           break;
 
         case 'v':
           ret = d_vector_type (di);
+          can_subst = 1;
           break;
 
         case 'n':
           /* decltype(nullptr) */
           ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
           di->expansion += ret->u.s_builtin.type->len;
           break;
 
         default:
           return NULL;
@@ skipping 357 matching lines @@
 {
   struct demangle_component *hold_last_name;
   struct demangle_component *al;
   struct demangle_component **pal;
 
   /* Preserve the last name we saw--don't let the template arguments
      clobber it, as that would give us the wrong name for a subsequent
      constructor or destructor.  */
   hold_last_name = di->last_name;
 
-  if (! d_check_char (di, 'I'))
+  if (d_peek_char (di) != 'I'
+      && d_peek_char (di) != 'J')
     return NULL;
+  d_advance (di, 1);
 
   if (d_peek_char (di) == 'E')
     {
       /* An argument pack can be empty.  */
       d_advance (di, 1);
       return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
     }
 
   al = NULL;
   pal = &al;
@@ skipping 38 matching lines @@
       d_advance (di, 1);
       ret = d_expression (di);
       if (! d_check_char (di, 'E'))
         return NULL;
       return ret;
 
     case 'L':
       return d_expr_primary (di);
 
     case 'I':
+    case 'J':
       /* An argument pack.  */
       return d_template_args (di);
 
     default:
       return cplus_demangle_type (di);
     }
 }
 
-/* Subroutine of <expression> ::= cl <expression>+ E */
+/* Parse a sequence of expressions until we hit the terminator
+   character.  */
 
 static struct demangle_component *
-d_exprlist (struct d_info *di)
+d_exprlist (struct d_info *di, char terminator)
 {
   struct demangle_component *list = NULL;
   struct demangle_component **p = &list;
 
-  if (d_peek_char (di) == 'E')
+  if (d_peek_char (di) == terminator)
     {
       d_advance (di, 1);
       return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
     }
 
   while (1)
     {
       struct demangle_component *arg = d_expression (di);
       if (arg == NULL)
         return NULL;
 
       *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
       if (*p == NULL)
         return NULL;
       p = &d_right (*p);
 
-      if (d_peek_char (di) == 'E')
+      if (d_peek_char (di) == terminator)
         {
           d_advance (di, 1);
           break;
         }
     }
 
   return list;
 }
 
 /* <expression> ::= <(unary) operator-name> <expression>
@@ skipping 70 matching lines @@
 
       name = d_unqualified_name (di);
       if (name == NULL)
         return NULL;
       if (d_peek_char (di) == 'I')
         return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
                             d_template_args (di));
       else
         return name;
     }
+  else if ((peek == 'i' || peek == 't')
+           && d_peek_next_char (di) == 'l')
+    {
+      /* Brace-enclosed initializer list, untyped or typed.  */
+      struct demangle_component *type = NULL;
+      if (peek == 't')
+        type = cplus_demangle_type (di);
+      d_advance (di, 2);
+      return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
+                          type, d_exprlist (di, 'E'));
+    }
   else
     {
       struct demangle_component *op;
+      const char *code = NULL;
       int args;
 
       op = d_operator_name (di);
       if (op == NULL)
         return NULL;
 
       if (op->type == DEMANGLE_COMPONENT_OPERATOR)
-        di->expansion += op->u.s_operator.op->len - 2;
-
-      if (op->type == DEMANGLE_COMPONENT_OPERATOR
-          && strcmp (op->u.s_operator.op->code, "st") == 0)
-        return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
-                            cplus_demangle_type (di));
+        {
+          code = op->u.s_operator.op->code;
+          di->expansion += op->u.s_operator.op->len - 2;
+          if (strcmp (code, "st") == 0)
+            return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
+                                cplus_demangle_type (di));
+        }
 
       switch (op->type)
         {
         default:
           return NULL;
         case DEMANGLE_COMPONENT_OPERATOR:
           args = op->u.s_operator.op->args;
           break;
         case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
           args = op->u.s_extended_operator.args;
           break;
         case DEMANGLE_COMPONENT_CAST:
           args = 1;
           break;
         }
 
       switch (args)
         {
+        case 0:
+          return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
+
         case 1:
           {
             struct demangle_component *operand;
+            int suffix = 0;
+
+            if (code && (code[0] == 'p' || code[0] == 'm')
+                && code[1] == code[0])
+              /* pp_ and mm_ are the prefix variants.  */
+              suffix = !d_check_char (di, '_');
+
             if (op->type == DEMANGLE_COMPONENT_CAST
                 && d_check_char (di, '_'))
-              operand = d_exprlist (di);
+              operand = d_exprlist (di, 'E');
             else
               operand = d_expression (di);
-            return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
-                                operand);
+
+            if (suffix)
+              /* Indicate the suffix variant for d_print_comp.  */
+              return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
+                                  d_make_comp (di,
+                                               DEMANGLE_COMPONENT_BINARY_ARGS,
+                                               operand, operand));
+            else
+              return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
+                                  operand);
           }
         case 2:
           {
             struct demangle_component *left;
             struct demangle_component *right;
-            const char *code = op->u.s_operator.op->code;
 
             left = d_expression (di);
             if (!strcmp (code, "cl"))
-              right = d_exprlist (di);
+              right = d_exprlist (di, 'E');
             else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
               {
                 right = d_unqualified_name (di);
                 if (d_peek_char (di) == 'I')
                   right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
                                        right, d_template_args (di));
               }
             else
               right = d_expression (di);
 
             return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
                                 d_make_comp (di,
                                              DEMANGLE_COMPONENT_BINARY_ARGS,
                                              left, right));
           }
         case 3:
           {
             struct demangle_component *first;
             struct demangle_component *second;
+            struct demangle_component *third;
 
-            first = d_expression (di);
-            second = d_expression (di);
+            if (!strcmp (code, "qu"))
+              {
+                /* ?: expression.  */
+                first = d_expression (di);
+                second = d_expression (di);
+                third = d_expression (di);
+              }
+            else if (code[0] == 'n')
+              {
+                /* new-expression.  */
+                if (code[1] != 'w' && code[1] != 'a')
+                  return NULL;
+                first = d_exprlist (di, '_');
+                second = cplus_demangle_type (di);
+                if (d_peek_char (di) == 'E')
+                  {
+                    d_advance (di, 1);
+                    third = NULL;
+                  }
+                else if (d_peek_char (di) == 'p'
+                         && d_peek_next_char (di) == 'i')
+                  {
+                    /* Parenthesized initializer.  */
+                    d_advance (di, 2);
+                    third = d_exprlist (di, 'E');
+                  }
+                else if (d_peek_char (di) == 'i'
+                         && d_peek_next_char (di) == 'l')
+                  /* initializer-list.  */
+                  third = d_expression (di);
+                else
+                  return NULL;
+              }
+            else
+              return NULL;
             return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
                                 d_make_comp (di,
                                              DEMANGLE_COMPONENT_TRINARY_ARG1,
                                              first,
                                              d_make_comp (di,
                                                           DEMANGLE_COMPONENT_TRINARY_ARG2,
-                                                          second,
-                                                          d_expression (di))));
+                                                          second, third)));
           }
         default:
           return NULL;
         }
     }
 }
 
 /* <expr-primary> ::= L <type> <(value) number> E
                   ::= L <type> <(value) float> E
                   ::= L <mangled-name> E
@@ skipping 658 matching lines @@
     case DEMANGLE_COMPONENT_PACK_EXPANSION:
       return NULL;
       
     case DEMANGLE_COMPONENT_LAMBDA:
     case DEMANGLE_COMPONENT_NAME:
     case DEMANGLE_COMPONENT_OPERATOR:
     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
     case DEMANGLE_COMPONENT_SUB_STD:
     case DEMANGLE_COMPONENT_CHARACTER:
     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
+    case DEMANGLE_COMPONENT_UNNAMED_TYPE:
       return NULL;
 
     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
       return d_find_pack (dpi, dc->u.s_extended_operator.name);
     case DEMANGLE_COMPONENT_CTOR:
       return d_find_pack (dpi, dc->u.s_ctor.name);
     case DEMANGLE_COMPONENT_DTOR:
       return d_find_pack (dpi, dc->u.s_dtor.name);
 
     default:
@@ skipping 21 matching lines @@
 
 /* DC is a component of a mangled expression.  Print it, wrapped in parens
    if needed.  */
 
 static void
 d_print_subexpr (struct d_print_info *dpi, int options,
                  const struct demangle_component *dc)
 {
   int simple = 0;
   if (dc->type == DEMANGLE_COMPONENT_NAME
+      || dc->type == DEMANGLE_COMPONENT_QUAL_NAME
+      || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
       || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
     simple = 1;
   if (!simple)
     d_append_char (dpi, '(');
   d_print_comp (dpi, options, dc);
   if (!simple)
     d_append_char (dpi, ')');
 }
 
 /* Subroutine to handle components.  */
@@ skipping 575 matching lines @@
           len = dpi->len;
           flush_count = dpi->flush_count;
           d_print_comp (dpi, options, d_right (dc));
           /* If that didn't print anything (which can happen with empty
              template argument packs), remove the comma and space.  */
           if (dpi->flush_count == flush_count && dpi->len == len)
             dpi->len -= 2;
         }
       return;
 
+    case DEMANGLE_COMPONENT_INITIALIZER_LIST:
+      {
+        struct demangle_component *type = d_left (dc);
+        struct demangle_component *list = d_right (dc);
+
+        if (type)
+          d_print_comp (dpi, options, type);
+        d_append_char (dpi, '{');
+        d_print_comp (dpi, options, list);
+        d_append_char (dpi, '}');
+      }
+      return;
+
     case DEMANGLE_COMPONENT_OPERATOR:
       {
-        char c;
+        const struct demangle_operator_info *op = dc->u.s_operator.op;
+        int len = op->len;
 
         d_append_string (dpi, "operator");
-        c = dc->u.s_operator.op->name[0];
-        if (IS_LOWER (c))
+        /* Add a space before new/delete.  */
+        if (IS_LOWER (op->name[0]))
           d_append_char (dpi, ' ');
-        d_append_buffer (dpi, dc->u.s_operator.op->name,
-                         dc->u.s_operator.op->len);
+        /* Omit a trailing space.  */
+        if (op->name[len-1] == ' ')
+          --len;
+        d_append_buffer (dpi, op->name, len);
         return;
       }
 
     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
       d_append_string (dpi, "operator ");
       d_print_comp (dpi, options, dc->u.s_extended_operator.name);
       return;
 
     case DEMANGLE_COMPONENT_CAST:
       d_append_string (dpi, "operator ");
       d_print_cast (dpi, options, dc);
       return;
 
+    case DEMANGLE_COMPONENT_NULLARY:
+      d_print_expr_op (dpi, options, d_left (dc));
+      return;
+
     case DEMANGLE_COMPONENT_UNARY:
-      if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
-          && d_left (dc)->u.s_operator.op->len == 1
-          && d_left (dc)->u.s_operator.op->name[0] == '&'
-          && d_right (dc)->type == DEMANGLE_COMPONENT_TYPED_NAME
-          && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_QUAL_NAME
-          && d_right (d_right (dc))->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
-        {
-          /* Address of a function (therefore in an expression context) must
-             have its argument list suppressed.
+      {
+        struct demangle_component *op = d_left (dc);
+        struct demangle_component *operand = d_right (dc);
+        const char *code = NULL;
 
-             unary operator ... dc
-               operator & ... d_left (dc)
-               typed name ... d_right (dc)
-                 qualified name ... d_left (d_right (dc))
-                   <names>
-                 function type ... d_right (d_right (dc))
-                   argument list
-                     <arguments>  */
+        if (op->type == DEMANGLE_COMPONENT_OPERATOR)
+          {
+            code = op->u.s_operator.op->code;
+            if (!strcmp (code, "ad"))
+              {
+                /* Don't print the argument list for the address of a
+                   function.  */
+                if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
+                    && d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME
+                    && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
+                  operand = d_left (operand);
+              }
+            if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
+              {
+                /* This indicates a suffix operator.  */
+                operand = d_left (operand);
+                d_print_subexpr (dpi, options, operand);
+                d_print_expr_op (dpi, options, op);
+                return;
+              }
+          }
 
-          d_print_expr_op (dpi, options, d_left (dc));
-          d_print_comp (dpi, options, d_left (d_right (dc)));
-          return;
-        }
-      else if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
-               && d_left (dc)->u.s_operator.op->len == 1
-               && d_left (dc)->u.s_operator.op->name[0] == '&'
-               && d_right (dc)->type == DEMANGLE_COMPONENT_QUAL_NAME)
-        {
-          /* Keep also already processed variant without the argument list.
-
-             unary operator ... dc
-               operator & ... d_left (dc)
-               qualified name ... d_right (dc)
-                 <names>  */
-
-          d_print_expr_op (dpi, options, d_left (dc));
-          d_print_comp (dpi, options, d_right (dc));
-          return;
-        }
-      else if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
-        d_print_expr_op (dpi, options, d_left (dc));
-      else
-        {
-          d_append_char (dpi, '(');
-          d_print_cast (dpi, options, d_left (dc));
-          d_append_char (dpi, ')');
-        }
-      d_print_subexpr (dpi, options, d_right (dc));
+        if (op->type != DEMANGLE_COMPONENT_CAST)
+          d_print_expr_op (dpi, options, op);
+        else
+          {
+            d_append_char (dpi, '(');
+            d_print_cast (dpi, options, op);
+            d_append_char (dpi, ')');
+          }
+        if (code && !strcmp (code, "gs"))
+          /* Avoid parens after '::'.  */
+          d_print_comp (dpi, options, operand);
+        else if (code && !strcmp (code, "st"))
+          /* Always print parens for sizeof (type).  */
+          {
+            d_append_char (dpi, '(');
+            d_print_comp (dpi, options, operand);
+            d_append_char (dpi, ')');
+          }
+        else
+          d_print_subexpr (dpi, options, operand);
+      }
       return;
 
     case DEMANGLE_COMPONENT_BINARY:
       if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
         {
           d_print_error (dpi);
           return;
         }
 
       /* We wrap an expression which uses the greater-than operator in
@@ skipping 44 matching lines @@
       d_print_error (dpi);
       return;
 
     case DEMANGLE_COMPONENT_TRINARY:
       if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
           || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
         {
           d_print_error (dpi);
           return;
         }
-      d_print_subexpr (dpi, options, d_left (d_right (dc)));
-      d_print_expr_op (dpi, options, d_left (dc));
-      d_print_subexpr (dpi, options, d_left (d_right (d_right (dc))));
-      d_append_string (dpi, " : ");
-      d_print_subexpr (dpi, options, d_right (d_right (d_right (dc))));
+      {
+        struct demangle_component *op = d_left (dc);
+        struct demangle_component *first = d_left (d_right (dc));
+        struct demangle_component *second = d_left (d_right (d_right (dc)));
+        struct demangle_component *third = d_right (d_right (d_right (dc)));
+
+        if (!strcmp (op->u.s_operator.op->code, "qu"))
+          {
+            d_print_subexpr (dpi, options, first);
+            d_print_expr_op (dpi, options, op);
+            d_print_subexpr (dpi, options, second);
+            d_append_string (dpi, " : ");
+            d_print_subexpr (dpi, options, third);
+          }
+        else
+          {
+            d_append_string (dpi, "new ");
+            if (d_left (first) != NULL)
+              {
+                d_print_subexpr (dpi, options, first);
+                d_append_char (dpi, ' ');
+              }
+            d_print_comp (dpi, options, second);
+            if (third)
+              d_print_subexpr (dpi, options, third);
+          }
+      }
       return;
 
     case DEMANGLE_COMPONENT_TRINARY_ARG1:
     case DEMANGLE_COMPONENT_TRINARY_ARG2:
       /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
       d_print_error (dpi);
       return;
 
     case DEMANGLE_COMPONENT_LITERAL:
     case DEMANGLE_COMPONENT_LITERAL_NEG:
@@ skipping 1173 matching lines @@
               fprintf (stderr, "Failed: %s\n", argv[i]);
 #endif
             }
         }
     }
 
   return 0;
 }
 
 #endif /* STANDALONE_DEMANGLER */